Add comprehensive Redis connection debugging and network testing scripts

core/redis_client.py

@@ -1,12 +1,13 @@
 import redis
 import logging
 import time
+import ssl
 from typing import Optional
 
 logger = logging.getLogger(__name__)
 
 class RedisClient:
-    """Hardcoded Redis client with new database configuration"""
+    """Hardcoded Redis client with comprehensive debugging"""
     
     _instance = None
     _redis_client = None
@@ -22,35 +23,112 @@ class RedisClient:
             self._connect()
 
     def _connect(self):
-        """Establish Redis connection with new hardcoded configuration"""
-        logger.info("Attempting Redis connection with new hardcoded values")
-        logger.info("  Host: redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com")
-        logger.info("  Port: 16717")
-        logger.info("  Username: default")
-        logger.info("  Password: [REDACTED]")
+        """Establish Redis connection with comprehensive debugging"""
+        logger.info("=== Redis Connection Debug Information ===")
+        host = 'redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com'
+        port = 16717
+        username = "default"
+        password = "bNQGmfkB2fRo4KrT3UXwhAUEUmgDClx7"
+        
+        logger.info(f"Host: {host}")
+        logger.info(f"Port: {port}")
+        logger.info(f"Username: {username}")
+        logger.info(f"Password: {'*' * len(password) if password else 'None'}")
+        logger.info("========================================")
 
+        # Try different SSL configurations
+        ssl_configs = [
+            {
+                'name': 'Standard SSL with cert validation',
+                'ssl': True,
+                'ssl_cert_reqs': 'required'
+            },
+            {
+                'name': 'SSL without cert validation',
+                'ssl': True,
+                'ssl_cert_reqs': None
+            },
+            {
+                'name': 'SSL with custom context',
+                'ssl': True,
+                'ssl_cert_reqs': ssl.CERT_REQUIRED,
+                'ssl_context': ssl.create_default_context()
+            }
+        ]
+
+        for i, config in enumerate(ssl_configs, 1):
+            logger.info(f"\n--- Trying SSL Configuration {i}: {config['name']} ---")
+            try:
+                redis_config = {
+                    'host': host,
+                    'port': port,
+                    'username': username,
+                    'password': password,
+                    'decode_responses': True,
+                    'socket_connect_timeout': 15,
+                    'socket_timeout': 15,
+                    'health_check_interval': 30,
+                    'retry_on_timeout': True
+                }
+                
+                # Add SSL configuration
+                redis_config.update({k: v for k, v in config.items() if k != 'name'})
+                
+                logger.info(f"Creating Redis client with config: {redis_config}")
+                self._redis_client = redis.Redis(**redis_config)
+                
+                logger.info("Attempting to ping Redis...")
+                result = self._redis_client.ping()
+                logger.info(f"Ping result: {result}")
+                
+                # Test set/get
+                logger.info("Testing set/get operations...")
+                self._redis_client.set('debug_test_key', 'debug_test_value')
+                value = self._redis_client.get('debug_test_key')
+                self._redis_client.delete('debug_test_key')
+                
+                if value == 'debug_test_value':
+                    logger.info("✅ Set/Get test successful!")
+                    logger.info(f"✅ Successfully connected with SSL configuration: {config['name']}")
+                    return
+                else:
+                    logger.warning("❌ Set/Get test failed")
+                    
+            except Exception as e:
+                logger.error(f"❌ Failed with SSL configuration {config['name']}: {e}")
+                logger.error(f"Error type: {type(e).__name__}")
+                import traceback
+                logger.error(f"Traceback: {traceback.format_exc()}")
+
+        # If all SSL configurations fail, try without SSL
+        logger.info("\n--- Trying without SSL as last resort ---")
         try:
-            logger.info("Connecting to NEW Redis Cloud with hardcoded configuration")
             self._redis_client = redis.Redis(
-                host='redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com',  # NEW HOST
-                port=16717,                                                    # NEW PORT
-                username="default",
-                password="bNQGmfkB2fRo4KrT3UXwhAUEUmgDClx7",                   # NEW PASSWORD
+                host=host,
+                port=port,
+                username=username,
+                password=password,
                 decode_responses=True,
                 socket_connect_timeout=15,
                 socket_timeout=15,
-                ssl=True,
                 health_check_interval=30,
                 retry_on_timeout=True
+                # No SSL parameters
             )
             
