claude-mpm 4.1.4__py3-none-any.whl → 4.1.6__py3-none-any.whl

claude_mpm/services/infrastructure/monitoring/legacy.py

@@ -0,0 +1,203 @@
+"""Legacy compatibility wrappers for monitoring classes.
+
+Provides backward compatibility for existing code using the old monitoring API.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from .aggregator import MonitoringAggregatorService
+from .base import HealthChecker, HealthMetric
+from .network import NetworkHealthService
+from .process import ProcessHealthService
+from .service import ServiceHealthService
+
+
+class ProcessResourceChecker(HealthChecker):
+    """Legacy wrapper for ProcessHealthService.
+
+    Maintains backward compatibility with existing code.
+    """
+
+    def __init__(
+        self,
+        pid: int,
+        cpu_threshold: float = 80.0,
+        memory_threshold_mb: int = 500,
+        fd_threshold: int = 1000,
+    ):
+        """Initialize legacy process resource checker."""
+        self.service = ProcessHealthService(
+            pid=pid,
+            cpu_threshold=cpu_threshold,
+            memory_threshold_mb=memory_threshold_mb,
+            fd_threshold=fd_threshold,
+        )
+        self.pid = pid
+
+    def get_name(self) -> str:
+        """Get checker name."""
+        return f"process_resources_{self.pid}"
+
+    async def check_health(self) -> List[HealthMetric]:
+        """Perform health check."""
+        return await self.service.check_health()
+
+
+class NetworkConnectivityChecker(HealthChecker):
+    """Legacy wrapper for NetworkHealthService.
+
+    Maintains backward compatibility with existing code.
+    """
+
+    def __init__(self, host: str, port: int, timeout: float = 1.0):
+        """Initialize legacy network connectivity checker."""
+        self.service = NetworkHealthService(default_timeout=timeout)
+        self.service.add_endpoint(host, port, f"{host}_{port}", timeout)
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+
+    def get_name(self) -> str:
+        """Get checker name."""
+        return f"network_connectivity_{self.host}_{self.port}"
+
+    async def check_health(self) -> List[HealthMetric]:
+        """Perform health check."""
+        # Filter to only return metrics for the configured endpoint
+        all_metrics = await self.service.check_health()
+        relevant_metrics = []
+
+        for metric in all_metrics:
+            # Include socket creation and metrics for our endpoint
+            if (
+                metric.name == "socket_creation"
+                or f"{self.host}_{self.port}" in metric.name
+                or "localhost_default" not in metric.name
+            ):
+                # Rename metrics to match legacy format
+                if f"port_accessible_{self.host}_{self.port}" in metric.name:
+                    metric.name = "port_accessible"
+                relevant_metrics.append(metric)
+
+        return relevant_metrics
+
+
+class ServiceHealthChecker(HealthChecker):
+    """Legacy wrapper for ServiceHealthService.
+
+    Maintains backward compatibility with existing code.
+    """
+
+    def __init__(
+        self,
+        service_stats: Dict[str, Any],
+        max_clients: int = 1000,
+        max_error_rate: float = 0.1,
+    ):
+        """Initialize legacy service health checker."""
+        self.service = ServiceHealthService(
+            service_stats=service_stats,
+            max_clients=max_clients,
+            max_error_rate=max_error_rate,
+        )
+        self.service_stats = service_stats
+        self.max_clients = max_clients
+        self.max_error_rate = max_error_rate
+        self.last_check_time = self.service.last_check_time
+        self.last_events_processed = self.service.last_events_processed
+
+    def get_name(self) -> str:
+        """Get checker name."""
+        return "service_health"
+
+    async def check_health(self) -> List[HealthMetric]:
+        """Perform health check."""
+        metrics = await self.service.check_health()
+        # Update exposed state for compatibility
+        self.last_check_time = self.service.last_check_time
+        self.last_events_processed = self.service.last_events_processed
+        return metrics
+
+
+class AdvancedHealthMonitor:
+    """Legacy wrapper for MonitoringAggregatorService.
+
+    Maintains backward compatibility with existing code.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize legacy advanced health monitor."""
+        self.service = MonitoringAggregatorService(config)
+
+        # Expose service properties for compatibility
+        self.config = self.service.config
+        self.check_interval = self.service.check_interval
+        self.history_size = self.service.history_size
+        self.aggregation_window = self.service.aggregation_window
+        self.checkers = self.service.checkers
+        self.health_history = self.service.health_history
+        self.monitoring = self.service.monitoring
+        self.monitor_task = self.service.monitor_task
+        self.last_check_result = self.service.last_check_result
+        self.health_callbacks = self.service.health_callbacks
+        self.monitoring_stats = self.service.monitoring_stats
+
+        # Legacy logger
+        import logging
+
+        self.logger = logging.getLogger(f"{__name__}.AdvancedHealthMonitor")
+
+    def add_checker(self, checker: HealthChecker) -> None:
+        """Add a health checker."""
+        self.service.add_checker(checker)
+        self.checkers = self.service.checkers
+
+    def add_health_callback(self, callback) -> None:
+        """Add health callback."""
+        self.service.add_health_callback(callback)
+        self.health_callbacks = self.service.health_callbacks
+
+    async def perform_health_check(self):
+        """Perform health check."""
+        result = await self.service.perform_health_check()
+        # Update exposed state
+        self.health_history = self.service.health_history
+        self.last_check_result = self.service.last_check_result
+        self.monitoring_stats = self.service.monitoring_stats
+        return result
+
+    def _determine_overall_status(self, metrics):
+        """Determine overall status."""
+        return self.service._determine_overall_status(metrics)
+
+    def start_monitoring(self) -> None:
+        """Start monitoring."""
+        self.service.start_monitoring()
+        self.monitoring = self.service.monitoring
+        self.monitor_task = self.service.monitor_task
+
+    async def stop_monitoring(self) -> None:
+        """Stop monitoring."""
+        await self.service.stop_monitoring()
+        self.monitoring = self.service.monitoring
+        self.monitor_task = self.service.monitor_task
+
+    async def _monitoring_loop(self) -> None:
+        """Monitoring loop (should not be called directly)."""
+        await self.service._monitoring_loop()
+
+    def get_current_status(self):
+        """Get current status."""
+        return self.service.get_current_status()
+
+    def get_health_history(self, limit=None):
+        """Get health history."""
+        return self.service.get_health_history(limit)
+
+    def get_aggregated_status(self, window_seconds=None):
+        """Get aggregated status."""
+        return self.service.get_aggregated_status(window_seconds)
+
+    def export_diagnostics(self):
+        """Export diagnostics."""
+        return self.service.export_diagnostics()

claude_mpm/services/infrastructure/monitoring/network.py

@@ -0,0 +1,218 @@
+"""Network health monitoring service.
+
+Monitors network connectivity, port availability, and socket health.
+"""
+
+import socket
+from typing import Dict, List, Optional
+
+from .base import BaseMonitoringService, HealthMetric, HealthStatus
+
+
+class NetworkHealthService(BaseMonitoringService):
+    """Service for monitoring network health and connectivity.
+
+    Monitors:
+    - Port availability and binding
+    - Socket creation capability
+    - Network interface status
+    - Connection health to specified endpoints
+    """
+
+    def __init__(self, default_timeout: float = 1.0):
+        """Initialize network health service.
+
+        Args:
+            default_timeout: Default connection timeout in seconds
+        """
+        super().__init__("NetworkHealth")
+        self.default_timeout = default_timeout
+        self.monitored_endpoints: List[Dict[str, any]] = []
+
+    def add_endpoint(
+        self,
+        host: str,
+        port: int,
+        name: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        """Add an endpoint to monitor.
+
+        Args:
+            host: Host address to monitor
+            port: Port number to monitor
+            name: Optional name for the endpoint
+            timeout: Optional custom timeout for this endpoint
+        """
+        endpoint = {
+            "host": host,
+            "port": port,
+            "name": name or f"{host}:{port}",
+            "timeout": timeout or self.default_timeout,
+        }
+        self.monitored_endpoints.append(endpoint)
+        self.logger.info(f"Added endpoint for monitoring: {endpoint['name']}")
+
+    async def check_health(self) -> List[HealthMetric]:
+        """Check network health for all configured endpoints."""
+        metrics = []
+
+        # Check socket creation capability
+        metrics.extend(self._check_socket_creation())
+
+        # Check all monitored endpoints
+        for endpoint in self.monitored_endpoints:
+            metrics.extend(
+                self._check_endpoint(
+                    endpoint["host"],
+                    endpoint["port"],
+                    endpoint["name"],
+                    endpoint["timeout"],
+                )
+            )
+
+        # Check localhost connectivity (always check)
+        if not any(e["host"] == "localhost" for e in self.monitored_endpoints):
+            metrics.extend(
+                self._check_endpoint("localhost", 8765, "localhost_default", 0.5)
+            )
+
+        return metrics
+
+    def _check_socket_creation(self) -> List[HealthMetric]:
+        """Check if we can create sockets (resource availability)."""
+        metrics = []
+        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
+
+    def _check_endpoint(
+        self,
+        host: str,
+        port: int,
+        name: str,
+        timeout: float,
+    ) -> List[HealthMetric]:
+        """Check connectivity to a specific endpoint.
+
+        Args:
+            host: Host to check
+            port: Port to check
+            name: Endpoint name for metrics
+            timeout: Connection timeout
+
+        Returns:
+            List of health metrics for the endpoint
+        """
+        metrics = []
+        metric_name = f"port_accessible_{name}"
+
+        try:
+            # Try to connect to the port
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(timeout)
+            result = sock.connect_ex((host, port))
+            sock.close()
+
+            if result == 0:
+                metrics.append(
+                    HealthMetric(
+                        name=metric_name,
+                        value=True,
+                        status=HealthStatus.HEALTHY,
+                        message=f"Port {port} is accessible on {host}",
+                    )
+                )
+            else:
+                # Determine if this is critical or warning based on endpoint type
+                status = (
+                    HealthStatus.WARNING
+                    if "optional" in name.lower()
+                    else HealthStatus.CRITICAL
+                )
+                metrics.append(
+                    HealthMetric(
+                        name=metric_name,
+                        value=False,
+                        status=status,
+                        message=f"Port {port} is not accessible on {host} (error: {result})",
+                    )
+                )
+        except socket.timeout:
+            metrics.append(
+                HealthMetric(
+                    name=metric_name,
+                    value=False,
+                    status=HealthStatus.WARNING,
+                    message=f"Connection to {host}:{port} timed out after {timeout}s",
+                )
+            )
+        except Exception as e:
+            metrics.append(
+                HealthMetric(
+                    name=metric_name,
+                    value=False,
+                    status=HealthStatus.UNKNOWN,
+                    message=f"Error checking port accessibility: {e}",
+                )
+            )
+
+        return metrics
+
+    def check_port_available(self, port: int, host: str = "0.0.0.0") -> bool:
+        """Check if a port is available for binding.
+
+        Args:
+            port: Port number to check
+            host: Host interface to check
+
+        Returns:
+            True if port is available for binding
+        """
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                sock.bind((host, port))
+                return True
+        except OSError:
+            return False
+
+    def scan_port_range(
+        self,
+        start_port: int,
+        end_port: int,
+        host: str = "0.0.0.0",
+    ) -> List[int]:
+        """Scan a range of ports to find available ones.
+
+        Args:
+            start_port: Starting port number
+            end_port: Ending port number (inclusive)
+            host: Host interface to check
+
+        Returns:
+            List of available port numbers
+        """
+        available_ports = []
+        for port in range(start_port, end_port + 1):
+            if self.check_port_available(port, host):
+                available_ports.append(port)
+        return available_ports