Watching Every Subsystem at Once

# labs/dashboard.py
import json
import pathlib
import time

from labs.health_monitor import HealthStatus, run_checks

PAGE = pathlib.Path(__file__).with_name("dashboard.html")


def as_dict(status: HealthStatus) -> dict:
    """One check, written out as the four fields the wire carries."""
    return {"name": status.name, "ok": status.ok,
            "detail": status.detail, "value": status.value}


def snapshot(checks: list[HealthStatus], at: float) -> dict:
    return {"at": time.strftime("%H:%M:%S", time.localtime(at)),
            "overall": "ok" if all(c.ok for c in checks) else "degraded",
            "checks": [as_dict(c) for c in checks]}


if __name__ == "__main__":
    print(json.dumps(snapshot(run_checks(), time.time()), indent=2))

$ uv run python -m labs.dashboard   # measured on the bench — yours will vary
{
  "at": "09:53:02",
  "overall": "ok",
  "checks": [
    {
      "name": "ollama",
      "ok": true,
      "detail": "6 model(s) available",
      "value": 6.0
    },
    {
      "name": "disk",
      "ok": true,
      "detail": "71.2% used, 67.1 GiB free",
      "value": 71.2
    },
    {
      "name": "memory",
      "ok": true,
      "detail": "41.8% used, 4.3 GiB available",
      "value": 41.8
    }
  ]
}

No Flask yet, and no browser. The hard decision in a dashboard is what to report, and once that answer is a plain dict every later layer only moves it around. run_checks already returns a list of frozen HealthStatus records, so the only work here is turning each one into JSON-native values: strings, numbers, booleans, None, lists and dicts. Nothing else survives the trip.

as_dict names its four fields by hand where dataclasses.asdict would have done it in one line, and that is deliberate. This dict is a published interface: a page you are not going to redeploy in step with the server reads these key names. Generating them from the attributes means the day you rename a field on the dataclass, the wire quietly changes and the page quietly stops finding detail. Typing them out makes that rename a visible edit in one file.

overall exists so the page never has to know the rule for combining verdicts. One flag, computed once by the server, and every reader agrees about whether the house is fine.

def sse_event(payload: dict) -> str:
    """Frame one dict as a single Server-Sent Events message."""
    return f"data: {json.dumps(payload)}\n\n"


if __name__ == "__main__":
    print(repr(sse_event({"at": "09:53:02", "overall": "ok"})))

$ uv run python -m labs.dashboard
'data: {"at": "09:53:02", "overall": "ok"}\n\n'

That is the entire transport layer of this chapter, and repr is there so the two newlines are visible instead of being rendered as empty space. The format is line based. Every line is a field: value pair, and a blank line ends the current message and tells the browser to hand it to your code. One \n instead of two leaves the browser holding a half-finished message forever, waiting for a terminator that never arrives, with no error anywhere.

There are only four fields, plus one line that is not a field at all:

• data: is the payload. It fires the browser's onmessage handler, and everything after the space arrives as event.data, a string.
• event: names a channel, so addEventListener("alert", ...) receives it instead of onmessage.
• id: tags the message. The browser remembers the last one it saw and sends it back as a Last-Event-ID header when it reconnects.
• retry: sets how many milliseconds the browser waits before reconnecting after a drop.
• A line starting with : is a comment. The parser reads it and throws it away, which makes it the cheapest possible way to write something into a connection to prove it still exists.

That list is the whole protocol. There is nothing to install on the server, because the server is writing text, and nothing to install in the browser, because the parser for those five line types has been built into browsers for over a decade.

# labs/glados_api.py — added beside the routes from chapter 89
from flask import Response

from labs.dashboard import sse_event, snapshot
from labs.health_monitor import run_checks


@app.route("/events", methods=["GET"])
def events():
    def stream():
        while True:
            yield sse_event(snapshot(run_checks(), time.time()))
            time.sleep(5)

    return Response(stream(), mimetype="text/event-stream",
                    headers={"Cache-Control": "no-cache",
                             "X-Accel-Buffering": "no"})

$ curl -iN http://127.0.0.1:5000/events   # ctrl-C to stop it; measured on the bench — yours will vary
HTTP/1.1 200 OK
Server: Werkzeug/3.1.8 Python/3.11.15
Date: Sun, 23 Aug 2026 14:53:02 GMT
Content-Type: text/event-stream; charset=utf-8
Cache-Control: no-cache
X-Accel-Buffering: no
Connection: close

data: {"at": "09:53:02", "overall": "ok", "checks": [{"name": "ollama", "ok": true, "detail": "6 model(s) available", "value": 6.0}, {"name": "disk", "ok": true, "detail": "71.2% used, 67.1 GiB free", "value": 71.2}, {"name": "memory", "ok": true, "detail": "41.8% used, 4.3 GiB available", "value": 41.8}]}

data: {"at": "09:53:07", "overall": "ok", "checks": [{"name": "ollama", "ok": true, "detail": "6 model(s) available", "value": 6.0}, {"name": "disk", "ok": true, "detail": "71.2% used, 67.1 GiB free", "value": 71.2}, {"name": "memory", "ok": true, "detail": "41.8% used, 4.3 GiB available", "value": 41.8}]}

