main.py

"""Run alert worker and expose monitoring API endpoints."""

from __future__ import annotations

import json
import logging
import os
import signal
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any
from urllib.parse import parse_qs, urlparse

from alerts.alert_manager import load_active_alerts, start_alert_manager
from storage.db_client import DBClient

logging.basicConfig(
    level=os.getenv("LOG_LEVEL", "INFO"),
    format="%(asctime)s %(levelname)s [%(name)s] %(message)s",
)
logger = logging.getLogger(__name__)


def normalize_alert_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
    normalized: list[dict[str, Any]] = []
    for row in rows:
        if row.get("_field") not in (None, "message"):
            continue
        raw_message = str(row.get("_value") or row.get("message") or "")
        try:
            payload = json.loads(raw_message)
        except json.JSONDecodeError:
            payload = {}

        if isinstance(payload, dict) and {"severity", "device", "cpu", "time"} <= set(payload):
            normalized.append(
                {
                    "severity": str(payload["severity"]),
                    "device": str(payload["device"]),
                    "cpu": float(payload["cpu"]),
                    "time": str(payload["time"]),
                }
            )
            continue

        normalized.append(
            {
                "time": str(row.get("_time", "")),
                "host": str(row.get("host", "unknown")),
                "severity": str(row.get("severity", "info")),
                "message": raw_message,
            }
        )
    return normalized


def build_handler(db: DBClient) -> type[BaseHTTPRequestHandler]:
    class AlertAPIHandler(BaseHTTPRequestHandler):
        def _send_json(self, status_code: int, payload: dict[str, Any]) -> None:
            body = json.dumps(payload).encode("utf-8")
            self.send_response(status_code)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)

        def do_GET(self) -> None:  # noqa: N802
            parsed = urlparse(self.path)
            if parsed.path == "/health":
                self._send_json(200, {"status": "ok", "influx": db.is_healthy()})
                return

            if parsed.path == "/api/alerts":
                params = parse_qs(parsed.query)
                host = params.get("host", [None])[0]
                try:
                    limit = int(params.get("limit", ["20"])[0])
                except ValueError:
                    self._send_json(400, {"error": "limit must be integer"})
                    return

                file_alerts = load_active_alerts()
                if host:
                    file_alerts = [a for a in file_alerts if a.get("device") == host]
                file_alerts = file_alerts[-max(1, min(limit, 200)) :]

                rows = db.get_recent_alerts(host=host, limit=max(1, min(limit, 200)))
                items = [*file_alerts, *normalize_alert_rows(rows)]
                self._send_json(
                    200,
                    {
                        "count": len(items),
                        "items": items,
                    },
                )
                return

            self._send_json(404, {"error": "not found"})

        def log_message(self, fmt: str, *args: Any) -> None:
            logger.info("HTTP %s", fmt % args)

    return AlertAPIHandler


def main() -> int:
    host = os.getenv("API_HOST", "0.0.0.0")
    port = int(os.getenv("API_PORT", "8000"))

    with DBClient.from_env() as db:
        _, stop_event = start_alert_manager(db)
        server = ThreadingHTTPServer((host, port), build_handler(db))
        logger.info("API serving at http://%s:%d", host, port)

        def _shutdown(*_: Any) -> None:
            logger.info("Shutting down...")
            stop_event.set()
            server.shutdown()

        signal.signal(signal.SIGINT, _shutdown)
        signal.signal(signal.SIGTERM, _shutdown)

        try:
            server.serve_forever()
        finally:
            stop_event.set()
            server.server_close()

    return 0


if __name__ == "__main__":
    raise SystemExit(main())