crackerjack 0.18.2__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/mcp/websocket/monitoring/websockets/metrics.py

@@ -0,0 +1,291 @@
+"""WebSocket endpoints for metrics streaming.
+
+This module handles real-time metrics streaming, historical data,
+alerts, and dashboard overview WebSocket connections.
+"""
+
+import asyncio
+import json
+import typing as t
+from datetime import datetime
+
+from acb.depends import depends
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from crackerjack.events import WorkflowEventTelemetry
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+    TrendDirection,
+    UnifiedMetrics,
+)
+
+from ..metrics import get_monitoring_current_metrics
+from ..websocket_manager import MonitoringWebSocketManager
+
+
+def register_metrics_websockets(
+    app: FastAPI,
+    job_manager: t.Any,
+    ws_manager: MonitoringWebSocketManager,
+    quality_service: EnhancedQualityBaselineService,
+) -> None:
+    """Register metrics-related WebSocket endpoints."""
+
+    @app.websocket("/ws/metrics/live")
+    async def websocket_metrics_live(websocket: WebSocket) -> None:
+        """WebSocket endpoint for live metrics streaming."""
+        await _handle_live_metrics_websocket(
+            websocket, ws_manager, quality_service, job_manager
+        )
+
+    @app.websocket("/ws/metrics/historical/{days}")
+    async def websocket_metrics_historical(websocket: WebSocket, days: int) -> None:
+        """WebSocket endpoint for historical metrics data."""
+        await _handle_historical_metrics_websocket(
+            websocket, ws_manager, quality_service, days
+        )
+
+    @app.websocket("/ws/alerts/subscribe")
+    async def websocket_alerts_subscribe(websocket: WebSocket) -> None:
+        """WebSocket endpoint for alert subscriptions."""
+        await _handle_alerts_websocket(websocket, ws_manager)
+
+    @app.websocket("/ws/dashboard/overview")
+    async def websocket_dashboard_overview(websocket: WebSocket) -> None:
+        """WebSocket endpoint for comprehensive dashboard data."""
+        await _handle_dashboard_websocket(
+            websocket, ws_manager, quality_service, job_manager
+        )
+
+
+async def _handle_live_metrics_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    quality_service: EnhancedQualityBaselineService,
+    job_manager: t.Any,
+) -> None:
+    """Handle live metrics WebSocket connection."""
+    client_id = f"metrics_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        # Send initial metrics
+        current_metrics = await get_monitoring_current_metrics(
+            quality_service, job_manager
+        )
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "initial_metrics",
+                    "data": current_metrics.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Keep connection alive and handle client messages
+        while True:
+            try:
+                message = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+                data = json.loads(message)
+
+                if data.get("type") == "request_update":
+                    metrics = await get_monitoring_current_metrics(
+                        quality_service, job_manager
+                    )
+                    await websocket.send_text(
+                        json.dumps(
+                            {
+                                "type": "metrics_update",
+                                "data": metrics.to_dict(),
+                                "timestamp": datetime.now().isoformat(),
+                            }
+                        )
+                    )
+
+            except TimeoutError:
+                metrics = await get_monitoring_current_metrics(
+                    quality_service, job_manager
+                )
+                await ws_manager.broadcast_metrics(metrics)
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_historical_metrics_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    quality_service: EnhancedQualityBaselineService,
+    days: int,
+) -> None:
+    """Handle historical metrics WebSocket connection."""
+    if days > 365:
+        await websocket.close(code=1008, reason="Days parameter too large")
+        return
+
+    client_id = f"historical_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        baselines = await quality_service.aget_recent_baselines(limit=days)
+        historical_data = _convert_baselines_to_metrics(baselines)
+
+        await _send_historical_data_chunks(websocket, historical_data)
+
+        # Keep connection open for updates
+        while True:
+            await websocket.receive_text()
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+def _convert_baselines_to_metrics(
+    baselines: list[t.Any],
+) -> list[UnifiedMetrics]:
+    """Convert quality baselines to UnifiedMetrics objects."""
+    return [
+        UnifiedMetrics(
+            timestamp=baseline.timestamp,
+            quality_score=baseline.quality_score,
+            test_coverage=baseline.coverage_percent,
+            hook_duration=0.0,
+            active_jobs=0,
+            error_count=baseline.hook_failures
+            + baseline.security_issues
+            + baseline.type_errors
+            + baseline.linting_issues,
+            trend_direction=TrendDirection.STABLE,
+            predictions={},
+        )
+        for baseline in baselines
+    ]
+
+
+async def _send_historical_data_chunks(
+    websocket: WebSocket, historical_data: list[UnifiedMetrics]
+) -> None:
+    """Send historical data in chunks to avoid overwhelming the client."""
+    chunk_size = 100
+
+    for i in range(0, len(historical_data), chunk_size):
+        chunk = historical_data[i : i + chunk_size]
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "historical_chunk",
+                    "data": [m.to_dict() for m in chunk],
+                    "chunk_index": i // chunk_size,
+                    "total_chunks": (len(historical_data) + chunk_size - 1)
+                    // chunk_size,
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+        await asyncio.sleep(0.1)
+
+    # Send completion signal
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "historical_complete",
+                "total_records": len(historical_data),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _handle_alerts_websocket(
+    websocket: WebSocket, ws_manager: MonitoringWebSocketManager
+) -> None:
+    """Handle alerts WebSocket connection."""
+    client_id = f"alerts_{datetime.now().timestamp()}"
+    await ws_manager.connect_alerts(websocket, client_id)
+
+    try:
+        # Send current active alerts - would need to track these separately
+        active_alerts = []  # For now, empty list
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "active_alerts",
+                    "data": [alert.to_dict() for alert in active_alerts],
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Keep connection alive
+        while True:
+            await websocket.receive_text()
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_dashboard_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    quality_service: EnhancedQualityBaselineService,
+    job_manager: t.Any,
+) -> None:
+    """Handle dashboard overview WebSocket connection."""
+    client_id = f"dashboard_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        telemetry: WorkflowEventTelemetry | None
+        try:
+            telemetry = depends.get_sync(WorkflowEventTelemetry)
+        except Exception:
+            telemetry = None
+
+        while True:
+            current_metrics = await get_monitoring_current_metrics(
+                quality_service, job_manager
+            )
+
+            metrics_dict = _create_dashboard_metrics_dict(current_metrics)
+
+            dashboard_state = await asyncio.to_thread(
+                quality_service.create_dashboard_state,
+                metrics_dict,
+                len(job_manager.active_connections),
+                7,
+            )
+
+            telemetry_snapshot: dict[str, t.Any] | None = None
+            if telemetry is not None:
+                telemetry_snapshot = await telemetry.snapshot()
+
+            await websocket.send_text(
+                json.dumps(
+                    {
+                        "type": "dashboard_update",
+                        "data": dashboard_state.to_dict(),
+                        "telemetry": telemetry_snapshot,
+                        "timestamp": datetime.now().isoformat(),
+                    }
+                )
+            )
+
+            await asyncio.sleep(10)
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+def _create_dashboard_metrics_dict(current_metrics: UnifiedMetrics) -> dict[str, t.Any]:
+    """Create basic metrics dict for dashboard state."""
+    return {
+        "coverage_percent": current_metrics.test_coverage,
+        "test_count": 0,
+        "test_pass_rate": 100.0,
+        "hook_failures": 0,
+        "complexity_violations": 0,
+        "security_issues": 0,
+        "type_errors": 0,
+        "linting_issues": 0,
+    }