The -N turns off curl's output buffering, so the lines land as they are written and the terminal sits there afterwards, waiting for more. That is the whole trick made visible: an ordinary GET, a 200, a normal header block, and then a body that is still being written. Every byte is text you can read without a decoder.

Two headers in that block deserve a look. Content-Type: text/event-stream is the switch that puts a browser into SSE mode; get it wrong and the browser treats the reply as a document and gives up. And there is no Content-Length at all, which is what makes the rest possible. A length is a promise about how many bytes follow, and this response cannot make one. Chapter 89's captures ended with the receiver counting bytes and stopping; this one ends when someone closes the socket.

Cache-Control: no-cache and X-Accel-Buffering: no exist for the machines in between. A cache that stores a response it thinks is finished, or a reverse proxy that holds bytes back until it has a few kilobytes to send, breaks this in a way that looks exactly like a dead server. The second header is nginx's own switch, read per response, and it costs nothing to send when no proxy is there.

What this stage still gets wrong is the same thing polling got wrong. It runs the checks on a timer, once per connection, so two tabs mean two independent probe loops hammering Ollama out of step with each other.

# labs/dashboard.py
import threading

from labs.health_monitor import POLL_SECONDS, Monitor

KEEPALIVE_SECONDS = 15.0


class Board:
    """The latest snapshot, and a version number readers can wait on."""

    def __init__(self) -> None:
        self._cond = threading.Condition()
        self._latest: dict | None = None
        self._version = 0

    def publish(self, payload: dict) -> None:
        with self._cond:
            self._latest = payload
            self._version += 1
            self._cond.notify_all()

    def wait(self, seen: int, timeout: float) -> tuple[int, dict | None]:
        """Block until the version moves past `seen`, or the timeout expires."""
        with self._cond:
            self._cond.wait_for(lambda: self._version != seen, timeout)
            return self._version, self._latest


BOARD = Board()


def publish_forever(interval: float = POLL_SECONDS) -> None:
    """Chapter 92's monitor, with every poll put on the board."""
    monitor = Monitor()
    while True:
        at = time.time()
        checks, _ = monitor.poll(at)
        BOARD.publish(snapshot(checks, at))
        time.sleep(max(0.0, interval - (time.time() - at)))

# labs/glados_api.py
from labs.dashboard import BOARD, KEEPALIVE_SECONDS, PAGE, publish_forever, sse_event


@app.route("/events", methods=["GET"])
def events():
    def stream():
        seen = 0
        while True:
            version, payload = BOARD.wait(seen, KEEPALIVE_SECONDS)
            if version == seen or payload is None:
                yield ": waiting\n\n"
                continue
            seen = version
            yield sse_event(payload)

    return Response(stream(), mimetype="text/event-stream",
                    headers={"Cache-Control": "no-cache",
                             "X-Accel-Buffering": "no"})


if __name__ == "__main__":
    threading.Thread(target=publish_forever, args=(5.0,), daemon=True).start()
    app.run(host="0.0.0.0", port=5000)

$ curl -N localhost:5000/events   # measured on the bench; in a third terminal: sudo systemctl stop ollama
data: {"at": "09:56:12", "overall": "ok", "checks": [{"name": "ollama", "ok": true, "detail": "6 model(s) available", "value": 6.0}, {"name": "disk", "ok": true, "detail": "71.2% used, 67.1 GiB free", "value": 71.2}, {"name": "memory", "ok": true, "detail": "41.8% used, 4.3 GiB available", "value": 41.8}]}

data: {"at": "09:56:17", "overall": "degraded", "checks": [{"name": "ollama", "ok": false, "detail": "URLError: <urlopen error [Errno 111] Connection refused>", "value": null}, {"name": "disk", "ok": true, "detail": "71.2% used, 67.1 GiB free", "value": 71.2}, {"name": "memory", "ok": true, "detail": "41.8% used, 4.3 GiB available", "value": 41.8}]}

$ curl -N localhost:5000/events   # the same route with the interval left at POLL_SECONDS
data: {"at": "10:02:00", "overall": "degraded", "checks": [{"name": "ollama", "ok": false, "detail": "URLError: <urlopen error [Errno 111] Connection refused>", "value": null}, {"name": "disk", "ok": true, "detail": "71.3% used, 67.0 GiB free", "value": 71.3}, {"name": "memory", "ok": true, "detail": "42.0% used, 4.3 GiB available", "value": 42.0}]}

: waiting

: waiting

: waiting

data: {"at": "10:03:00", "overall": "degraded", "checks": [{"name": "ollama", "ok": false, "detail": "URLError: <urlopen error [Errno 111] Connection refused>", "value": null}, {"name": "disk", "ok": true, "detail": "71.3% used, 67.0 GiB free", "value": 71.3}, {"name": "memory", "ok": true, "detail": "42.1% used, 4.3 GiB available", "value": 42.1}]}

