production-ready caching a

modules/__init__.py

@@ -7,6 +7,6 @@ from .retriever import Retriever
 from .analyzer import Analyzer
 from .citation import CitationManager
 from .formatter import OutputFormatter
-from .server_cache import server_status_cache
+from .server_cache import RedisServerStatusCache
 
-__all__ = ['InputHandler', 'Retriever', 'Analyzer', 'CitationManager', 'OutputFormatter', 'server_status_cache']
+__all__ = ['InputHandler', 'Retriever', 'Analyzer', 'CitationManager', 'OutputFormatter', 'RedisServerStatusCache']

modules/analyzer.py

@@ -3,7 +3,8 @@ from openai import OpenAI
 import requests
 import time
 import logging
-from modules.server_cache import server_status_cache
+from modules.server_cache import RedisServerStatusCache
+from modules.status_logger import log_server_status
 
 class Analyzer:
     def __init__(self, base_url, api_key):
@@ -15,9 +16,12 @@ class Analyzer:
         self.headers = {"Authorization": f"Bearer {api_key}"}
         self.cache_key = f"server_status_{base_url}"
         
+        # Connect to Redis cache
+        self.cache = RedisServerStatusCache()
+        
     def is_server_ready(self):
         # Check cache first
-        cached_status = server_status_cache.get(self.cache_key)
+        cached_status = self.cache.get(self.cache_key)
         if cached_status is not None:
             return cached_status
             
@@ -25,10 +29,12 @@ class Analyzer:
         try:
             response = requests.get(self.health_check_url, headers=self.headers, timeout=5)
             is_ready = response.status_code == 200
-            server_status_cache.set(self.cache_key, is_ready)
+            self.cache.set(self.cache_key, is_ready)
+            log_server_status(self.cache_key, is_ready)
             return is_ready
-        except requests.exceptions.RequestException:
-            server_status_cache.set(self.cache_key, False)
+        except requests.exceptions.RequestException as e:
+            self.cache.set(self.cache_key, False)
+            log_server_status(self.cache_key, False)
             return False
 
     def wait_for_server(self, timeout=180, interval=10):

modules/server_cache.py

@@ -1,22 +1,45 @@
 # modules/server_cache.py
 import time
+import redis
+import json
 
-class ServerStatusCache:
-    def __init__(self, ttl=300):  # 5 minutes default TTL
-        self.cache = {}
-        self.ttl = ttl
+class RedisServerStatusCache:
+    def __init__(self, host='localhost', port=6379, db=0, default_ttl=300):
+        try:
+            self.redis = redis.StrictRedis(host=host, port=port, db=db, decode_responses=True)
+            # Test connection
+            self.redis.ping()
+        except redis.ConnectionError:
+            # Fallback to in-memory cache if Redis is not available
+            self.redis = None
+            self.fallback_cache = {}
+        self.default_ttl = default_ttl
 
     def get(self, server_key):
-        if server_key in self.cache:
-            timestamp, status = self.cache[server_key]
-            if time.time() - timestamp < self.ttl:
-                return status
+        try:
+            if self.redis:
+                status = self.redis.get(f"server_status:{server_key}")
+                return json.loads(status) if status else None
             else:
-                del self.cache[server_key]  # Expired
-        return None
+                # Fallback to in-memory cache
+                entry = self.fallback_cache.get(server_key)
+                if entry:
+                    timestamp, status = entry
+                    if time.time() - timestamp < self.default_ttl:
+                        return status
+                    else:
+                        del self.fallback_cache[server_key]
+                return None
+        except Exception:
+            return None
 
-    def set(self, server_key, status):
-        self.cache[server_key] = (time.time(), status)
-
-# Global cache instance
-server_status_cache = ServerStatusCache()
+    def set(self, server_key, status, ttl=None):
+        try:
+            ttl = ttl or self.default_ttl
+            if self.redis:
+                self.redis.setex(f"server_status:{server_key}", ttl, json.dumps(status))
+            else:
+                # Fallback to in-memory cache
+                self.fallback_cache[server_key] = (time.time(), status)
+        except Exception:
+            pass  # Silently fail if cache is not available

modules/status_logger.py

@@ -0,0 +1,25 @@
+import logging
+import os
+from datetime import datetime
+
+STATUS_LOG_FILE = "server_status_log.csv"
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def log_server_status(server_key, status):
+    timestamp = datetime.now().isoformat()
+    status_str = "UP" if status else "DOWN"
+    
+    # Log to console
+    logging.info(f"Server {server_key} is {status_str}")
+    
+    # Log to file
+    try:
+        file_exists = os.path.exists(STATUS_LOG_FILE)
+        with open(STATUS_LOG_FILE, 'a') as f:
+            if not file_exists:
+                f.write("timestamp,server,status\n")
+            f.write(f"{timestamp},{server_key},{status_str}\n")
+    except Exception as e:
+        logging.error(f"Failed to log server status: {e}")

requirements.txt

@@ -1,5 +1,7 @@
+# requirements.txt
 gradio>=3.40.0
 tavily-python>=0.3.0
 openai>=1.0.0
 requests>=2.31.0
-pytest==8.3.3
+pytest==8.3.3
+redis>=4.0.0