Update src/monitoring_system.py

src/monitoring_system.py

@@ -20,7 +20,6 @@ except ImportError:
 
 @dataclass
 class InferenceMetrics:
-    """Data class for inference metrics"""
     model_name: str
     processing_time_ms: float
     input_tokens: int
@@ -38,7 +37,6 @@ class InferenceMetrics:
 
 @dataclass
 class SystemMetrics:
-    """Data class for system metrics"""
     timestamp: datetime
     cpu_percent: float
     memory_percent: float
@@ -52,11 +50,6 @@ class SystemMetrics:
     active_threads: int
 
 class ComprehensiveMonitor:
-    """
-    Comprehensive monitoring system for performance tracking, metrics, and alerts.
-    Provides real-time monitoring of AI system performance and health.
-    """
-    
     def __init__(self, prometheus_port: int = 8001, metrics_retention_hours: int = 24):
         self.inference_metrics: List[InferenceMetrics] = []
         self.system_metrics: List[SystemMetrics] = []
@@ -70,19 +63,19 @@ class ComprehensiveMonitor:
         self.alert_callbacks = []
         
         self.prometheus_metrics = {}
+        
+        self.setup_logging()
+        
         if PROMETHEUS_AVAILABLE:
             self.setup_prometheus_metrics()
         
-        self.setup_logging()
         self.start_monitoring()
     
     def setup_logging(self):
-        """Setup monitoring logging"""
         self.logger = logging.getLogger(__name__)
         self.logger.setLevel(logging.INFO)
     
     def setup_prometheus_metrics(self):
