Lukas
0a3f9c6c16
- Add external_logging_init_failures counter - Add external_log_required flag, raise if init fails and required - Health endpoint: add external_logging status check - Blocklist service: enrich with metadata fields, update import logic - Health check task: add runtime_state dependency, fix return typing - Metrics: add Histogram for request latencies - Frontend: align BlocklistImportLogSection props - Docs: update deployment guide, remove stale tasks Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
142 lines
4.7 KiB
Python
142 lines
4.7 KiB
Python
"""Health-check background task.
|
|
|
|
Registers an APScheduler job that probes the fail2ban socket every 30 seconds
|
|
and stores the result on ``app.state.server_status``. The dashboard endpoint
|
|
reads from this cache, keeping HTTP responses fast and the daemon connection
|
|
decoupled from user-facing requests.
|
|
|
|
Crash detection (Task 3)
|
|
------------------------
|
|
When a jail activation is performed, the router stores a timestamp on
|
|
``app.state.last_activation`` (a ``dict`` with ``jail_name`` and ``at``
|
|
keys). If the health probe subsequently detects an online→offline transition
|
|
within 60 seconds of that activation, a
|
|
:class:`~app.models.config.PendingRecovery` record is written to
|
|
``app.state.pending_recovery`` so the UI can offer a one-click rollback.
|
|
|
|
Correlation IDs are propagated through the task using :mod:`app.utils.correlation`
|
|
so that task logs can be correlated across runs.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import datetime
|
|
import uuid
|
|
from contextvars import copy_context
|
|
from typing import TYPE_CHECKING
|
|
|
|
import structlog
|
|
|
|
from app.models.server import ServerStatus
|
|
from app.services import health_service
|
|
from app.tasks.timeout_utils import run_with_timeout
|
|
from app.utils.correlation import reset_correlation_id, set_correlation_id
|
|
from app.utils.runtime_state import (
|
|
RuntimeState,
|
|
get_effective_settings,
|
|
get_runtime_state,
|
|
process_health_probe_result,
|
|
)
|
|
|
|
if TYPE_CHECKING: # pragma: no cover
|
|
from fastapi import FastAPI
|
|
|
|
from app.config import Settings
|
|
|
|
log: structlog.stdlib.BoundLogger = structlog.get_logger()
|
|
|
|
|
|
#: How often the probe fires (seconds).
|
|
HEALTH_CHECK_INTERVAL: int = 30
|
|
|
|
#: Maximum seconds to allow for health probe to complete.
|
|
HEALTH_PROBE_TIMEOUT_SECONDS: int = 10
|
|
|
|
|
|
async def _run_probe_with_resources(
|
|
settings: Settings,
|
|
runtime_state: RuntimeState,
|
|
correlation_id: str | None = None,
|
|
) -> None:
|
|
"""Probe fail2ban and cache the result on the runtime state.
|
|
|
|
Args:
|
|
settings: The resolved application settings used for the probe.
|
|
runtime_state: The mutable runtime state manager.
|
|
correlation_id: Optional correlation ID for log correlation.
|
|
"""
|
|
if correlation_id is None:
|
|
correlation_id = str(uuid.uuid4())
|
|
|
|
token = set_correlation_id(correlation_id)
|
|
try:
|
|
# Use copy_context() so ContextVar values (e.g. correlation_id)
|
|
# propagate to any child asyncio tasks spawned inside the coroutine.
|
|
probe_task = asyncio.create_task(
|
|
_do_probe_with_resources(settings, runtime_state),
|
|
context=copy_context(),
|
|
)
|
|
await run_with_timeout("health_check", probe_task, HEALTH_PROBE_TIMEOUT_SECONDS)
|
|
finally:
|
|
# Reset AFTER run_with_timeout completes, so child tasks still
|
|
# have the correlation ID in their context while they log.
|
|
reset_correlation_id(token)
|
|
|
|
|
|
async def _do_probe_with_resources(settings: Settings, runtime_state: RuntimeState) -> None:
|
|
"""Inner probe logic that runs with correlation context set."""
|
|
socket_path: str = settings.fail2ban_socket
|
|
status: ServerStatus = await health_service.probe(socket_path)
|
|
process_health_probe_result(runtime_state, status)
|
|
|
|
|
|
async def _run_probe(app: FastAPI) -> None:
|
|
await _run_probe_with_resources(
|
|
get_effective_settings(app),
|
|
get_runtime_state(app),
|
|
)
|
|
|
|
|
|
async def run_probe(app: FastAPI) -> None:
|
|
"""Run a single health probe outside the scheduled job context."""
|
|
await _run_probe(app)
|
|
|
|
|
|
def register(app: FastAPI) -> None:
|
|
"""Add the health-check job to the application scheduler.
|
|
|
|
Must be called after the scheduler has been started (i.e., inside the
|
|
lifespan handler, after ``scheduler.start()``).
|
|
|
|
Args:
|
|
app: The :class:`fastapi.FastAPI` application instance whose
|
|
``app.state.scheduler`` will receive the job.
|
|
"""
|
|
# Initialise the cache with an offline placeholder so the dashboard
|
|
# endpoint is always able to return a valid response even before the
|
|
# first probe fires.
|
|
settings = get_effective_settings(app)
|
|
runtime_state = get_runtime_state(app)
|
|
|
|
runtime_state.server_status = ServerStatus(online=False)
|
|
|
|
# Initialise activation tracking state.
|
|
runtime_state.last_activation = None
|
|
runtime_state.pending_recovery = None
|
|
|
|
app.state.scheduler.add_job(
|
|
_run_probe_with_resources,
|
|
trigger="interval",
|
|
seconds=HEALTH_CHECK_INTERVAL,
|
|
kwargs={"settings": settings, "runtime_state": runtime_state},
|
|
id="health_check",
|
|
replace_existing=True,
|
|
# Fire immediately on startup too, so the UI isn't dark for 30 s.
|
|
next_run_time=datetime.datetime.now(tz=datetime.UTC),
|
|
)
|
|
log.info(
|
|
"health_check_scheduled",
|
|
interval_seconds=HEALTH_CHECK_INTERVAL,
|
|
)
|