crackerjack/mcp/websocket/monitoring_endpoints.py

@@ -0,0 +1,21 @@
+"""Backward compatibility wrapper for refactored monitoring endpoints.
+
+This module re-exports the main factory function from the new monitoring/ directory
+to maintain backward compatibility with existing code that imports from
+crackerjack.mcp.websocket.monitoring_endpoints.
+
+The actual implementation has been split into organized modules:
+- monitoring/models.py - Pydantic data models
+- monitoring/websocket_manager.py - WebSocket connection management
+- monitoring/utils.py - Utility functions
+- monitoring/dashboard.py - Dashboard HTML rendering
+- monitoring/websockets/ - WebSocket endpoint modules (metrics, intelligence, dependencies, heatmap)
+- monitoring/api/ - REST API endpoint modules (telemetry, metrics, intelligence, dependencies, heatmap)
+- monitoring/factory.py - Endpoint registration orchestration
+
+All imports should work exactly as before via the main factory function.
+"""
+
+from .monitoring import MonitoringWebSocketManager, create_monitoring_endpoints
+
+__all__ = ["create_monitoring_endpoints", "MonitoringWebSocketManager"]

crackerjack/mcp/websocket/server.py

@@ -0,0 +1,174 @@
+import asyncio
+import contextlib
+import signal
+import subprocess
+import tempfile
+import time
+import typing as t
+from pathlib import Path
+
+import uvicorn
+from acb import console
+
+from crackerjack.core.timeout_manager import get_timeout_manager
+
+from .app import create_websocket_app
+from .jobs import JobManager
+
+
+class WebSocketServer:
+    def __init__(self, port: int = 8675) -> None:
+        self.port = port
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
+        self.is_running = True
+        self.job_manager: JobManager | None = None
+        self.app: t.Any = None
+        self.timeout_manager = get_timeout_manager()
+        self.server_task: asyncio.Task[t.Any] | None = None
+
+    def setup(self) -> None:
+        self.progress_dir.mkdir(exist_ok=True)
+
+        self.job_manager = JobManager(self.progress_dir)
+
+        self.app = create_websocket_app(self.job_manager, self.progress_dir)
+
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    def _signal_handler(self, _signum: int, _frame: t.Any) -> None:
+        console.print("\n[yellow]Shutting down WebSocket server...[/yellow]")
+        self.is_running = False
+
+        if self.server_task and not self.server_task.done():
+            self.server_task.cancel()
+
+        if self.job_manager:
+            with contextlib.suppress(Exception):
+                asyncio.create_task(self._graceful_shutdown())
+
+    async def _graceful_shutdown(self) -> None:
+        if self.job_manager:
+            try:
+                await asyncio.sleep(2.0)
+
+                console.print(
+                    "[yellow]Forcing remaining WebSocket connections to close[/yellow]"
+                )
+            except Exception as e:
+                console.print(f"[red]Error during graceful shutdown: {e}[/red]")
+
+    def run(self) -> None:
+        try:
+            self.setup()
+            console.print(
+                f"[green]Starting WebSocket server on port {self.port}[/green]",
+            )
+            console.print(f"Progress directory: {self.progress_dir}")
+            console.print("Press Ctrl+C to stop")
+
+            config = uvicorn.Config(
+                app=self.app,
+                port=self.port,
+                host="127.0.0.1",
+                log_level="info",
+                timeout_keep_alive=30,
+                timeout_graceful_shutdown=30,
+            )
+
+            server = uvicorn.Server(config)
+
+            try:
+                asyncio.run(self._run_with_timeout(server))
+            except KeyboardInterrupt:
+                console.print("\n[yellow]Server interrupted by user[/yellow]")
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Server stopped by user[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Server error: {e}[/red]")
+        finally:
+            console.print("[green]WebSocket server shutdown complete[/green]")
+
+    async def _run_with_timeout(self, server: uvicorn.Server) -> None:
+        try:
+            self.server_task = asyncio.create_task(server.serve())
+
+            while self.is_running and not self.server_task.done():
+                try:
+                    await asyncio.sleep(5.0)
+
+                except asyncio.CancelledError:
+                    console.print("[yellow]Server monitoring cancelled[/yellow]")
+                    break
+                except Exception as e:
+                    console.print(f"[red]Server monitoring error: {e}[/red]")
+                    break
+
+            if self.server_task and not self.server_task.done():
+                try:
+                    await asyncio.wait_for(self.server_task, timeout=30.0)
+                except TimeoutError:
+                    console.print(
+                        "[yellow]Server shutdown timeout, forcing termination[/yellow]"
+                    )
+                    self.server_task.cancel()
+                    try:
+                        await self.server_task
+                    except asyncio.CancelledError:
+                        pass
+
+        except Exception as e:
+            console.print(f"[red]Server runtime error: {e}[/red]")
+
+
+def handle_websocket_server_command(
+    start: bool = False,
+    stop: bool = False,
+    restart: bool = False,
+    port: int = 8675,
+) -> None:
+    if stop or restart:
+        console.print("[yellow]Stopping WebSocket servers...[/yellow]")
+
+        try:
+            result = subprocess.run(
+                ["pkill", "-f", f"uvicorn.*: {port}"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                console.print("[green]✅ WebSocket servers stopped[/green]")
+            else:
+                console.print("[dim]No WebSocket servers were running[/dim]")
+        except subprocess.TimeoutExpired:
+            console.print("[red]Timeout stopping WebSocket servers[/red]")
+        except Exception as e:
+            console.print(f"[red]Error stopping WebSocket servers: {e}[/red]")
+
+        if stop:
+            return
+
+        time.sleep(2)
+
+    if start or restart:
+        console.print(f"[green]Starting WebSocket server on port {port}...[/green]")
+        try:
+            server = WebSocketServer(port)
+            server.run()
+        except Exception as e:
+            console.print(f"[red]Failed to start WebSocket server: {e}[/red]")
+
+
+def main(port: int = 8675) -> None:
+    server = WebSocketServer(port)
+    server.run()
+
+
+if __name__ == "__main__":
+    import sys
+
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8675
+    main(port)