-        """Setup Prometheus metrics"""
         try:
             self.prometheus_metrics = {
                 'inference_requests_total': Counter(
@@ -146,14 +139,12 @@ class ComprehensiveMonitor:
             self.logger.warning(f"Could not start Prometheus server: {e}")
     
     def start_monitoring(self):
-        """Start background monitoring"""
         self.monitoring_active = True
         self.monitoring_thread = threading.Thread(target=self._monitoring_loop, daemon=True)
         self.monitoring_thread.start()
         self.logger.info("Background monitoring started")
     
     def _monitoring_loop(self):
-        """Background monitoring loop"""
         iteration = 0
         while self.monitoring_active:
             try:
@@ -178,7 +169,6 @@ class ComprehensiveMonitor:
                 time.sleep(60)
     
     def get_system_metrics(self) -> SystemMetrics:
-        """Get current system metrics"""
         try:
             cpu_percent = psutil.cpu_percent(interval=1)
             
@@ -235,7 +225,6 @@ class ComprehensiveMonitor:
             )
     
     def update_prometheus_gauges(self, system_metrics: SystemMetrics):
-        """Update Prometheus gauges with system metrics"""
         try:
             self.prometheus_metrics['system_cpu_percent'].set(system_metrics.cpu_percent)
             self.prometheus_metrics['system_memory_percent'].set(system_metrics.memory_percent)
@@ -258,7 +247,6 @@ class ComprehensiveMonitor:
             self.logger.error(f"Error updating Prometheus gauges: {e}")
     
     def record_inference(self, metrics: Dict):
-        """Record inference metrics"""
         try:
             inference_metrics = InferenceMetrics(
                 model_name=metrics.get('model_name', 'unknown'),
@@ -307,12 +295,10 @@ class ComprehensiveMonitor:
             self.logger.error(f"Error recording inference metrics: {e}")
     
     def get_recent_metrics(self, minutes: int = 5) -> List[InferenceMetrics]:
-        """Get metrics from recent time window"""
         cutoff = datetime.now() - timedelta(minutes=minutes)
         return [m for m in self.inference_metrics if m.timestamp > cutoff]
     
     def get_average_response_time(self, minutes: int = 30) -> float:
-        """Get average response time for successful requests"""
         recent_metrics = self.get_recent_metrics(minutes)
         successful_metrics = [m for m in recent_metrics if m.success]
         
@@ -322,7 +308,6 @@ class ComprehensiveMonitor:
         return sum(m.processing_time_ms for m in successful_metrics) / len(successful_metrics)
     
     def get_response_time_percentile(self, percentile: float, minutes: int = 30) -> float:
-        """Get percentile response time"""
         recent_metrics = self.get_recent_metrics(minutes)
         successful_metrics = [m for m in recent_metrics if m.success]
         
@@ -336,7 +321,6 @@ class ComprehensiveMonitor:
         return processing_times[index] if index < len(processing_times) else processing_times[-1]
     
     def get_error_rate(self, minutes: int = 30) -> float:
-        """Get error rate percentage"""
         recent_metrics = self.get_recent_metrics(minutes)
         if not recent_metrics:
             return 0.0
@@ -345,7 +329,6 @@ class ComprehensiveMonitor:
         return (errors / len(recent_metrics)) * 100
     
     def get_throughput(self, minutes: int = 5) -> float:
-        """Get requests per minute"""
         recent_metrics = self.get_recent_metrics(minutes)
         if not recent_metrics or minutes == 0:
             return 0.0
@@ -353,7 +336,6 @@ class ComprehensiveMonitor:
         return len(recent_metrics) / minutes
     
     def get_cache_hit_rate(self, minutes: int = 30) -> float:
-        """Get cache hit rate percentage"""
         recent_metrics = self.get_recent_metrics(minutes)
         if not recent_metrics:
             return 0.0
@@ -362,11 +344,9 @@ class ComprehensiveMonitor:
         return (cache_hits / len(recent_metrics)) * 100
     
     def get_uptime(self) -> float:
-        """Get system uptime in seconds"""
         return (datetime.now() - self.start_time).total_seconds()
     
     def check_alerts(self, system_metrics: SystemMetrics):
-        """Check system metrics against alert thresholds"""
         current_alerts = []
         
         if system_metrics.cpu_percent > 85:
@@ -432,7 +412,6 @@ class ComprehensiveMonitor:
                 self.alerts.append(alert)
     
     def is_new_alert(self, alert: Dict) -> bool:
-        """Check if this is a new alert (not recently triggered)"""
         recent_threshold = datetime.now() - timedelta(minutes=5)
         recent_alerts = [a for a in self.alerts 
                         if a['metric'] == alert['metric'] 
@@ -440,7 +419,6 @@ class ComprehensiveMonitor:
         return len(recent_alerts) == 0
     
     def trigger_alert(self, alert: Dict):
-        """Trigger alert notification"""
         alert['timestamp'] = datetime.now()
         alert['alert_id'] = hashlib.md5(f"{alert['metric']}_{alert['timestamp']}".encode()).hexdigest()[:8]
         
@@ -453,11 +431,9 @@ class ComprehensiveMonitor:
                 self.logger.error(f"Error in alert callback: {e}")
     
     def add_alert_callback(self, callback):
-        """Add callback function for alert notifications"""
         self.alert_callbacks.append(callback)
     
     def log_system_summary(self):
-        """Log periodic system summary"""
         summary = self.get_performance_summary(timedelta(minutes=5))
         
         if summary:
@@ -471,7 +447,6 @@ class ComprehensiveMonitor:
             )
     
     def get_performance_summary(self, time_window: timedelta) -> Dict[str, Any]:
-        """Get comprehensive performance summary"""
         recent_metrics = self.get_recent_metrics(time_window.total_seconds() / 60)
         recent_system = [m for m in self.system_metrics 
                         if m.timestamp > datetime.now() - time_window]
@@ -508,7 +483,6 @@ class ComprehensiveMonitor:
         return summary
     
     def cleanup_old_metrics(self):
-        """Clean up old metrics to prevent memory issues"""
         cutoff = datetime.now() - timedelta(hours=self.metrics_retention_hours)
         
         self.inference_metrics = [m for m in self.inference_metrics if m.timestamp > cutoff]
@@ -516,7 +490,6 @@ class ComprehensiveMonitor:
         self.alerts = [a for a in self.alerts if a.get('timestamp', datetime.min) > cutoff - timedelta(hours=24)]
     
     def get_system_health(self) -> Dict[str, Any]:
-        """Get comprehensive system health status"""
         performance_summary = self.get_performance_summary(timedelta(minutes=30))
         
         health_status = "healthy"
@@ -539,14 +512,12 @@ class ComprehensiveMonitor:
         }
     
     def stop_monitoring(self):
-        """Stop the monitoring system"""
         self.monitoring_active = False
         if self.monitoring_thread:
             self.monitoring_thread.join(timeout=5)
         self.logger.info("Monitoring system stopped")
     
     def export_metrics(self, filename: str, time_window: timedelta = timedelta(hours=24)):
-        """Export metrics to JSON file for analysis"""
         try:
             metrics_data = {
                 'export_timestamp': datetime.now().isoformat(),
@@ -589,7 +560,6 @@ class ComprehensiveMonitor:
             self.logger.error(f"Error exporting metrics: {e}")
     
     def get_prometheus_metrics(self) -> str:
-        """Get Prometheus metrics as string"""
         if not PROMETHEUS_AVAILABLE:
             return "# Prometheus client not available\n"
         
@@ -600,7 +570,6 @@ class ComprehensiveMonitor:
             return f"# Error generating metrics: {e}\n"
     
     def reset_metrics(self):
-        """Reset all metrics (for testing)"""
         self.inference_metrics.clear()
         self.system_metrics.clear()
         self.alerts.clear()