CBCFacil v8.0 - Refactored with AMD GPU support

services/metrics_collector.py

@@ -0,0 +1,137 @@
+"""
+Performance metrics collector for CBCFacil
+"""
+import time
+import threading
+import psutil
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime, timedelta
+from contextlib import contextmanager
+
+
+class MetricsCollector:
+    """Collect and aggregate performance metrics"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self._start_time = time.time()
+        self._request_count = 0
+        self._error_count = 0
+        self._total_latency = 0.0
+        self._latencies = []
+        self._lock = threading.Lock()
+        self._process = psutil.Process()
+    
+    def record_request(self, latency: float, success: bool = True) -> None:
+        """Record a request with latency"""
+        with self._lock:
+            self._request_count += 1
+            self._total_latency += latency
+            self._latencies.append(latency)
+            
+            # Keep only last 1000 latencies for memory efficiency
+            if len(self._latencies) > 1000:
+                self._latencies = self._latencies[-1000:]
+            
+            if not success:
+                self._error_count += 1
+    
+    def get_latency_percentiles(self) -> Dict[str, float]:
+        """Calculate latency percentiles"""
+        with self._lock:
+            if not self._latencies:
+                return {"p50": 0, "p95": 0, "p99": 0}
+            
+            sorted_latencies = sorted(self._latencies)
+            n = len(sorted_latencies)
+            
+            return {
+                "p50": sorted_latencies[int(n * 0.50)],
+                "p95": sorted_latencies[int(n * 0.95)],
+                "p99": sorted_latencies[int(n * 0.99)]
+            }
+    
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Get system resource metrics"""
+        try:
+            memory = self._process.memory_info()
+            cpu_percent = self._process.cpu_percent(interval=0.1)
+            
+            return {
+                "cpu_percent": cpu_percent,
+                "memory_rss_mb": memory.rss / 1024 / 1024,
+                "memory_vms_mb": memory.vms / 1024 / 1024,
+                "thread_count": self._process.num_threads(),
+                "open_files": self._process.open_files(),
+            }
+        except Exception as e:
+            self.logger.warning(f"Error getting system metrics: {e}")
+            return {}
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """Get metrics summary"""
+        with self._lock:
+            uptime = time.time() - self._start_time
+            latency_pcts = self.get_latency_percentiles()
+            
+            return {
+                "uptime_seconds": round(uptime, 2),
+                "total_requests": self._request_count,
+                "error_count": self._error_count,
+                "error_rate": round(self._error_count / max(1, self._request_count) * 100, 2),
+                "requests_per_second": round(self._request_count / max(1, uptime), 2),
+                "average_latency_ms": round(self._total_latency / max(1, self._request_count) * 1000, 2),
+                "latency_p50_ms": round(latency_pcts["p50"] * 1000, 2),
+                "latency_p95_ms": round(latency_pcts["p95"] * 1000, 2),
+                "latency_p99_ms": round(latency_pcts["p99"] * 1000, 2),
+            }
+    
+    def reset(self) -> None:
+        """Reset metrics"""
+        with self._lock:
+            self._request_count = 0
+            self._error_count = 0
+            self._total_latency = 0.0
+            self._latencies = []
+            self._start_time = time.time()
+
+
+class LatencyTracker:
+    """Context manager for tracking operation latency"""
+    
+    def __init__(self, collector: MetricsCollector, operation: str):
+        self.collector = collector
+        self.operation = operation
+        self.start_time: Optional[float] = None
+        self.success = True
+    
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        latency = time.time() - self.start_time
+        success = exc_type is None
+        self.collector.record_request(latency, success)
+        return False  # Don't suppress exceptions
+
+
+# Global metrics collector
+metrics_collector = MetricsCollector()
+
+
+@contextmanager
+def track_latency(operation: str = "unknown"):
+    """Convenience function for latency tracking"""
+    with LatencyTracker(metrics_collector, operation):
+        yield
+
+
+def get_performance_report() -> Dict[str, Any]:
+    """Generate comprehensive performance report"""
+    return {
+        "metrics": metrics_collector.get_summary(),
+        "system": metrics_collector.get_system_metrics(),
+        "timestamp": datetime.utcnow().isoformat()
+    }