The checks now run in exactly one place, on the schedule chapter 92 chose, and the alerts it sends still go out from the same poll. Ten tabs cost ten sleeping threads and no extra probes at all. A reader arriving mid-flight passes seen = 0, the version is already past that, and wait_for returns without blocking, so a new tab paints itself immediately instead of staring at an empty page until the next poll.

The board keeps the latest snapshot and not a queue, and that is the right choice for status. A reader that was slow, or asleep in a background tab, wants the truth now, not a backlog of the six intermediate versions it missed. Anything where every event matters, like her alert history, needs ids and a buffer instead, which is exercise 1.

The three comment lines are the reason this design survives a real house. With the interval at sixty seconds a connection can sit silent long enough for a phone's radio, a NAT table or an impatient proxy to decide it is dead. More importantly, a generator blocked in wait_for has no idea its reader closed the tab; the server only finds out when it next tries to write and the socket refuses. Writing eleven bytes every fifteen seconds is what turns a closed tab into a freed thread.

One judgement call is baked in here: every poll counts as news, so the numbers on the cards stay fresh even when nothing interesting happened. If you would rather stream only true changes, compare the name and ok pairs against the previous payload inside publish and return early when they match. The cost is a page whose timestamp can be hours old, which reads as a dead dashboard.

<!-- labs/dashboard.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>GLaDOS status</title>
  <style>
    body   { background: #101014; color: #d8d8dc; font: 15px/1.6 monospace; margin: 2rem; }
    h1     { font-size: 1rem; letter-spacing: 0.15em; text-transform: uppercase; }
    #line  { color: #8a8a92; margin-bottom: 1rem; }
    .card  { border: 1px solid #2a2a32; border-left-width: 5px; border-radius: 4px;
             padding: 0.6rem 0.9rem; margin: 0.4rem 0; }
    .ok    { border-left-color: #3ddc84; }
    .bad   { border-left-color: #ff5f56; }
    .name  { display: inline-block; width: 7rem; }
    .detail{ color: #a0a0a8; }
  </style>
</head>
<body>
  <h1>GLaDOS subsystems</h1>
  <div id="line">connecting</div>
  <div id="board"></div>
  <form id="say"><input id="text" size="40" placeholder="make her say something"></form>

  <script>
    const board = document.getElementById("board");
    const line  = document.getElementById("line");
    const text  = document.getElementById("text");

    function card(check) {
      const row = document.createElement("div");
      row.className = "card " + (check.ok ? "ok" : "bad");
      const name = document.createElement("span");
      name.className = "name";
      name.textContent = check.name;
      const detail = document.createElement("span");
      detail.className = "detail";
      detail.textContent = check.detail;
      row.append(name, detail);
      return row;
    }

    const stream = new EventSource("/events");
    stream.onopen    = () => { line.textContent = "live"; };
    stream.onerror   = () => { line.textContent = "connection dropped, retrying"; };
    stream.onmessage = (message) => {
      const snap = JSON.parse(message.data);
      line.textContent = snap.overall + " at " + snap.at;
      board.replaceChildren(...snap.checks.map(card));
    };

    document.getElementById("say").addEventListener("submit", (submit) => {
      submit.preventDefault();                       // the other channel: an ordinary POST
      fetch("/speak", {method: "POST",
                       headers: {"Content-Type": "application/json"},
                       body: JSON.stringify({text: text.value})});
      text.value = "";
    });
  </script>
</body>
</html>

# labs/glados_api.py
@app.route("/", methods=["GET"])
def dashboard():
    return PAGE.read_text(encoding="utf-8"), 200, {"Content-Type": "text/html; charset=utf-8"}

# the server terminal, measured on the bench: the page open in a browser, one sentence typed into it
127.0.0.1 - - [23/Aug/2026 10:11:38] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [23/Aug/2026 10:11:38] "GET /events HTTP/1.1" 200 -
127.0.0.1 - - [23/Aug/2026 10:12:04] "POST /speak HTTP/1.1" 202 -

Three requests, and then the log goes quiet while the cards keep repainting. That is the entire argument of the chapter in one capture. The polling version puts a line in that terminal every second the tab is open, 86,400 of them by this time tomorrow, and it would still have been late to the one thing that mattered.

Reading the page off disk on every request costs a few microseconds and buys you an edit-and-refresh loop: change a colour, press F5, see it, with the server and her models left running. Nothing on the page is fetched from anywhere else. No framework, no CDN, no build step, no font server that turns her dashboard into something that stops working when your internet does.

textContent is doing quiet safety work in card. The detail field carries whatever a failing subsystem said about itself, including exception text from a library nobody here wrote. Building the row with innerHTML and a template string would hand that text to the HTML parser, and an error message containing angle brackets would rearrange the page instead of being displayed on it. Elements built by hand and filled with textContent cannot do that.

The single input at the bottom is the other direction, and it earns its place on the page precisely because it is so plainly separate. Typing a sentence and pressing enter sends a POST to chapter 89's /speak, which answers 202 on its own short-lived connection while the stream carries on untouched. The stream reports; the POST asks. If you ever find yourself wanting to send something up the stream, that is the signal you have outgrown SSE and want a WebSocket.