138 lines
4.6 KiB
Python
138 lines
4.6 KiB
Python
"""
|
|
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()
|
|
}
|