debugging web ui

COBY/caching/redis_manager.py

@@ -3,7 +3,7 @@ Simple Redis manager stub.
 """
 
 import logging
-from typing import Any, Optional
+from typing import Any, Optional, List, Dict
 
 logger = logging.getLogger(__name__)
 
@@ -14,6 +14,12 @@ class RedisManager:
     def __init__(self):
         self.connected = False
         self.cache = {}  # In-memory cache as fallback
+        self.stats = {
+            'hits': 0,
+            'misses': 0,
+            'sets': 0,
+            'deletes': 0
+        }
         
     async def connect(self):
         """Connect to Redis (stub)"""
@@ -28,22 +34,88 @@ class RedisManager:
         """Disconnect from Redis"""
         self.connected = False
         
+    async def close(self):
+        """Close Redis connection (alias for disconnect)"""
+        await self.disconnect()
+        
     def is_connected(self) -> bool:
         """Check if connected"""
         return self.connected
         
+    async def ping(self) -> bool:
+        """Ping Redis to check connection"""
+        return self.connected
+        
     async def set(self, key: str, value: Any, ttl: Optional[int] = None):
         """Set value in cache"""
         self.cache[key] = value
+        self.stats['sets'] += 1
         logger.debug(f"Cached key: {key}")
         
     async def get(self, key: str) -> Optional[Any]:
         """Get value from cache"""
-        return self.cache.get(key)
+        value = self.cache.get(key)
+        if value is not None:
+            self.stats['hits'] += 1
+        else:
+            self.stats['misses'] += 1
+        return value
         
     async def delete(self, key: str):
         """Delete key from cache"""
         self.cache.pop(key, None)
+        self.stats['deletes'] += 1
+        
+    async def keys(self, pattern: str) -> List[str]:
+        """Get keys matching pattern"""
+        if pattern.endswith('*'):
+            prefix = pattern[:-1]
+            return [key for key in self.cache.keys() if key.startswith(prefix)]
+        return [key for key in self.cache.keys() if key == pattern]
+    
+    async def get_heatmap(self, symbol: str, exchange: Optional[str] = None) -> Optional[Any]:
+        """Get heatmap data for symbol"""
+        key = f"heatmap:{symbol}:{exchange or 'consolidated'}"
+        return await self.get(key)
+    
+    async def get_orderbook(self, symbol: str, exchange: str) -> Optional[Any]:
+        """Get order book data for symbol on exchange"""
+        key = f"orderbook:{symbol}:{exchange}"
+        return await self.get(key)
+    
+    async def get_metrics(self, symbol: str, exchange: str) -> Optional[Any]:
+        """Get metrics data for symbol on exchange"""
+        key = f"metrics:{symbol}:{exchange}"
+        return await self.get(key)
+    
+    async def get_exchange_status(self, exchange: str) -> Optional[Any]:
+        """Get exchange status"""
+        key = f"st:{exchange}"
+        return await self.get(key)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        total_requests = self.stats['hits'] + self.stats['misses']
+        hit_rate = self.stats['hits'] / max(1, total_requests)
+        
+        return {
+            'hits': self.stats['hits'],
+            'misses': self.stats['misses'],
+            'sets': self.stats['sets'],
+            'deletes': self.stats['deletes'],
+            'hit_rate': hit_rate,
+            'total_keys': len(self.cache),
+            'connected': self.connected
+        }
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Get Redis health status"""
+        return {
+            'connected': self.connected,
+            'total_keys': len(self.cache),
+            'memory_usage': 'N/A (stub mode)',
+            'uptime': 'N/A (stub mode)'
+        }
 
 
 # Global instance