claude-mpm 3.7.8__py3-none-any.whl → 3.9.0__py3-none-any.whl

claude_mpm/services/infrastructure/monitoring.py

@@ -0,0 +1,893 @@
+"""Advanced health monitoring system for claude-mpm Socket.IO server.
+
+This module provides comprehensive health checking capabilities including:
+- Process resource monitoring (CPU, memory, file descriptors)
+- Service-specific health markers
+- Configurable thresholds and intervals
+- Health status aggregation and history
+- Integration with automatic recovery mechanisms
+
+Design Principles:
+- Minimal performance impact through efficient polling
+- Extensible metric collection system
+- Circuit breaker integration for failure detection
+- Comprehensive logging for debugging and diagnostics
+"""
+
+import asyncio
+import logging
+import time
+import threading
+from abc import ABC, abstractmethod
+from collections import deque
+from dataclasses import dataclass, asdict
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Callable, Union
+import json
+import socket
+from claude_mpm.core.constants import ResourceLimits, TimeoutConfig
+
+try:
+    import psutil
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+    psutil = None
+
+
+class HealthStatus(Enum):
+    """Health status levels for monitoring."""
+    HEALTHY = "healthy"
+    WARNING = "warning"
+    CRITICAL = "critical"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class HealthMetric:
+    """Individual health metric data structure."""
+    name: str
+    value: Union[int, float, str, bool]
+    status: HealthStatus
+    threshold: Optional[Union[int, float]] = None
+    unit: Optional[str] = None
+    timestamp: float = None
+    message: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = time.time()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert metric to dictionary format."""
+        result = asdict(self)
+        result['status'] = self.status.value
+        result['timestamp_iso'] = datetime.fromtimestamp(self.timestamp, timezone.utc).isoformat()
+        return result
+
+
+@dataclass
+class HealthCheckResult:
+    """Result of a health check operation."""
+    overall_status: HealthStatus
+    metrics: List[HealthMetric]
+    timestamp: float
+    duration_ms: float
+    errors: List[str]
+    
+    def __post_init__(self):
+        if not hasattr(self, 'timestamp') or self.timestamp is None:
+            self.timestamp = time.time()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert health check result to dictionary format."""
+        return {
+            'overall_status': self.overall_status.value,
+            'metrics': [metric.to_dict() for metric in self.metrics],
+            'timestamp': self.timestamp,
+            'timestamp_iso': datetime.fromtimestamp(self.timestamp, timezone.utc).isoformat(),
+            'duration_ms': self.duration_ms,
+            'errors': self.errors,
+            'metric_count': len(self.metrics),
+            'healthy_metrics': len([m for m in self.metrics if m.status == HealthStatus.HEALTHY]),
+            'warning_metrics': len([m for m in self.metrics if m.status == HealthStatus.WARNING]),
+            'critical_metrics': len([m for m in self.metrics if m.status == HealthStatus.CRITICAL])
+        }
+
+
+class HealthChecker(ABC):
+    """Abstract base class for health checkers.
+    
+    Health checkers implement specific monitoring logic for different aspects
+    of the system (process resources, network connectivity, service health, etc.).
+    """
+    
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get the name of this health checker."""
+        pass
+    
+    @abstractmethod
+    async def check_health(self) -> List[HealthMetric]:
+        """Perform health check and return metrics."""
+        pass
+
+
+class ProcessResourceChecker(HealthChecker):
+    """Health checker for process resource usage.
+    
+    Monitors:
+    - CPU usage percentage
+    - Memory usage (RSS, VMS)
+    - File descriptor count
+    - Thread count
+    - Process status
+    """
+    
+    def __init__(self, pid: int, cpu_threshold: float = 80.0, 
+                 memory_threshold_mb: int = 500, fd_threshold: int = 1000):
+        """Initialize process resource checker.
+        
+        Args:
+            pid: Process ID to monitor
+            cpu_threshold: CPU usage threshold as percentage
+            memory_threshold_mb: Memory usage threshold in MB
+            fd_threshold: File descriptor count threshold
+        """
+        self.pid = pid
+        self.cpu_threshold = cpu_threshold
+        self.memory_threshold_mb = memory_threshold_mb
+        self.fd_threshold = fd_threshold
+        self.process = None
+        self.logger = logging.getLogger(f"{__name__}.ProcessResourceChecker")
+        
+        if PSUTIL_AVAILABLE:
+            try:
+                self.process = psutil.Process(pid)
+            except psutil.NoSuchProcess:
+                self.logger.warning(f"Process {pid} not found for monitoring")
+    
+    def get_name(self) -> str:
+        return f"process_resources_{self.pid}"
+    
+    async def check_health(self) -> List[HealthMetric]:
+        """Check process resource usage."""
+        metrics = []
+        
+        if not PSUTIL_AVAILABLE:
+            metrics.append(HealthMetric(
+                name="psutil_availability",
+                value=False,
+                status=HealthStatus.WARNING,
+                message="psutil not available for enhanced monitoring"
+            ))
+            return metrics
+        
+        if not self.process:
+            metrics.append(HealthMetric(
+                name="process_exists",
+                value=False,
+                status=HealthStatus.CRITICAL,
+                message=f"Process {self.pid} not found"
+            ))
+            return metrics
+        
+        try:
+            # Check if process still exists
+            if not self.process.is_running():
+                metrics.append(HealthMetric(
+                    name="process_exists",
+                    value=False,
+                    status=HealthStatus.CRITICAL,
+                    message=f"Process {self.pid} is no longer running"
+                ))
+                return metrics
+            
+            # Process status
+            status = self.process.status()
+            process_healthy = status not in [psutil.STATUS_ZOMBIE, psutil.STATUS_DEAD, psutil.STATUS_STOPPED]
+            metrics.append(HealthMetric(
+                name="process_status",
+                value=status,
+                status=HealthStatus.HEALTHY if process_healthy else HealthStatus.CRITICAL,
+                message=f"Process status: {status}"
+            ))
+            
+            # CPU usage
+            try:
+                cpu_percent = self.process.cpu_percent(interval=TimeoutConfig.CPU_SAMPLE_INTERVAL)
+                cpu_status = HealthStatus.HEALTHY
+                if cpu_percent > self.cpu_threshold:
+                    cpu_status = HealthStatus.WARNING if cpu_percent < self.cpu_threshold * 1.2 else HealthStatus.CRITICAL
+                
+                metrics.append(HealthMetric(
+                    name="cpu_usage_percent",
+                    value=round(cpu_percent, 2),
+                    status=cpu_status,
+                    threshold=self.cpu_threshold,
+                    unit="%"
+                ))
+            except Exception as e:
+                metrics.append(HealthMetric(
+                    name="cpu_usage_percent",
+                    value=-1,
+                    status=HealthStatus.UNKNOWN,
+                    message=f"Failed to get CPU usage: {e}"
+                ))
+            
+            # Memory usage
+            try:
+                memory_info = self.process.memory_info()
+                memory_mb = memory_info.rss / ResourceLimits.BYTES_TO_MB
+                memory_status = HealthStatus.HEALTHY
+                if memory_mb > self.memory_threshold_mb:
+                    memory_status = HealthStatus.WARNING if memory_mb < self.memory_threshold_mb * 1.2 else HealthStatus.CRITICAL
+                
+                metrics.append(HealthMetric(
+                    name="memory_usage_mb",
+                    value=round(memory_mb, 2),
+                    status=memory_status,
+                    threshold=self.memory_threshold_mb,
+                    unit="MB"
+                ))
+                
+                metrics.append(HealthMetric(
+                    name="memory_vms_mb",
+                    value=round(memory_info.vms / ResourceLimits.BYTES_TO_MB, 2),
+                    status=HealthStatus.HEALTHY,
+                    unit="MB"
+                ))
+            except Exception as e:
+                metrics.append(HealthMetric(
+                    name="memory_usage_mb",
+                    value=-1,
+                    status=HealthStatus.UNKNOWN,
+                    message=f"Failed to get memory usage: {e}"
+                ))
+            
+            # File descriptors (Unix only)
+            if hasattr(self.process, 'num_fds'):
+                try:
+                    fd_count = self.process.num_fds()
+                    fd_status = HealthStatus.HEALTHY
+                    if fd_count > self.fd_threshold:
+                        fd_status = HealthStatus.WARNING if fd_count < self.fd_threshold * 1.2 else HealthStatus.CRITICAL
+                    
+                    metrics.append(HealthMetric(
+                        name="file_descriptors",
+                        value=fd_count,
+                        status=fd_status,
+                        threshold=self.fd_threshold
+                    ))
+                except Exception as e:
+                    metrics.append(HealthMetric(
+                        name="file_descriptors",
+                        value=-1,
+                        status=HealthStatus.UNKNOWN,
+                        message=f"Failed to get file descriptor count: {e}"
+                    ))
+            
+            # Thread count
+            try:
+                thread_count = self.process.num_threads()
+                metrics.append(HealthMetric(
+                    name="thread_count",
+                    value=thread_count,
+                    status=HealthStatus.HEALTHY,
+                ))
+            except Exception as e:
+                metrics.append(HealthMetric(
+                    name="thread_count",
+                    value=-1,
+                    status=HealthStatus.UNKNOWN,
+                    message=f"Failed to get thread count: {e}"
+                ))
+            
+            # Process create time (for validation)
+            try:
+                create_time = self.process.create_time()
+                metrics.append(HealthMetric(
+                    name="process_start_time",
+                    value=create_time,
+                    status=HealthStatus.HEALTHY,
+                    unit="timestamp"
+                ))
+            except Exception as e:
+                metrics.append(HealthMetric(
+                    name="process_start_time",
+                    value=-1,
+                    status=HealthStatus.UNKNOWN,
+                    message=f"Failed to get process start time: {e}"
+                ))
+                
+        except psutil.NoSuchProcess:
+            metrics.append(HealthMetric(
+                name="process_exists",
+                value=False,
+                status=HealthStatus.CRITICAL,
+                message=f"Process {self.pid} no longer exists"
+            ))
+        except Exception as e:
+            self.logger.error(f"Error checking process health: {e}")
+            metrics.append(HealthMetric(
+                name="process_check_error",
+                value=str(e),
+                status=HealthStatus.UNKNOWN,
+                message=f"Unexpected error during process health check: {e}"
+            ))
+        
+        return metrics
+
+
+class NetworkConnectivityChecker(HealthChecker):
+    """Health checker for network connectivity.
+    
+    Monitors:
+    - Port availability and binding status
+    - Socket connection health
+    - Network interface status
+    """
+    
+    def __init__(self, host: str, port: int, timeout: float = 1.0):
+        """Initialize network connectivity checker.
+        
+        Args:
+            host: Host address to check
+            port: Port number to check
+            timeout: Connection timeout in seconds
+        """
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.logger = logging.getLogger(f"{__name__}.NetworkConnectivityChecker")
+    
+    def get_name(self) -> str:
+        return f"network_connectivity_{self.host}_{self.port}"
+    
+    async def check_health(self) -> List[HealthMetric]:
+        """Check network connectivity."""
+        metrics = []
+        
+        # Check port binding
+        try:
+            # Try to connect to the port
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(self.timeout)
+            result = sock.connect_ex((self.host, self.port))
+            sock.close()
+            
+            if result == 0:
+                metrics.append(HealthMetric(
+                    name="port_accessible",
+                    value=True,
+                    status=HealthStatus.HEALTHY,
+                    message=f"Port {self.port} is accessible on {self.host}"
+                ))
+            else:
+                metrics.append(HealthMetric(
+                    name="port_accessible",
+                    value=False,
+                    status=HealthStatus.CRITICAL,
+                    message=f"Port {self.port} is not accessible on {self.host}"
+                ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="port_accessible",
+                value=False,
+                status=HealthStatus.UNKNOWN,
+                message=f"Error checking port accessibility: {e}"
+            ))
+        
+        # Check if we can create a socket (resource availability)
+        try:
+            test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            test_sock.close()
+            metrics.append(HealthMetric(
+                name="socket_creation",
+                value=True,
+                status=HealthStatus.HEALTHY,
+                message="Socket creation successful"
+            ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="socket_creation",
+                value=False,
+                status=HealthStatus.CRITICAL,
+                message=f"Failed to create socket: {e}"
+            ))
+        
+        return metrics
+
+
+class ServiceHealthChecker(HealthChecker):
+    """Health checker for service-specific metrics.
+    
+    Monitors:
+    - Connected clients count
+    - Event processing rate
+    - Error rates
+    - Response times
+    """
+    
+    def __init__(self, service_stats: Dict[str, Any], 
+                 max_clients: int = 1000, max_error_rate: float = 0.1):
+        """Initialize service health checker.
+        
+        Args:
+            service_stats: Reference to service statistics dictionary
+            max_clients: Maximum allowed connected clients
+            max_error_rate: Maximum allowed error rate (0.0-1.0)
+        """
+        self.service_stats = service_stats
+        self.max_clients = max_clients
+        self.max_error_rate = max_error_rate
+        self.last_check_time = time.time()
+        self.last_events_processed = 0
+        self.logger = logging.getLogger(f"{__name__}.ServiceHealthChecker")
+    
+    def get_name(self) -> str:
+        return "service_health"
+    
+    async def check_health(self) -> List[HealthMetric]:
+        """Check service-specific health metrics."""
+        metrics = []
+        current_time = time.time()
+        
+        # Connected clients
+        try:
+            client_count = self.service_stats.get("clients_connected", 0)
+            client_status = HealthStatus.HEALTHY
+            if client_count > self.max_clients * 0.8:
+                client_status = HealthStatus.WARNING
+            if client_count > self.max_clients:
+                client_status = HealthStatus.CRITICAL
+            
+            metrics.append(HealthMetric(
+                name="connected_clients",
+                value=client_count,
+                status=client_status,
+                threshold=self.max_clients
+            ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="connected_clients",
+                value=-1,
+                status=HealthStatus.UNKNOWN,
+                message=f"Failed to get client count: {e}"
+            ))
+        
+        # Event processing rate
+        try:
+            events_processed = self.service_stats.get("events_processed", 0)
+            time_diff = current_time - self.last_check_time
+            
+            if time_diff > 0 and self.last_events_processed > 0:
+                event_rate = (events_processed - self.last_events_processed) / time_diff
+                metrics.append(HealthMetric(
+                    name="event_processing_rate",
+                    value=round(event_rate, 2),
+                    status=HealthStatus.HEALTHY,
+                    unit="events/sec"
+                ))
+            
+            self.last_events_processed = events_processed
+            
+            # Total events processed
+            metrics.append(HealthMetric(
+                name="total_events_processed",
+                value=events_processed,
+                status=HealthStatus.HEALTHY
+            ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="event_processing_rate",
+                value=-1,
+                status=HealthStatus.UNKNOWN,
+                message=f"Failed to calculate event rate: {e}"
+            ))
+        
+        # Error rate
+        try:
+            errors = self.service_stats.get("errors", 0)
+            total_events = self.service_stats.get("events_processed", 1)  # Avoid division by zero
+            error_rate = errors / max(total_events, 1)
+            
+            error_status = HealthStatus.HEALTHY
+            if error_rate > self.max_error_rate * 0.5:
+                error_status = HealthStatus.WARNING
+            if error_rate > self.max_error_rate:
+                error_status = HealthStatus.CRITICAL
+            
+            metrics.append(HealthMetric(
+                name="error_rate",
+                value=round(error_rate, 4),
+                status=error_status,
+                threshold=self.max_error_rate,
+                unit="ratio"
+            ))
+            
+            metrics.append(HealthMetric(
+                name="total_errors",
+                value=errors,
+                status=HealthStatus.HEALTHY if errors == 0 else HealthStatus.WARNING
+            ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="error_rate",
+                value=-1,
+                status=HealthStatus.UNKNOWN,
+                message=f"Failed to calculate error rate: {e}"
+            ))
+        
+        # Last activity timestamp
+        try:
+            last_activity = self.service_stats.get("last_activity")
+            if last_activity:
+                # Parse ISO timestamp or use as-is if numeric
+                if isinstance(last_activity, str):
+                    try:
+                        from dateutil.parser import parse
+                        last_activity_dt = parse(last_activity)
+                        last_activity_timestamp = last_activity_dt.timestamp()
+                    except ImportError:
+                        # Fallback: try to parse ISO format manually
+                        try:
+                            from datetime import datetime
+                            clean_timestamp = last_activity.rstrip('Z')
+                            last_activity_dt = datetime.fromisoformat(clean_timestamp.replace('T', ' '))
+                            last_activity_timestamp = last_activity_dt.timestamp()
+                        except Exception:
+                            # Final fallback: treat as current time
+                            last_activity_timestamp = current_time
+                else:
+                    last_activity_timestamp = float(last_activity)
+                
+                time_since_activity = current_time - last_activity_timestamp
+                activity_status = HealthStatus.HEALTHY
+                if time_since_activity > 300:  # 5 minutes
+                    activity_status = HealthStatus.WARNING
+                if time_since_activity > 1800:  # 30 minutes
+                    activity_status = HealthStatus.CRITICAL
+                
+                metrics.append(HealthMetric(
+                    name="time_since_last_activity",
+                    value=round(time_since_activity, 2),
+                    status=activity_status,
+                    unit="seconds"
+                ))
+            else:
+                metrics.append(HealthMetric(
+                    name="time_since_last_activity",
+                    value=-1,
+                    status=HealthStatus.WARNING,
+                    message="No last activity recorded"
+                ))
+        except Exception as e:
+            metrics.append(HealthMetric(
+                name="time_since_last_activity",
+                value=-1,
+                status=HealthStatus.UNKNOWN,
+                message=f"Failed to parse last activity: {e}"
+            ))
+        
+        self.last_check_time = current_time
+        return metrics
+
+
+class AdvancedHealthMonitor:
+    """Advanced health monitoring system with configurable checks and thresholds.
+    
+    Provides comprehensive health monitoring including:
+    - Multiple health checker integration
+    - Configurable check intervals and thresholds
+    - Health history tracking
+    - Status aggregation and reporting
+    - Integration with recovery systems
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize advanced health monitor.
+        
+        Args:
+            config: Configuration dictionary for health monitoring
+        """
+        self.config = config or {}
+        self.logger = logging.getLogger(f"{__name__}.AdvancedHealthMonitor")
+        
+        # Configuration with defaults
+        self.check_interval = self.config.get('check_interval', 30)
+        self.history_size = self.config.get('history_size', 100)
+        self.aggregation_window = self.config.get('aggregation_window', 300)  # 5 minutes
+        
+        # Health checkers
+        self.checkers: List[HealthChecker] = []
+        
+        # Health history
+        self.health_history: deque = deque(maxlen=self.history_size)
+        
+        # Monitoring state
+        self.monitoring = False
+        self.monitor_task: Optional[asyncio.Task] = None
+        self.last_check_result: Optional[HealthCheckResult] = None
+        
+        # Health callbacks for recovery integration
+        self.health_callbacks: List[Callable[[HealthCheckResult], None]] = []
+        
+        # Initialize metrics
+        self.monitoring_stats = {
+            'checks_performed': 0,
+            'checks_failed': 0,
+            'average_check_duration_ms': 0,
+            'last_check_timestamp': None
+        }
+        
+        self.logger.info("Advanced health monitor initialized")
+    
+    def add_checker(self, checker: HealthChecker) -> None:
+        """Add a health checker to the monitoring system."""
+        self.checkers.append(checker)
+        self.logger.info(f"Added health checker: {checker.get_name()}")
+    
+    def add_health_callback(self, callback: Callable[[HealthCheckResult], None]) -> None:
+        """Add a callback to be called when health checks complete.
+        
+        Args:
+            callback: Function to call with HealthCheckResult
+        """
+        self.health_callbacks.append(callback)
+        self.logger.debug(f"Added health callback: {callback.__name__}")
+    
+    async def perform_health_check(self) -> HealthCheckResult:
+        """Perform comprehensive health check using all registered checkers."""
+        start_time = time.time()
+        all_metrics = []
+        errors = []
+        
+        # Run all health checkers
+        for checker in self.checkers:
+            try:
+                checker_start = time.time()
+                metrics = await checker.check_health()
+                checker_duration = (time.time() - checker_start) * 1000
+                
+                all_metrics.extend(metrics)
+                self.logger.debug(f"Health checker {checker.get_name()} completed in {checker_duration:.2f}ms")
+                
+            except Exception as e:
+                error_msg = f"Health checker {checker.get_name()} failed: {e}"
+                errors.append(error_msg)
+                self.logger.error(error_msg)
+                
+                # Add error metric
+                all_metrics.append(HealthMetric(
+                    name=f"{checker.get_name()}_error",
+                    value=str(e),
+                    status=HealthStatus.UNKNOWN,
+                    message=error_msg
+                ))
+        
+        # Determine overall status
+        overall_status = self._determine_overall_status(all_metrics)
+        
+        # Create result
+        duration_ms = (time.time() - start_time) * 1000
+        result = HealthCheckResult(
+            overall_status=overall_status,
+            metrics=all_metrics,
+            timestamp=start_time,
+            duration_ms=duration_ms,
+            errors=errors
+        )
+        
+        # Update statistics
+        self.monitoring_stats['checks_performed'] += 1
+        if errors:
+            self.monitoring_stats['checks_failed'] += 1
+        
+        # Update average duration
+        current_avg = self.monitoring_stats['average_check_duration_ms']
+        checks_count = self.monitoring_stats['checks_performed']
+        self.monitoring_stats['average_check_duration_ms'] = (
+            (current_avg * (checks_count - 1) + duration_ms) / checks_count
+        )
+        self.monitoring_stats['last_check_timestamp'] = time.time()
+        
+        # Store in history
+        self.health_history.append(result)
+        self.last_check_result = result
+        
+        # Notify callbacks
+        for callback in self.health_callbacks:
+            try:
+                callback(result)
+            except Exception as e:
+                self.logger.error(f"Health callback {callback.__name__} failed: {e}")
+        
+        self.logger.debug(f"Health check completed: {overall_status.value} "
+                         f"({len(all_metrics)} metrics, {len(errors)} errors, "
+                         f"{duration_ms:.2f}ms)")
+        
+        return result
+    
+    def _determine_overall_status(self, metrics: List[HealthMetric]) -> HealthStatus:
+        """Determine overall health status from individual metrics."""
+        if not metrics:
+            return HealthStatus.UNKNOWN
+        
+        # Count metrics by status
+        status_counts = {status: 0 for status in HealthStatus}
+        for metric in metrics:
+            status_counts[metric.status] += 1
+        
+        # Determine overall status based on counts
+        total_metrics = len(metrics)
+        
+        # If any critical metrics, overall is critical
+        if status_counts[HealthStatus.CRITICAL] > 0:
+            return HealthStatus.CRITICAL
+        
+        # If more than 30% warning metrics, overall is warning
+        warning_ratio = status_counts[HealthStatus.WARNING] / total_metrics
+        if warning_ratio > 0.3:
+            return HealthStatus.WARNING
+        
+        # If any warning metrics but less than 30%, still healthy
+        if status_counts[HealthStatus.WARNING] > 0:
+            return HealthStatus.HEALTHY
+        
+        # If any unknown metrics, overall is unknown
+        if status_counts[HealthStatus.UNKNOWN] > 0:
+            return HealthStatus.UNKNOWN
+        
+        # All metrics healthy
+        return HealthStatus.HEALTHY
+    
+    def start_monitoring(self) -> None:
+        """Start continuous health monitoring."""
+        if self.monitoring:
+            self.logger.warning("Health monitoring is already running")
+            return
+        
+        self.monitoring = True
+        self.monitor_task = asyncio.create_task(self._monitoring_loop())
+        self.logger.info(f"Started health monitoring with {self.check_interval}s interval")
+    
+    async def stop_monitoring(self) -> None:
+        """Stop continuous health monitoring."""
+        if not self.monitoring:
+            return
+        
+        self.monitoring = False
+        if self.monitor_task:
+            self.monitor_task.cancel()
+            try:
+                await self.monitor_task
+            except asyncio.CancelledError:
+                pass
+            self.monitor_task = None
+        
+        self.logger.info("Stopped health monitoring")
+    
+    async def _monitoring_loop(self) -> None:
+        """Continuous health monitoring loop."""
+        try:
+            while self.monitoring:
+                try:
+                    await self.perform_health_check()
+                except Exception as e:
+                    self.logger.error(f"Error during health check: {e}")
+                
+                # Wait for next check
+                await asyncio.sleep(self.check_interval)
+        except asyncio.CancelledError:
+            self.logger.debug("Health monitoring loop cancelled")
+        except Exception as e:
+            self.logger.error(f"Health monitoring loop error: {e}")
+    
+    def get_current_status(self) -> Optional[HealthCheckResult]:
+        """Get the most recent health check result."""
+        return self.last_check_result
+    
+    def get_health_history(self, limit: Optional[int] = None) -> List[HealthCheckResult]:
+        """Get health check history.
+        
+        Args:
+            limit: Maximum number of results to return
+            
+        Returns:
+            List of health check results, newest first
+        """
+        history = list(self.health_history)
+        history.reverse()  # Newest first
+        
+        if limit:
+            history = history[:limit]
+        
+        return history
+    
+    def get_aggregated_status(self, window_seconds: Optional[int] = None) -> Dict[str, Any]:
+        """Get aggregated health status over a time window.
+        
+        Args:
+            window_seconds: Time window for aggregation (defaults to configured window)
+            
+        Returns:
+            Dictionary with aggregated health statistics
+        """
+        window_seconds = window_seconds or self.aggregation_window
+        current_time = time.time()
+        cutoff_time = current_time - window_seconds
+        
+        # Filter history to time window
+        recent_results = [
+            result for result in self.health_history
+            if result.timestamp >= cutoff_time
+        ]
+        
+        if not recent_results:
+            return {
+                'period': 'no_data',
+                'window_seconds': window_seconds,
+                'checks_count': 0,
+                'overall_status': HealthStatus.UNKNOWN.value
+            }
+        
+        # Aggregate statistics
+        status_counts = {status: 0 for status in HealthStatus}
+        total_metrics = 0
+        total_errors = 0
+        total_duration_ms = 0
+        
+        for result in recent_results:
+            status_counts[result.overall_status] += 1
+            total_metrics += len(result.metrics)
+            total_errors += len(result.errors)
+            total_duration_ms += result.duration_ms
+        
+        checks_count = len(recent_results)
+        
+        # Determine aggregated status
+        if status_counts[HealthStatus.CRITICAL] > 0:
+            aggregated_status = HealthStatus.CRITICAL
+        elif status_counts[HealthStatus.WARNING] > checks_count * 0.3:
+            aggregated_status = HealthStatus.WARNING
+        elif status_counts[HealthStatus.UNKNOWN] > checks_count * 0.5:
+            aggregated_status = HealthStatus.UNKNOWN
+        else:
+            aggregated_status = HealthStatus.HEALTHY
+        
+        return {
+            'period': f'last_{window_seconds}_seconds',
+            'window_seconds': window_seconds,
+            'checks_count': checks_count,
+            'overall_status': aggregated_status.value,
+            'status_distribution': {status.value: count for status, count in status_counts.items()},
+            'average_metrics_per_check': round(total_metrics / checks_count, 2) if checks_count > 0 else 0,
+            'total_errors': total_errors,
+            'average_duration_ms': round(total_duration_ms / checks_count, 2) if checks_count > 0 else 0,
+            'monitoring_stats': dict(self.monitoring_stats)
+        }
+    
+    def export_diagnostics(self) -> Dict[str, Any]:
+        """Export comprehensive diagnostics information."""
+        return {
+            'monitor_info': {
+                'check_interval': self.check_interval,
+                'history_size': self.history_size,
+                'aggregation_window': self.aggregation_window,
+                'monitoring_active': self.monitoring,
+                'checkers_count': len(self.checkers),
+                'callbacks_count': len(self.health_callbacks)
+            },
+            'checkers': [checker.get_name() for checker in self.checkers],
+            'current_status': self.last_check_result.to_dict() if self.last_check_result else None,
+            'aggregated_status': self.get_aggregated_status(),
+            'monitoring_stats': dict(self.monitoring_stats),
+            'history_summary': {
+                'total_checks': len(self.health_history),
+                'oldest_check': self.health_history[0].timestamp if self.health_history else None,
+                'newest_check': self.health_history[-1].timestamp if self.health_history else None
+            }
+        }