monitor.server

MonitorServer — FastAPI web server for the otto monitoring dashboard.

Endpoints

GET / Serves the React dashboard’s built index.html (web/, via make web) GET /static/… Serves the built dist/ assets (JS/CSS bundles, etc.) GET /api/meta JSON metadata (host name, metric labels, units) GET /api/data JSON snapshot of all metric series and events GET /api/stream SSE stream — pushes metric updates and events in real time POST /api/event Record a manual event from the dashboard UI

class otto.monitor.server.SuppressASGIWarning(name='')

Bases: Filter

logging.Filter that drops the uvicorn ASGI callable warning on shutdown.

filter(record: LogRecord) → bool

Determine if the specified record is to be logged.

Returns True if the record should be logged, or False otherwise. If deemed appropriate, the record may be modified in-place.

class otto.monitor.server.MonitorServer(collector: MetricCollector, host: str = '0.0.0.0', port: int = 0)

Bases: object

Wraps a FastAPI/uvicorn server for the monitoring dashboard.

Call await serve() from an async context to run the server. Call stop() from any thread to trigger a graceful shutdown, or force_stop() to abort open SSE connections immediately instead of waiting for them to drain.

property url : str

Primary URL using the first detected non-loopback IP (or the bind address).

property urls : list[str]

All URLs the server is reachable on (one per non-loopback interface).

property started : bool

True once the server is ready to accept connections.

async serve() → None

Run the web server until stop() is called or the process exits.

stop() → None

Signal the server to shut down (thread-safe).

force_stop() → None

Shut down without waiting for open connections to drain (thread-safe).

SSE dashboards hold /api/stream open indefinitely, so a graceful shutdown can wait forever. This sets uvicorn’s force_exit (skip the drain) and aborts open connection transports on the server’s own loop (h11 never closes a mid-stream transport, so clients would otherwise not see the connection die). Used by test harnesses and Ctrl+C paths; prefer stop() when clients should finish cleanly.

The listening sockets are closed first, in the same loop callback as the abort. Aborting only a one-shot snapshot of state.connections left a race: uvicorn keeps accepting until its own shutdown closes the sockets (~one 0.1s tick later), so a connection established in that window — e.g. the fresh EventSource a browser opens right after a page reload — was never aborted, and an un-aborted mid-stream h11 SSE keeps the server task alive (asyncio.Server.wait_closed() waits on it on 3.12+), hanging shutdown indefinitely. Because an asyncio callback runs to completion before the loop can accept another connection, closing the sockets and aborting the live transports in one callback guarantees the snapshot is complete: nothing new can slip in between the two steps.