-            self._redis_client.ping()
-            logger.info("Successfully connected to NEW Redis Cloud with hardcoded configuration")
+            result = self._redis_client.ping()
+            logger.info(f"✅ Non-SSL connection successful! Ping result: {result}")
             return
             
         except Exception as e:
-            logger.error(f"Redis connection failed: {e}")
-            self._redis_client = None
+            logger.error(f"❌ Non-SSL connection also failed: {e}")
+            logger.error(f"Error type: {type(e).__name__}")
+            import traceback
+            logger.error(f"Traceback: {traceback.format_exc()}")
+
+        # If we get here, all connection attempts failed
+        logger.error("💥 All Redis connection attempts failed!")
+        self._redis_client = None
 
     def get_client(self) -> Optional[redis.Redis]:
         """Get Redis client instance"""
@@ -63,7 +141,8 @@ class RedisClient:
         try:
             self._redis_client.ping()
             return True
-        except:
+        except Exception as e:
+            logger.error(f"Redis health check failed: {e}")
             return False
 
     def reconnect(self):

debug_redis_connection.py

@@ -0,0 +1,54 @@
+import sys
+import logging
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+# Set up logging to see debug information
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+from core.redis_client import redis_client
+
+def main():
+    """Debug Redis connection issues"""
+    print("=== Redis Connection Debug Test ===")
+    
+    # Test the connection
+    client = redis_client.get_client()
+    
+    if client is None:
+        print("❌ Redis client is None - connection failed")
+        return 1
+    
+    try:
+        print("Testing ping...")
+        result = client.ping()
+        print(f"✅ Ping successful: {result}")
+        
+        print("Testing set/get...")
+        client.set('debug_test', 'success')
+        value = client.get('debug_test')
+        client.delete('debug_test')
+        
+        if value == 'success':
+            print("✅ Set/Get test successful!")
+            print("🎉 Redis connection is working!")
+            return 0
+        else:
+            print("❌ Set/Get test failed")
+            return 1
+            
+    except Exception as e:
+        print(f"❌ Redis operation failed: {e}")
+        import traceback
+        print(f"Traceback: {traceback.format_exc()}")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = main()
+    sys.exit(exit_code)

test_network_connectivity.py

@@ -0,0 +1,53 @@
+import socket
+import ssl
+
+def test_tcp_connection(host, port):
+    """Test basic TCP connection to host:port"""
+    print(f"Testing TCP connection to {host}:{port}...")
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(10)
+        result = sock.connect_ex((host, port))
+        sock.close()
+        
+        if result == 0:
+            print("✅ TCP connection successful")
+            return True
+        else:
+            print(f"❌ TCP connection failed with error code: {result}")
+            return False
+    except Exception as e:
+        print(f"❌ TCP connection failed: {e}")
+        return False
+
+def test_ssl_connection(host, port):
+    """Test SSL connection to host:port"""
+    print(f"Testing SSL connection to {host}:{port}...")
+    try:
+        context = ssl.create_default_context()
+        with socket.create_connection((host, port), timeout=10) as sock:
+            with context.wrap_socket(sock, server_hostname=host) as ssock:
+                print(f"✅ SSL connection successful")
+                print(f"SSL version: {ssock.version()}")
+                return True
+    except Exception as e:
+        print(f"❌ SSL connection failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    host = 'redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com'
+    port = 16717
+    
+    print("=== Network Connectivity Tests ===")
+    
+    tcp_result = test_tcp_connection(host, port)
+    print()
+    ssl_result = test_ssl_connection(host, port)
+    
+    print("\n=== Summary ===")
+    if tcp_result and ssl_result:
+        print("✅ All network tests passed")
+    elif tcp_result:
+        print("⚠️  TCP connection works but SSL failed")
+    else:
+        print("❌ Network connectivity issues detected")