From cc6ea7c230469068e0eb2b67626775f00aaba79e Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Tue, 17 Nov 2026 14:08:13 +0000 Subject: [PATCH] feat(orchestrator): time range and replay move into the rates panel (015) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The navbar time menu goes; the rates panel holds the presets, a two-handle span slider over the hub's history, replay and Live, and the custom From/To range. A custom range becomes a window length plus an end point, so live windows keep their length. The rates chip lists every metric, and the panel wraps instead of spilling at 390 px. Unit and e2e (Chromium, Firefox, 1920/1366/390) cover the window, the slider and the requests. 🎯 Fix: 94 % πŸ’₯ Break: 4 % πŸ’Έ Tokens: 100 % ⏱️ Velocity: 100 % πŸ›‘οΈ Security: 100 % πŸ† Score: 90 🚦 Gate: βœ… 90/5, tokens and velocity <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- docs/requirements/015-rates-time-range.md | 7 +- orchestrator/kvb_orchestrator/rates.py | 179 +++++----------- orchestrator/kvb_orchestrator/settings.py | 2 +- orchestrator/templates/index.html.j2 | 1 - orchestrator/templates/page-boot.js | 2 +- orchestrator/templates/page-constants.js | 2 +- orchestrator/templates/page-dom.js | 2 +- orchestrator/templates/page-filters.js | 3 - orchestrator/templates/page-rates.js | 76 ++++--- orchestrator/templates/page-resources.js | 2 +- orchestrator/templates/page-state.js | 2 +- orchestrator/templates/page-time.js | 117 ++++++----- orchestrator/templates/style-rates.css | 20 +- tests/e2e/bidi.mjs | 9 +- tests/e2e/cdp.mjs | 4 +- tests/e2e/hub_e2e_views.py | 4 +- tests/e2e/test_orchestrator_e2e.py | 2 +- tests/e2e/test_rates_chip_e2e.py | 243 ++++++++++++++-------- tests/test_hub_rates.py | 195 ++++++++--------- tests/test_hub_settings.py | 6 +- 20 files changed, 462 insertions(+), 416 deletions(-) diff --git a/docs/requirements/015-rates-time-range.md b/docs/requirements/015-rates-time-range.md index 06b65c9..f960fcd 100644 --- a/docs/requirements/015-rates-time-range.md +++ b/docs/requirements/015-rates-time-range.md @@ -38,8 +38,9 @@ control instead of three. lacks room the chip shows as many as fit and `+n`. Rejected: a limit of 3 or 5. 6. **Persistence**: unit and chip metrics persist in the hub settings - `rates` without a passkey, as today; the window stays page state, 1 h - live on load, as today. + `rates` without a passkey, as today; the window stays page state, 24 h + live on load, as today (corrected 2026-11-17: the draft named 1 h, but + the page loads 24 h). 7. **Timing**: implemented after every other open skills requirement. ## Approach @@ -96,7 +97,7 @@ flowchart TD the window's token sum divided by 7. - [ ] With 9 metrics chosen the chip shows every one at 1920 and `+n` at 390, and the header never grows wider than the viewport. -- [ ] Unit and metrics survive a reload; the window returns to 1 h live. +- [ ] Unit and metrics survive a reload; the window returns to 24 h live. ### Tests diff --git a/orchestrator/kvb_orchestrator/rates.py b/orchestrator/kvb_orchestrator/rates.py index e0308f0..efd40ab 100644 --- a/orchestrator/kvb_orchestrator/rates.py +++ b/orchestrator/kvb_orchestrator/rates.py @@ -1,6 +1,5 @@ from __future__ import annotations -import math from collections.abc import Iterable from pathlib import Path @@ -17,11 +16,10 @@ GAUGES = ("cpu", "ram", "vram", "swap", "disk") METRICS = (*COUNTS, *GAUGES) HOST = ("cpu", "ram", "swap") TOKEN_FIELDS = ("input", "output", "cache_read", "cache_write") -FINEST = {"tokens": HOUR} +FINEST = {"tasks": 0, "commits": 0, "krs": 0, "tokens": HOUR} INTERVAL = 60 DONE = "done" DIGITS = 4 -TOTAL = "total" NUMBERS = (int, float) LIMIT = 1e18 @@ -99,87 +97,32 @@ def share(piece: Piece, begin: float, now: float) -> float: return amount * inside / (end - start) if inside > 0 else 0.0 -def sums(pieces: list[Piece], now: float, finest: float) -> dict[str, float | None]: +def counted(pieces: list[Piece], window: tuple[float, float], first: float | None, finest: float) -> dict[str, dict]: """Args: - pieces: (start, end, amount) per event; start None for one without - a time, end equal to start for an instant. - now: the end of every window. - finest: the shortest window the pieces resolve; a shorter one holds - no event of its own. + pieces: (start, end, amount) per event of one kind; start None for + one without a time, end equal to start for an instant. + window: (begin, end) the rates cover, in epoch seconds. + first: the first time the records of the kind hold, None without any. + finest: the shortest span the kind's pieces resolve. Returns: - Per period the amount inside its window, None below finest; total - holds every piece. + Per period {value, approx, covered}: covered the seconds of the + window from first on; total the amount inside the window, every + other period that amount per its seconds of covered; value None + where no record covers the window; approx where the window is + shorter than finest, and for every period but total where it starts + before first. """ - found: dict[str, float | None] = {} - for name, seconds in PERIODS: - if seconds is None: - found[name] = sum(piece[2] for piece in pieces) - else: - found[name] = None if seconds < finest else sum(share(piece, now - seconds, now) for piece in pieces) - return found - - -def lengths(now: float, since: float | None) -> dict[str, float | None]: - total = now - since if since is not None and now > since else None - return {name: total if seconds is None else float(seconds) for name, seconds in PERIODS} - - -def held(now: float, since: float | None, begins: float | None) -> dict[str, float | None]: - """Args: - now: the end of every window. - since: the first time any record holds. - begins: the first time the records of one kind hold, None when they - reach back as far as any record. - - Returns: - Per period the seconds now - begins where other records reach - further back into its window than this kind's, else None. - """ - if since is None or begins is None: - return dict.fromkeys(PERIOD_NAMES) - return {name: now - begins if begins > (since if seconds is None else max(now - seconds, since)) else None for name, seconds in PERIODS} - - -def estimate(own: dict[str, float | None], length: dict[str, float | None], partial: dict[str, float | None], index: int) -> tuple[float, str | None]: - """Returns: - (value, source) of the period at index in PERIODS: its own amount - when partial holds no seconds for it and it holds any or is total; - its own amount scaled from the partial seconds to the part of its - window any record covers when it holds any, source total; else the - shortest longer window that holds any, scaled to the period's length - (at most its whole amount), source that window, or total when - partial holds seconds for that window and those scale it; 0 without - any. - """ - name, seconds = PERIODS[index] - value = own[name] - if partial[name] is None and (value or seconds is None): - return value or 0.0, None - if value and partial[name]: - return value * min(length[name], length[TOTAL]) / partial[name], TOTAL - for other, _ in PERIODS[index + 1:]: - if own[other] and length[other]: - covered = partial[other] or length[other] - return own[other] * min(1.0, (seconds or covered) / covered), TOTAL if partial[other] else other - return 0.0, None - - -def extrapolated(own: dict[str, float | None], length: dict[str, float | None], partial: dict[str, float | None]) -> dict[str, dict]: - """Args: - own: sums() of one kind. - length: lengths() of the windows. - partial: held() of the kind. - - Returns: - Per period {value, approx, source} of estimate(); approx whenever it - names a source. - """ - found = {} - for index, name in enumerate(PERIOD_NAMES): - value, source = estimate(own, length, partial, index) - found[name] = {"value": precise(value), "approx": source is not None, "source": source} - return found + begin, end = window + covered = end - max(begin, first) if first is not None else 0.0 + if covered <= 0: + return {name: {"value": None, "approx": False, "covered": None} for name in PERIOD_NAMES} + amount = sum(share(piece, begin, end) for piece in pieces) + short, early = end - begin < finest, begin < first + return { + name: {"value": precise(amount if seconds is None else amount * seconds / covered), "approx": short or (early and seconds is not None), "covered": covered} + for name, seconds in PERIODS + } def precise(value: float) -> float: @@ -207,10 +150,6 @@ def blank() -> dict: return {**{key: [0.0, 0.0] for key in HOST}, "vram": [0.0, 0.0, 0.0], "disks": {}} -def copied(tally: dict) -> dict: - return {**{key: list(tally[key]) for key in (*HOST, "vram")}, "disks": {mount: list(cell) for mount, cell in tally["disks"].items()}} - - def add_vram(cell: list[float], gpus: object, weight: float) -> None: used = total = 0.0 for gpu in gpus if type(gpus) is list else (): @@ -258,30 +197,16 @@ def add(tally: dict, row: dict, part: float) -> None: add_disks(tally["disks"], row.get("disks"), weight) -def tallies(items: list[Placed], begins: list[float]) -> list[dict]: - """Args: - items: placed() of every sample row, newest first. - begins: the start of every window, latest first; every window ends - at the newest row or later. - - Returns: - Per window the add() of every row inside it, a row whose bucket - straddles its start by the share inside, in one pass over items. +def tally(items: list[Placed], window: tuple[float, float]) -> dict: + """Returns: + The add() of every placed() row inside the window, a row whose + bucket straddles either end by its share inside. """ - widest = max((item[1] for item in items), default=0.0) - running, index, found = blank(), 0, [] - for begin in begins: - while index < len(items) and items[index][0] >= begin: - add(running, items[index][2], 1.0) - index += 1 - tally = copied(running) - cursor = index - while cursor < len(items) and items[cursor][0] > begin - widest: - t, width, row = items[cursor] - if t + width > begin: - add(tally, row, (t + width - begin) / width) - cursor += 1 - found.append(tally) + found = blank() + for t, width, row in items: + part = share((t, t + width, 1.0), *window) + if part: + add(found, row, part) return found @@ -311,40 +236,38 @@ def gauges(tally: dict) -> dict[str, dict]: found = {key: {"value": rounded(mean(tally[key], 1), 1)} for key in HOST} found["vram"] = {"value": rounded(mean(tally["vram"], 1), 1), "used": rounded(mean(tally["vram"], 2), 0)} found["disk"] = fullest(tally["disks"]) - return {key: {**entry, "approx": False, "source": None} for key, entry in found.items()} + return {key: {**entry, "approx": False} for key, entry in found.items()} -def rated(council: Path, kept: Path, now: float) -> dict: +def rated(council: Path, kept: Path, now: float, window: tuple[float, float]) -> dict: """Args: council: the council directory holding the register and the score journal, read through scores.journal(). kept: the directory holding the host sampler's resources folder. - now: the end of every window in epoch seconds. + now: the present in epoch seconds; the current token hour ends here. + window: (begin, end) the rates cover, end at most now. Returns: - {"now", "since", "periods", "rates"}: since the first time any record - holds; periods [{name, seconds}], total without seconds; rates per - period per metric {value, approx, source}: the done tasks, the - commits, the key results met and the tokens inside the window ending - now, extrapolated() where it holds none or, for tokens, where it - reaches back before the first token row, and the gauges() of the - samples inside it; total spans every record. + {"now", "since", "from", "to", "periods", "rates"}: since the first + time any record holds; periods [{name, seconds}], total without + seconds; rates per period per metric: counted() of the done tasks, + the commits, the key results met and the tokens, each kind covered + from since on, tokens from their first row, and the gauges() of the + samples inside the window, the same in every period. """ tasks = read_register(council / REGISTER) folder = kept / RESOURCES - items = sorted(filter(None, map(placed, rows_between(folder / SAMPLES, 0, now, 0))), key=lambda item: item[0], reverse=True) - counted = { + items = list(filter(None, map(placed, rows_between(folder / SAMPLES, 0, now, 0)))) + pieces = { "tasks": points(task_times(tasks)), "commits": points(commit_times(journal(council))), "krs": points(kr_times(tasks)), "tokens": token_pieces(rows_between(folder / TOKENS, 0, now, HOUR), now), } - starts = {kind: [piece[0] for piece in pieces if piece[0] is not None] for kind, pieces in counted.items()} - times = [*(t for found in starts.values() for t in found), *(item[0] for item in items)] - since = min(times) if times else None - length = lengths(now, since) - begins = {"tokens": min(starts["tokens"], default=None)} - counts = {kind: extrapolated(sums(pieces, now, FINEST.get(kind, 0)), length, held(now, since, begins.get(kind))) for kind, pieces in counted.items()} - measured = tallies(items, [-math.inf if seconds is None else now - seconds for _, seconds in PERIODS]) - shown = {name: {**{kind: counts[kind][name] for kind in COUNTS}, **gauges(tally)} for name, tally in zip(PERIOD_NAMES, measured, strict=True)} - return {"now": now, "since": since, "periods": [{"name": name, "seconds": seconds} for name, seconds in PERIODS], "rates": shown} + starts = {kind: [piece[0] for piece in found if piece[0] is not None] for kind, found in pieces.items()} + since = min([*(t for found in starts.values() for t in found), *(item[0] for item in items)], default=None) + firsts = {**dict.fromkeys(COUNTS, since), "tokens": min(starts["tokens"], default=None)} + counts = {kind: counted(found, window, firsts[kind], FINEST[kind]) for kind, found in pieces.items()} + measured = gauges(tally(items, window)) + shown = {name: {**{kind: counts[kind][name] for kind in COUNTS}, **measured} for name in PERIOD_NAMES} + return {"now": now, "since": since, "from": window[0], "to": window[1], "periods": [{"name": name, "seconds": seconds} for name, seconds in PERIODS], "rates": shown} diff --git a/orchestrator/kvb_orchestrator/settings.py b/orchestrator/kvb_orchestrator/settings.py index e140b82..a8e85db 100644 --- a/orchestrator/kvb_orchestrator/settings.py +++ b/orchestrator/kvb_orchestrator/settings.py @@ -50,7 +50,7 @@ SETTINGS = { "bubbles": False, "rates": {"period": "hour", "metrics": ["tasks", "tokens", "cpu"]}, } -RATE_CHIP = (2, 3) +RATE_CHIP = (2, 9) SPACE_AXES = ("none", "time", "spawn") SPACE_LIMITS = { "graph": {"yaw": (-180.0, 180.0), "pitch": (-90.0, 90.0), "zoom": (0.25, 4.0), "pan_x": (-2000.0, 2000.0), "pan_y": (-2000.0, 2000.0)}, diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index a86f92b..3e92753 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -466,7 +466,6 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi diff --git a/orchestrator/templates/page-boot.js b/orchestrator/templates/page-boot.js index 924733c..b64c127 100644 --- a/orchestrator/templates/page-boot.js +++ b/orchestrator/templates/page-boot.js @@ -48,7 +48,7 @@ syncBubbles(); syncMusic(); syncRadio(); - timeBar(); + ratesBar(); notifyLabel(); announce(); measure(); diff --git a/orchestrator/templates/page-constants.js b/orchestrator/templates/page-constants.js index a47f11c..f5a8a30 100644 --- a/orchestrator/templates/page-constants.js +++ b/orchestrator/templates/page-constants.js @@ -3,7 +3,7 @@ const ACTIVE_BEAT = 900; const DAY = 86400; const HUMAN = "Operator"; - const PRESETS = [[3600, "1 h"], [21600, "6 h"], [DAY, "24 h"], [7 * DAY, "7 d"], [0, "all"], [-1, "custom"]]; + const PRESETS = [[3600, "1 h"], [21600, "6 h"], [DAY, "24 h"], [7 * DAY, "7 d"], [0, "all"]]; const PARTS = [["user", "User"], ["assistant", "Assistant"], ["tool_call", "Tool call"], ["tool_result", "Tool result"], ["system", "System"]]; const PART_TONES = {user: "info", assistant: "ok", tool_call: "violet", tool_result: "teal", system: "neutral"}; const KIND_TONES = {radio: "teal", review: "info", ask: "warn", decision: "violet", operator: "bad", register: "neutral", rename: "info", cron: "teal", rule: "ok", approval: "ok", run: "info", transcript: "neutral"}; diff --git a/orchestrator/templates/page-dom.js b/orchestrator/templates/page-dom.js index 178e6df..d150a89 100644 --- a/orchestrator/templates/page-dom.js +++ b/orchestrator/templates/page-dom.js @@ -50,7 +50,7 @@ const counter = (value) => h("span", {class: "count"}, String(value)); const meta = (pairs) => h("dl", {class: "meta"}, pairs.map(([label, value, title]) => h("div", {}, h("dt", {}, label), h("dd", {}, h("code", {title: title ? revealed(title) : null}, revealed(dash(value))))))); const emptyState = (title, text) => h("div", {class: "empty"}, h("div", {class: "empty-mark", "aria-hidden": "true"}), h("h2", {}, title), h("p", {}, text)); - const live = () => ui.preset !== -1 && ui.asOf === null; + const live = () => ui.asOf === null; const alarmRows = () => state.radio.filter((row) => (row.class === "mayday" || row.class === "pan-pan") && row.ts >= state.alarm_since).reverse(); const keyOf = (item) => `${item.kind}:${item.id}`; const visibleInbox = () => state.inbox.filter((item) => ui.snoozed || !item.until); diff --git a/orchestrator/templates/page-filters.js b/orchestrator/templates/page-filters.js index 37fe5d6..2c462d0 100644 --- a/orchestrator/templates/page-filters.js +++ b/orchestrator/templates/page-filters.js @@ -23,9 +23,6 @@ } function windowKey() { - if (ui.preset === -1) { - return `custom:${ui.from}:${ui.to}`; - } return `${ui.preset}:${ui.asOf === null ? "live" : ui.asOf}`; } diff --git a/orchestrator/templates/page-rates.js b/orchestrator/templates/page-rates.js index fae5b68..486ad30 100644 --- a/orchestrator/templates/page-rates.js +++ b/orchestrator/templates/page-rates.js @@ -1,4 +1,4 @@ - const RATES = {poll: 60, fewest: 2, most: 3}; + const RATES = {poll: 60, fewest: 2, most: 9}; const RATE_PERIODS = [ ["minute", "min", "per minute"], ["hour", "h", "per hour"], @@ -6,7 +6,7 @@ ["week", "wk", "per week"], ["month", "mo", "per month of 30 days"], ["year", "yr", "per year of 365 days"], - ["total", "all", "in total since records begin"], + ["total", "all", "in the whole window"], ]; const RATE_METRICS = [ ["tasks", "bi-check2-square", "Tasks done", "count"], @@ -20,7 +20,7 @@ ["disk", "bi-hdd", "Disk", "disk"], ]; const BYTE_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]; - const rateView = {data: null, dom: null, busy: false, at: -Infinity}; + const rateView = {data: null, dom: null, ticket: 0, at: -Infinity}; const periodOf = (id) => RATE_PERIODS.find(([name]) => name === id) || RATE_PERIODS[1]; const metricOf = (id) => RATE_METRICS.find(([name]) => name === id); @@ -43,7 +43,7 @@ * @param entry - one metric of one period from /api/rates, or null before the first answer. * @param kind - the metric's kind: count, percent, vram or disk. * @param short - the period's short name a count is per, "" for none. - * @returns the cell text: β‰ˆ before an extrapolated count, n/a for a gauge without a sample. + * @returns the cell text: β‰ˆ before an estimated count, n/a without a record or sample in the window. */ function rateText(entry, kind, short) { if (!entry) { @@ -65,10 +65,11 @@ return `${label} ${per}: loading`; } if (entry.value === null) { - return `${label} ${per}: n/a, no sample in this window`; + return `${label} ${per}: n/a, ${kind === "count" ? "no record of this kind reaches into the window" : "no sample in the window"}`; } - const source = entry.source === "total" ? "all records of this kind" : `the last ${entry.source}`; - const scaled = entry.approx ? `; β‰ˆ none in this window or its records begin later, scaled from ${source}` : ""; + const length = rateView.data.to - rateView.data.from; + const covered = entry.covered !== null && entry.covered < length - 1; + const scaled = !entry.approx ? "" : covered ? `; β‰ˆ its records cover only the last ${spanName(entry.covered)} of the window, so the rate divides by that part` : "; β‰ˆ the window is shorter than the hour tokens are counted in"; const where = id === "disk" ? ` on ${entry.mount}, ${bytesText(entry.used)} of ${bytesText(entry.total)}` : ""; const mean = kind === "count" ? "" : " on average"; return `${label} ${per}: ${rateText(entry, kind, "")}${mean}${where}${scaled}`; @@ -76,18 +77,19 @@ function ratesBar() { const host = document.getElementById("rates"); - const period = h("select", {class: "field rates-period", ...named("Rate period", "Rate period: the window the chip counts over"), on: {change: (event) => chooseRates({...settings.rates, period: event.target.value})}}, - RATE_PERIODS.map(([id, short, per]) => h("option", {value: id, title: per}, short))); const chip = h("summary", {class: "rates-chip"}); + const units = h("div", {class: "segmented rates-units", role: "group", "aria-label": "Rate unit"}, + RATE_PERIODS.map(([id, short, per]) => h("button", {type: "button", "data-period": id, title: per, on: {click: () => chooseRates({...settings.rates, period: id})}}, short))); const body = h("tbody", {}); const head = h("tr", {}, h("th", {scope: "col"}, "Metric"), h("th", {scope: "col", title: "Shown in the chip"}, "Chip"), RATE_PERIODS.map(([id, short, per]) => h("th", {scope: "col", "data-period": id, title: per}, short))); const box = h("div", {class: "menu-box end rates-box", role: "group", "aria-label": "Rates per period"}, - h("h3", {}, "Rates per period"), + h("h3", {}, "Rates per period"), ...timeSection(), h("h3", {}, "Unit"), units, h("div", {class: "rates-scroll"}, h("table", {class: "rates-table"}, h("thead", {}, head), body)), - h("p", {class: "muted"}, `β‰ˆ means an estimate: none in the window, so the shortest longer window that holds any, scaled down, or a window reaching back before the records of its kind begin, scaled from those records. n/a means no sample in the window. Total counts since records begin; the gauges average over the window. The chip shows ${RATES.fewest} to ${RATES.most} metrics.`)); + h("p", {class: "muted"}, `Every column rates the chosen window: a count is its sum per unit, all the sum itself; a gauge averages over the window. β‰ˆ means the records of a kind begin inside the window, so the rate divides by the part they cover, or the window is shorter than the hour tokens are counted in. n/a means no record or sample in the window. The chip shows ${RATES.fewest} to ${RATES.most} metrics.`)); const menu = h("details", {class: "menu rates-menu"}, chip, box); - host.replaceChildren(period, menu); - rateView.dom = {period, chip, body, menu}; + host.replaceChildren(menu); + rateView.dom = {chip, units, body, menu}; + window.addEventListener("resize", () => fitChip(chip)); } function rateCell(metric, period, chosen) { @@ -105,6 +107,23 @@ return h("tr", {"data-metric": id}, h("th", {scope: "row"}, icon(name), ` ${label}`), h("td", {}, pick), RATE_PERIODS.map((period) => rateCell(metric, period, chosen))); } + function fitChip(chip) { + const shown = [...chip.querySelectorAll(".rate")]; + const more = chip.querySelector(".rate-more"); + if (!more) { + return; + } + shown.forEach((node) => { + node.hidden = false; + }); + more.hidden = true; + for (let kept = shown.length; kept > 1 && chip.scrollWidth > chip.clientWidth; kept -= 1) { + shown[kept - 1].hidden = true; + more.hidden = false; + more.textContent = `+${shown.length - kept + 1}`; + } + } + function drawRates() { const dom = rateView.dom; if (!dom) { @@ -114,11 +133,16 @@ const period = periodOf(chosen.period); const short = period[0] === "total" ? "" : period[1]; const entries = chosen.metrics.map((id) => [metricOf(id), rateView.data ? rateView.data.rates[period[0]][id] : null]); - dom.period.value = period[0]; - dom.chip.replaceChildren(...entries.map(([metric, entry]) => h("span", {class: "rate", "data-metric": metric[0], "data-approx": String(Boolean(entry && entry.approx)), title: rateHint(entry, metric, period)}, - icon(metric[1]), h("span", {class: "rate-value"}, rateText(entry, metric[3], metric[3] === "count" ? short : "")))), caret()); - dom.chip.setAttribute("aria-label", `Rates ${period[2]}: ${entries.map(([metric, entry]) => `${metric[2]} ${rateText(entry, metric[3], "")}`).join(", ")}`); - dom.chip.title = "Rates: every metric per period"; + for (const button of dom.units.children) { + button.setAttribute("aria-pressed", String(button.dataset.period === period[0])); + } + dom.chip.replaceChildren(h("span", {class: "rate-window"}, `${windowName()} Β· ${short ? `/${short}` : "all"}`), + ...entries.map(([metric, entry]) => h("span", {class: "rate", "data-metric": metric[0], "data-approx": String(Boolean(entry && entry.approx)), title: rateHint(entry, metric, period)}, + icon(metric[1]), h("span", {class: "rate-value"}, rateText(entry, metric[3], metric[3] === "count" ? short : "")))), + h("span", {class: "rate-more", hidden: true}), caret()); + dom.chip.setAttribute("aria-label", `Rates ${period[2]} over ${windowName()}: ${entries.map(([metric, entry]) => `${metric[2]} ${rateText(entry, metric[3], "")}`).join(", ")}`); + dom.chip.title = "Rates per period: time range, replay, unit and every metric"; + fitChip(dom.chip); const focused = document.activeElement instanceof Element ? document.activeElement.closest("#rates tr[data-metric]") : null; dom.body.replaceChildren(...RATE_METRICS.map((metric) => rateRow(metric, chosen))); const again = focused ? dom.body.querySelector(`tr[data-metric="${focused.dataset.metric}"] input`) : null; @@ -134,26 +158,22 @@ } async function fetchRates() { - rateView.busy = true; + rateView.ticket += 1; + const ticket = rateView.ticket; + rateView.at = nowSeconds(); try { - const response = await fetch("/api/rates", {cache: "no-store"}); - if (response.ok) { + const response = await fetch(`/api/rates?${windowQuery()}`, {cache: "no-store"}); + if (response.ok && ticket === rateView.ticket) { rateView.data = await response.json(); } } catch { ui.offline = true; } - rateView.at = nowSeconds(); - rateView.busy = false; drawRates(); } function pollRates() { - if (!rateView.dom) { - ratesBar(); - drawRates(); - } - if (!document.hidden && !rateView.busy && nowSeconds() - rateView.at >= RATES.poll) { + if (!document.hidden && nowSeconds() - rateView.at >= RATES.poll) { fetchRates(); } } diff --git a/orchestrator/templates/page-resources.js b/orchestrator/templates/page-resources.js index e676a09..142bb83 100644 --- a/orchestrator/templates/page-resources.js +++ b/orchestrator/templates/page-resources.js @@ -8,7 +8,7 @@ }; const RESOURCE_BURN = {done: "Done", scope: "Scope"}; const resourceView = {data: null, dom: null, busy: false, key: "", at: 0, timer: 0, series: {}}; - const resourceKey = () => JSON.stringify([ui.preset, ui.from, ui.to, ui.asOf]); + const resourceKey = () => JSON.stringify([ui.preset, ui.asOf]); const resourcesStale = () => resourceKey() !== resourceView.key || nowSeconds() - resourceView.at >= RESOURCE.stale; const compactCount = Resources.compact; const resourceLabel = (line) => (line.kind === "vram" ? `${line.name} VRAM` : line.name); diff --git a/orchestrator/templates/page-state.js b/orchestrator/templates/page-state.js index 1b90ade..10ca995 100644 --- a/orchestrator/templates/page-state.js +++ b/orchestrator/templates/page-state.js @@ -32,7 +32,7 @@ let state = JSON.parse(document.getElementById("state").textContent); const KINDS = Object.entries(state.kinds); - const ui = {screen: "stream", views: {agents: "orbit", artifacts: "tree", tasks: "list"}, preset: DAY, from: null, to: null, asOf: null, playing: false, busy: false, offline: false, agent: null, order: null, spot: false, nightOff: new Set(), cursor: 0, selected: new Set(), snoozed: false, review: null, file: 0}; + const ui = {screen: "stream", views: {agents: "orbit", artifacts: "tree", tasks: "list"}, preset: DAY, asOf: null, playing: false, busy: false, offline: false, agent: null, order: null, spot: false, nightOff: new Set(), cursor: 0, selected: new Set(), snoozed: false, review: null, file: 0}; const filter = {view: "fuer-dich", saved: "", kinds: new Set(state.views["fuer-dich"].kinds), waiting: true, q: "", agent: "", session: "", sub: "", parts: new Set(PARTS.map(([id]) => id))}; const stream = {key: null, events: [], entries: [], last: 0, sessions: {}, busy: false, again: false, dom: null, error: ""}; const tree = {data: null, model: null, busy: false, q: "", open: new Set(), dom: null}; diff --git a/orchestrator/templates/page-time.js b/orchestrator/templates/page-time.js index c91c5c1..b0681b5 100644 --- a/orchestrator/templates/page-time.js +++ b/orchestrator/templates/page-time.js @@ -1,7 +1,7 @@ + const SPAN_STEPS = 1000; + const SHORTEST = 60; + function windowQuery() { - if (ui.preset === -1) { - return `from=${Math.floor(ui.from)}&to=${Math.ceil(ui.to)}`; - } const end = ui.asOf === null ? nowSeconds() : ui.asOf; const begin = ui.preset === 0 ? 0 : end - ui.preset; return `from=${Math.floor(begin)}${ui.asOf === null ? "" : `&to=${Math.ceil(end)}`}`; @@ -12,9 +12,34 @@ return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().slice(0, 16); }; + function spanName(seconds) { + if (seconds >= DAY) { + return `${Math.round(seconds / DAY)} d`; + } + return seconds >= 3600 ? `${Math.round(seconds / 3600)} h` : `${Math.max(Math.round(seconds / 60), 1)} min`; + } + + function windowName() { + const preset = PRESETS.find(([seconds]) => seconds === ui.preset); + return `${preset ? preset[1] : spanName(ui.preset)}${ui.asOf === null ? "" : " Β· past"}`; + } + + /** + * @param {number} begin the window's start in epoch seconds. + * @param {number} end its end; at or after now the window is live and keeps its length. + */ + function setWindow(begin, end) { + stopReplay(); + const now = nowSeconds(); + const stop = Math.min(end, now); + ui.preset = Math.max(Math.round(stop - begin), SHORTEST); + ui.asOf = end >= now ? null : stop; + reload(); + } + function customRange() { - const from = h("input", {type: "datetime-local", "aria-label": "From", value: localInput(ui.from === null ? state.since : ui.from)}); - const to = h("input", {type: "datetime-local", "aria-label": "To", value: localInput(ui.to === null ? state.until : ui.to)}); + const from = h("input", {type: "datetime-local", "aria-label": "From", value: localInput(state.since)}); + const to = h("input", {type: "datetime-local", "aria-label": "To", value: localInput(state.until)}); return h("span", {class: "custom"}, from, h("span", {class: "muted"}, "to"), to, h("button", {type: "button", class: "btn small soft", on: {click: () => { const begin = Date.parse(from.value) / 1000; @@ -23,47 +48,45 @@ toast("Time range invalid", ["β€œFrom” must come before β€œTo”."], false); return; } - stopReplay(); - ui.preset = -1; - ui.from = begin; - ui.to = end; - reload(); + setWindow(begin, end); }}}, "Apply")); } - function timeBar() { - const bar = document.getElementById("time"); + function spanSlider() { + const [from, to] = ["from", "to"].map((end, index) => h("input", {type: "range", class: `span-${end}`, min: 0, max: SPAN_STEPS, step: 1, value: index * SPAN_STEPS, "aria-label": `Time range ${end}`})); + const fill = h("span", {class: "span-fill", "aria-hidden": "true"}); + const at = (value) => state.first + (Math.max(state.now - state.first, 1) * Number(value)) / SPAN_STEPS; + const moved = (event) => { + if (Number(from.value) >= Number(to.value)) { + event.target.value = String(event.target === from ? Number(to.value) - 1 : Number(from.value) + 1); + } + setWindow(at(from.value), Number(to.value) >= SPAN_STEPS ? nowSeconds() : at(to.value)); + }; + from.addEventListener("input", moved); + to.addEventListener("input", moved); + return {box: h("div", {class: "span-slider"}, fill, from, to), from, to, fill}; + } + + function timeSection() { const presets = h("div", {class: "segmented", role: "group", "aria-label": "Time range"}); - const summary = h("summary", {title: "Time range and replay"}); - const slider = h("input", {type: "range", min: 0, max: 1000, step: 1, value: 1000, "aria-label": "Replay position"}); - const play = iconBtn("bi-play-fill", "Replay", "btn small soft", null); - const liveButton = h("button", {type: "button", class: "btn small ghost"}, "Live"); - const label = h("span", {class: "window-label"}); - for (const [seconds, name] of PRESETS.filter(([seconds]) => seconds !== -1)) { + for (const [seconds, name] of PRESETS) { presets.append(h("button", {type: "button", "data-preset": seconds, on: {click: () => choosePreset(seconds)}}, name)); } - slider.addEventListener("input", () => { - stopReplay(); - const span = state.now - state.first; - ui.asOf = Number(slider.value) >= 1000 ? null : state.first + (span * Number(slider.value)) / 1000; - reload(); - }); - play.addEventListener("click", () => (ui.playing ? stopReplay() : startReplay())); - liveButton.addEventListener("click", () => { + const slider = spanSlider(); + const play = iconBtn("bi-play-fill", "Replay", "btn small soft", () => (ui.playing ? stopReplay() : startReplay())); + const liveButton = h("button", {type: "button", class: "btn small ghost", on: {click: () => { stopReplay(); ui.asOf = null; - if (ui.preset === -1) { - ui.preset = DAY; - } reload(); - }); - bar.append(summary, h("div", {class: "menu-box end"}, h("h3", {}, "Time range"), presets, h("h3", {}, "Replay"), h("div", {class: "replay"}, play, slider, liveButton), label, - h("p", {class: "muted"}, "Filter β–Ύ in the stream sets a custom time range."))); - timeDom = {summary, presets, slider, play, live: liveButton, label}; + }}}, "Live"); + const label = h("span", {class: "window-label"}); + timeDom = {presets, from: slider.from, to: slider.to, fill: slider.fill, play, live: liveButton, label}; + return [h("h3", {}, "Time range"), presets, slider.box, h("div", {class: "replay"}, play, liveButton, label), customRange()]; } function reload() { load(); + fetchRates(); if (ui.screen === "stream") { fetchEvents(); } @@ -72,6 +95,7 @@ function choosePreset(seconds) { stopReplay(); ui.preset = seconds; + ui.asOf = null; reload(); } @@ -80,27 +104,26 @@ return; } for (const button of timeDom.presets.children) { - button.setAttribute("aria-pressed", String(Number(button.dataset.preset) === ui.preset)); + button.setAttribute("aria-pressed", String(Number(button.dataset.preset) === ui.preset && ui.asOf === null)); } - timeDom.summary.textContent = `${(PRESETS.find(([seconds]) => seconds === ui.preset) || [0, "custom"])[1]}${ui.asOf === null ? "" : " Β· replay"} β–Ύ`; - timeDom.slider.disabled = ui.preset === -1; - timeDom.play.disabled = ui.preset === -1; - timeDom.live.disabled = live(); const span = Math.max(state.now - state.first, 1); - if (!ui.playing) { - timeDom.slider.value = String(ui.asOf === null ? 1000 : Math.round((1000 * (ui.asOf - state.first)) / span)); - } + const end = ui.asOf === null ? state.now : ui.asOf; + const place = (t) => Math.min(Math.max(Math.round((SPAN_STEPS * (t - state.first)) / span), 0), SPAN_STEPS); + const [low, high] = [place(ui.preset === 0 ? state.first : end - ui.preset), ui.asOf === null ? SPAN_STEPS : place(end)]; + timeDom.from.value = String(Math.min(low, high - 1)); + timeDom.to.value = String(high); + timeDom.from.classList.toggle("on-top", low > SPAN_STEPS / 2); + timeDom.fill.style.left = `${(100 * low) / SPAN_STEPS}%`; + timeDom.fill.style.right = `${100 - (100 * high) / SPAN_STEPS}%`; + timeDom.live.disabled = live(); timeDom.label.textContent = `${absolute.format(stampOf(state.since))} – ${absolute.format(stampOf(state.until))}${live() ? " Β· live" : ""}`; } function startReplay() { - if (ui.preset === -1) { - return; - } - const began = state.first; + const began = state.first + (ui.preset === 0 ? 0 : ui.preset); const span = Math.max(state.now - began, 1); const resume = ui.asOf !== null && ui.asOf < state.now - 60; - let progress = resume ? (ui.asOf - began) / span : 0; + let progress = resume ? Math.max((ui.asOf - began) / span, 0) : 0; ui.playing = true; relabel(timeDom.play, "bi-pause-fill", "Pause"); const advance = async () => { @@ -109,8 +132,8 @@ } progress = Math.min(progress + 1 / 48, 1); ui.asOf = progress >= 1 ? null : began + span * progress; - timeDom.slider.value = String(Math.round(progress * 1000)); await load(); + fetchRates(); if (ui.screen === "stream") { fetchEvents(); } diff --git a/orchestrator/templates/style-rates.css b/orchestrator/templates/style-rates.css index 9ce0937..921e0aa 100644 --- a/orchestrator/templates/style-rates.css +++ b/orchestrator/templates/style-rates.css @@ -1,12 +1,28 @@ .rates { display: inline-flex; align-items: center; gap: 4px; min-width: 0; max-width: 100%; } -.rates-period { padding: 3px 6px; border-radius: 999px; font-size: var(--fs-xs); } -.rates-menu > summary.rates-chip { gap: 10px; padding: 3px 10px; border-radius: 999px; font-size: var(--fs-sm); font-weight: 560; font-variant-numeric: tabular-nums; white-space: nowrap; } +.rates-menu { min-width: 0; max-width: 100%; } +.rates-menu > summary.rates-chip { gap: 10px; max-width: 100%; min-width: 0; padding: 3px 10px; overflow: hidden; border-radius: 999px; font-size: var(--fs-sm); font-weight: 560; font-variant-numeric: tabular-nums; white-space: nowrap; } .rates-chip .rate { display: inline-flex; align-items: center; gap: 4px; } +.rates-chip .rate[hidden], .rates-chip .rate-more[hidden] { display: none; } +.rates-chip .rate-window, .rates-chip .rate-more { color: var(--muted); font-size: var(--fs-xs); } .rates-chip .bi { color: var(--muted); } +.span-slider { position: relative; height: 28px; } +.span-slider::before, .span-fill { position: absolute; top: 50%; height: 4px; margin-top: -2px; border-radius: 2px; content: ""; } +.span-slider::before { right: 0; left: 0; background: var(--line); } +.span-fill { background: var(--accent); } +.span-slider input[type="range"] { position: absolute; inset: 0; width: 100%; height: 100%; margin: 0; background: none; pointer-events: none; appearance: none; -webkit-appearance: none; } +.span-slider input[type="range"].on-top { z-index: 1; } +.span-slider input[type="range"]::-webkit-slider-runnable-track { background: none; } +.span-slider input[type="range"]::-moz-range-track { background: none; } +.span-slider input[type="range"]::-webkit-slider-thumb { width: 18px; height: 18px; border: 2px solid var(--panel); border-radius: 50%; background: var(--accent); cursor: grab; pointer-events: auto; appearance: none; -webkit-appearance: none; } +.span-slider input[type="range"]::-moz-range-thumb { width: 14px; height: 14px; border: 2px solid var(--panel); border-radius: 50%; background: var(--accent); cursor: grab; pointer-events: auto; } +.span-slider input[type="range"]:focus-visible::-webkit-slider-thumb { outline: 2px solid var(--accent); outline-offset: 2px; } +.span-slider input[type="range"]:focus-visible::-moz-range-thumb { outline: 2px solid var(--accent); outline-offset: 2px; } .rates-chip .rate[data-approx="true"] .rate-value, .rates-table td[data-approx="true"] { color: var(--muted); } .rates-box { max-width: min(1100px, calc(100vw - 32px)); } .rates-scroll { max-width: 100%; overflow-x: auto; } .rates-box > p { width: 0; min-width: 100%; margin: 0; } +.rates-box .replay { flex-wrap: wrap; min-width: 0; } +.rates-box .window-label { min-width: 0; white-space: normal; } .rates-table { border-collapse: collapse; font-size: var(--fs-sm); font-variant-numeric: tabular-nums; } .rates-table th, .rates-table td { padding: 3px 8px; border-bottom: 1px solid var(--line); text-align: right; white-space: nowrap; } .rates-table thead th { color: var(--muted); font-size: var(--fs-xs); font-weight: 650; } diff --git a/tests/e2e/bidi.mjs b/tests/e2e/bidi.mjs index adff41b..5b523a8 100644 --- a/tests/e2e/bidi.mjs +++ b/tests/e2e/bidi.mjs @@ -4,14 +4,15 @@ import {createServer} from "node:net"; import {tmpdir} from "node:os"; import {join} from "node:path"; -// Args: ; the plan lists steps {width, height, url, wait, probe, shot, gesture} and an optional -// init like cdp.mjs. +// Args: ; the plan lists steps {width, height, url, wait, keys, probe, shot, gesture} and an +// optional init like cdp.mjs. // Prints {results, errors}: one probe value per step and every JavaScript error the page logged. const [binary, planFile] = process.argv.slice(2); const plan = JSON.parse(readFileSync(planFile, "utf8")); const profile = mkdtempSync(join(tmpdir(), "bidi-")); writeFileSync(join(profile, "user.js"), ['user_pref("media.navigator.streams.fake", true);', 'user_pref("media.navigator.permission.disabled", true);', ""].join("\n")); const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); +const KEYS = {Enter: "", Tab: "", ArrowLeft: "ξ€’", ArrowRight: "ξ€”"}; const port = await new Promise((resolve) => { const probe = createServer().listen(0, "127.0.0.1", () => { const {port: free} = probe.address(); @@ -81,6 +82,10 @@ try { await send("browsingContext.navigate", {context, url: step.url, wait: "complete"}); } await sleep(step.wait); + for (const key of step.keys || []) { + await send("input.performActions", {context, actions: [{type: "key", id: "keyboard", actions: [{type: "keyDown", value: KEYS[key]}, {type: "keyUp", value: KEYS[key]}]}]}); + await sleep(250); + } let value = null; if (step.probe) { const answer = await send("script.evaluate", {expression: `(async () => JSON.stringify(await ${step.probe}))()`, target: {context}, awaitPromise: true, resultOwnership: "none", userActivation: Boolean(step.gesture)}); diff --git a/tests/e2e/cdp.mjs b/tests/e2e/cdp.mjs index 381dc24..1eee960 100644 --- a/tests/e2e/cdp.mjs +++ b/tests/e2e/cdp.mjs @@ -4,7 +4,7 @@ import {tmpdir} from "node:os"; import {join} from "node:path"; // Args: ; the plan lists steps {width, height, url, wait, keys, probe, shot, media, gesture}, -// keys being real key presses (Enter, Tab) on the focused element before the probe and gesture running the probe with a +// keys being real key presses (Enter, Tab, ArrowLeft, ArrowRight) on the focused element before the probe and gesture running the probe with a // user activation like a click, an optional init, the text of a function every new document runs before its own scripts, // and an optional authenticator {credentialId, privateKey, rpId}: base64 id and PKCS#8 key of a passkey the page may sign with. // Prints {results, errors}: one probe value per step and every uncaught page exception. @@ -17,7 +17,7 @@ const profile = mkdtempSync(join(tmpdir(), "cdp-")); const flags = ["--headless", "--no-sandbox", "--disable-gpu", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-certificate-errors", "--use-fake-device-for-media-stream", "--use-fake-ui-for-media-stream", "--no-first-run", "--no-default-browser-check", "--hide-scrollbars", `--user-data-dir=${profile}`, "--remote-debugging-port=0", "about:blank"]; const browser = spawn(binary, flags, {stdio: ["ignore", "ignore", "pipe"]}); const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); -const KEYS = {Enter: [13, "\r"], Tab: [9, ""]}; +const KEYS = {Enter: [13, "\r"], Tab: [9, ""], ArrowLeft: [37, ""], ArrowRight: [39, ""]}; const address = await new Promise((resolve, reject) => { let text = ""; diff --git a/tests/e2e/hub_e2e_views.py b/tests/e2e/hub_e2e_views.py index 61d4277..62ddad1 100644 --- a/tests/e2e/hub_e2e_views.py +++ b/tests/e2e/hub_e2e_views.py @@ -25,8 +25,8 @@ PROBE = """(async () => {@HELPERS@ layouts: all('#main [aria-label="Layout"] button').map(name), chips: all('#main [aria-label="Categories"] button').map(name), menus: all("#main details.menu > summary").map(name), - time: text(document.querySelector("#time > summary")), - replay: Boolean(document.querySelector("#time .replay input[type=range]")), + time: text(document.querySelector("#rates .rate-window")), + replay: Boolean(document.querySelector("#rates .span-slider input[type=range]")), custom: Boolean(document.querySelector('#main details.menu input[type="datetime-local"]')), toolbar: all('#main [role="toolbar"] > *').map((node) => name(node.tagName === "DETAILS" ? node.querySelector("summary") : node.querySelector("button") || node)), spot: (() => { diff --git a/tests/e2e/test_orchestrator_e2e.py b/tests/e2e/test_orchestrator_e2e.py index 0ffbd70..14d93de 100644 --- a/tests/e2e/test_orchestrator_e2e.py +++ b/tests/e2e/test_orchestrator_e2e.py @@ -144,7 +144,7 @@ class TestOrchestratorE2E(base.OrchestratorE2ECase): self.assertEqual(probe["badges"], {"tab-home": None, "tab-stream": None, "tab-rules": None, "tab-agents": "1", "tab-artifacts": None, "tab-tasks": "2", "tab-resources": None}) self.assertEqual(probe["banner"], "MAYDAY Β· Docs: disk full") self.assertFalse(probe["rail"]) - self.assertEqual((probe["time"], probe["replay"]), ("24 h β–Ύ", True)) + self.assertEqual((probe["time"], probe["replay"]), ("24 h Β· /h", True)) self.assertGreater(probe["icons"], 8) self.assertEqual(labelled(probe), {"unlabelled": [], "broken": []}) self.assertFalse(probe["wide"], "the page scrolls sideways") diff --git a/tests/e2e/test_rates_chip_e2e.py b/tests/e2e/test_rates_chip_e2e.py index 8b31cda..8de89db 100644 --- a/tests/e2e/test_rates_chip_e2e.py +++ b/tests/e2e/test_rates_chip_e2e.py @@ -18,22 +18,24 @@ from hub_support import iso OUT = Path(os.environ.get("E2E_OUT", "/tmp/hub-header-rates-shots")) HOUR = 3600 +DAY = 86400 GIB = 1 << 30 -PERIODS = {1920: "day", 1366: "week", 390: "minute"} -BEFORE = {1920: "hour", 1366: "day", 390: "week"} -CHOSEN = {1920: ["tasks", "tokens", "commits"], 1366: ["tasks", "tokens", "cpu"], 390: ["tasks", "tokens", "commits"]} -TASKS = {"minute": ("β‰ˆ 0.02/min", "true"), "hour": ("1/h", "false"), "day": ("2/d", "false"), "week": ("2/wk", "false"), "month": ("2/mo", "false"), "year": ("2/yr", "false"), "total": ("2", "false")} METRICS = ["tasks", "commits", "krs", "tokens", "cpu", "ram", "vram", "swap", "disk"] HEAD = ["Metric", "Chip", "min", "h", "d", "wk", "mo", "yr", "all"] +PARTS = {"presets": ["1 h", "6 h", "24 h", "7 d", "all"], "thumbs": 2, "replay": True, "live": True, "range": ["From", "To"], "units": ["min", "h", "d", "wk", "mo", "yr", "all"], "head": HEAD} READ = """ const chip = () => document.querySelector("#rates summary.rates-chip"); - const period = () => document.querySelector('#rates select[aria-label="Rate period"]'); const menu = () => document.querySelector("#rates details.rates-menu"); const box = () => document.querySelector("#rates .rates-box"); + const thumb = (end) => document.querySelector(`#rates .span-slider .span-${end}`); + const unit = (short) => all("#rates .rates-units button").find((button) => text(button) === short); + const preset = (name) => all('#rates [aria-label="Time range"] button').find((button) => text(button) === name); const pick = (id) => document.querySelector(`#rates tr[data-metric="${id}"] input[type="checkbox"]`); - const metrics = () => all("#rates summary .rate").map((node) => node.dataset.metric); - const values = () => Object.fromEntries(all("#rates summary .rate").map((node) => [node.dataset.metric, text(node)])); - const loaded = () => Boolean(chip() && metrics().length && !text(chip()).includes("…")); + const shown = () => all("#rates summary .rate").filter((node) => !node.hidden).map((node) => node.dataset.metric); + const value = (id) => text(document.querySelector(`#rates summary .rate[data-metric="${id}"] .rate-value`)); + const cell = (id, period) => text(document.querySelector(`#rates tr[data-metric="${id}"] td[data-period="${period}"]`)); + const windowText = () => text(document.querySelector("#rates .rate-window")); + const loaded = () => Boolean(chip() && shown().length && !text(chip()).includes("…")); const stored = async () => (await (await fetch("/api/state", {cache: "no-store"})).json()).settings.rates; const storedUntil = async (test, ms) => { const end = Date.now() + ms; @@ -46,67 +48,125 @@ READ = """ } return null; }; + if (!window.e2eAsked) { + window.e2eAsked = []; + const send = window.fetch.bind(window); + window.fetch = (path, init) => { + window.e2eAsked.push(String(path)); + return send(path, init); + }; + } + const asked = (path) => { + const hits = window.e2eAsked.map((entry) => new URL(entry, location.href)).filter((url) => url.pathname === path); + const last = hits[hits.length - 1]; + return last ? {from: Number(last.searchParams.get("from")), to: last.searchParams.has("to") ? Number(last.searchParams.get("to")) : null} : null; + }; const inside = (node) => { const rect = node.getBoundingClientRect(); return rect.width > 0 && rect.left >= -1 && rect.right <= innerWidth + 1; }; const fits = () => { const bar = document.querySelector(".navbar"); - return {wide: document.documentElement.scrollWidth > innerWidth + 1, bar: bar.scrollWidth > bar.clientWidth + 1, chip: inside(chip()), period: inside(period())}; + const spill = menu().open && box().getClientRects().length ? box().scrollWidth > box().clientWidth + 1 : false; + return {wide: document.documentElement.scrollWidth > innerWidth + 1, bar: bar.scrollWidth > bar.clientWidth + 1, chip: inside(chip()), spill}; + }; + const opened = async () => { + if (!menu().open) { + chip().click(); + } + return Boolean(await until(() => menu().open && box().getClientRects().length, 4000)); }; """ -CHOOSE = """(async () => {@HELPERS@@READ@ +PANEL = """(async () => {@HELPERS@@READ@ if (!(await until(loaded, 15000))) { return {error: text(document.getElementById("rates"))}; } - const before = {period: period().value, metrics: metrics()}; - period().value = "@PERIOD@"; - period().dispatchEvent(new Event("change", {bubbles: true})); - const saved = await storedUntil((found) => found.period === "@PERIOD@", 8000); - await until(() => period().value === "@PERIOD@" && loaded(), 4000); - return {before, saved, after: {period: period().value, metrics: metrics(), values: values(), label: chip().getAttribute("aria-label")}, fits: fits(), open: menu().open, violations: window.e2eViolations || null}; + const header = {time: Boolean(document.getElementById("time")), select: all(".navbar select").length, window: windowText()}; + const open = await opened(); + const parts = { + presets: all('#rates [aria-label="Time range"] button').map(text), thumbs: all("#rates .span-slider input[type=range]").length, + replay: Boolean(document.querySelector('#rates .replay button[aria-label="Replay"]')), live: Boolean(all("#rates .replay button").find((button) => text(button) === "Live")), + range: all('#rates .custom input[type="datetime-local"]').map((input) => input.getAttribute("aria-label")), units: all("#rates .rates-units button").map(text), + head: all("#rates .rates-table thead th").map(text), + }; + unit("d").click(); + const saved = await storedUntil((found) => found.period === "day", 8000); + preset("7 d").click(); + const week = Boolean(await until(() => windowText() === "7 d Β· /d" && loaded() && value("tokens").endsWith("/d"), 8000)); + await sleep(600); + const tokens = {chip: value("tokens"), cell: cell("tokens", "day"), current: all('#rates td[aria-current="true"]').map((node) => node.dataset.period)}; + const rates = asked("/api/rates"); + thumb("from").focus(); + return {header, open, parts, saved, week, tokens, rates, now: Date.now() / 1000, from: Number(thumb("from").value), focused: document.activeElement === thumb("from"), fits: fits(), violations: window.e2eViolations || null}; })()""" -OPEN = """(async () => {@HELPERS@@READ@ +STEPPED = """(async () => {@HELPERS@@READ@ + await sleep(800); + const stepped = {from: Number(thumb("from").value), to: Number(thumb("to").value)}; + thumb("from").value = String(Number(thumb("to").value) - 1); + thumb("from").dispatchEvent(new Event("input", {bubbles: true})); + await sleep(800); + thumb("from").focus(); + return {stepped, near: {from: Number(thumb("from").value), to: Number(thumb("to").value)}, focused: document.activeElement === thumb("from")}; +})()""" +BLOCKED = """(async () => {@HELPERS@@READ@ + await sleep(800); + const blocked = {from: Number(thumb("from").value), to: Number(thumb("to").value)}; + thumb("from").value = "100"; + thumb("from").dispatchEvent(new Event("input", {bubbles: true})); + thumb("to").value = "800"; + thumb("to").dispatchEvent(new Event("input", {bubbles: true})); + const past = Boolean(await until(() => windowText() === "7 d Β· past Β· /d" && loaded(), 8000)); + await sleep(800); + const label = text(document.querySelector("#rates .window-label")); + return {blocked, past, label, rates: asked("/api/rates"), state: asked("/api/state"), now: Date.now() / 1000, fits: fits(), violations: window.e2eViolations || null}; +})()""" +REPLAY = """(async () => {@HELPERS@@READ@ + const play = () => document.querySelector("#rates .replay button.icon-only"); + const liveButton = () => all("#rates .replay button").find((button) => text(button) === "Live"); + play().click(); + await sleep(1500); + play().click(); + await sleep(800); + const paused = text(document.querySelector("#rates .window-label")); + await sleep(1500); + const held = text(document.querySelector("#rates .window-label")) === paused && !liveButton().disabled; + play().click(); + const ended = Boolean(await until(() => liveButton().disabled && text(document.querySelector("#rates .window-label")).endsWith("Β· live"), 45000)); + return {paused: !paused.endsWith("Β· live"), held, ended, window: windowText(), playing: play().getAttribute("aria-label"), violations: window.e2eViolations || null}; +})()""" +NINE = """(async () => {@HELPERS@@READ@ + for (const id of @METRICS@) { + if (!pick(id).checked) { + pick(id).click(); + await storedUntil((found) => found.metrics.includes(id), 8000); + await until(() => pick(id) && pick(id).checked, 4000); + } + } + menu().open = false; + await until(() => !menu().open, 2000); + window.dispatchEvent(new Event("resize")); + await sleep(400); + const more = document.querySelector("#rates summary .rate-more"); + return {stored: (await stored()).metrics.length, shown: shown().length, more: more.hidden ? null : text(more), fits: fits(), violations: window.e2eViolations || null}; +})()""" +KEPT = """(async () => {@HELPERS@@READ@ if (!(await until(loaded, 15000))) { return {error: text(document.getElementById("rates"))}; } - const kept = {period: period().value, metrics: metrics(), values: values()}; - chip().click(); - const opened = Boolean(await until(() => menu().open && box().getClientRects().length, 4000)); - const head = all("#rates .rates-table thead th").map(text); - const rows = all("#rates .rates-table tbody tr").map((row) => [row.dataset.metric, all("td[data-period]", row).length]); - const current = all('#rates .rates-table td[aria-current="true"]').map((cell) => cell.dataset.period); - const tasks = Object.fromEntries(all('#rates tr[data-metric="tasks"] td[data-period]').map((cell) => [cell.dataset.period, [text(cell), cell.dataset.approx]])); - const hint = document.querySelector('#rates tr[data-metric="tasks"] td[data-period="minute"]').title; - const [drop, add] = metrics().includes("cpu") ? ["cpu", "commits"] : ["commits", "cpu"]; - const locked = pick(add).disabled; - pick(drop).click(); - await storedUntil((found) => !found.metrics.includes(drop), 8000); - await until(() => !metrics().includes(drop) && pick(add) && !pick(add).disabled, 4000); - const fewest = all("#rates tbody input:checked").map((input) => input.disabled); - pick(add).click(); - const swapped = await storedUntil((found) => found.metrics.includes(add), 8000); - await until(() => metrics().includes(add), 4000); - return {kept, opened, head, rows, current, tasks, hint, locked, fewest, swapped, chip: metrics(), box: inside(box()), fits: fits(), open: menu().open, violations: window.e2eViolations || null}; -})()""" -CLOSE = """(async () => {@HELPERS@@READ@ - const was = menu().open; + const kept = {window: windowText(), metrics: (await stored()).metrics.length, unit: all('#rates .rates-units button[aria-pressed="true"]').map(text)}; + await opened(); document.body.dispatchEvent(new KeyboardEvent("keydown", {key: "Escape", bubbles: true})); const escaped = Boolean(await until(() => !menu().open, 3000)); chip().click(); const reopened = Boolean(await until(() => menu().open, 3000)); - chip().click(); - const clicked = Boolean(await until(() => !menu().open, 3000)); - chip().click(); - await until(() => menu().open, 3000); document.getElementById("main").click(); const outside = Boolean(await until(() => !menu().open, 3000)); - return {was, escaped, reopened, clicked, outside, fits: fits(), violations: window.e2eViolations || null}; + return {kept, escaped, reopened, outside, fits: fits(), violations: window.e2eViolations || null}; })()""" -def probe(template: str, width: int) -> str: - names = {"@HELPERS@": base.HELPERS, "@READ@": READ, "@PERIOD@": PERIODS[width]} +def probe(template: str) -> str: + names = {"@HELPERS@": base.HELPERS, "@READ@": READ, "@METRICS@": json.dumps(METRICS)} for key, value in names.items(): template = template.replace(key, value) return template @@ -117,6 +177,10 @@ def sample(t: int) -> dict: return {"t": t, "disks": [{"mount": "/", "used": 400 << 30, "total": 1000 << 30}], "cpu": 25.0, "ram": 40.0, "swap": 5.0, "load": 1.0, "gpus": gpus, "queue": {"waiting": 0, "active": 0}} +def token(t: int, amount: int) -> dict: + return {"t": t, "agent": "Skills", "model": "claude-opus-5-5", "input": amount - 400_000, "output": 0, "cache_read": 400_000, "cache_write": 0} + + @unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium") class TestRatesChip(HubCase): drive = base.OrchestratorE2ECase.drive @@ -129,13 +193,15 @@ class TestRatesChip(HubCase): folder = self.kept / "resources" folder.mkdir() (folder / "samples.jsonl").write_text(self.jsonl([sample(now - 2 * HOUR + step * 60) for step in range(140)]), encoding="utf-8") - tokens = [{"t": t, "agent": "Skills", "model": "claude-opus-5-5", "input": 4000, "output": 1000, "cache_read": 20000, "cache_write": 500} for t in (hour - HOUR, hour)] + tokens = [token(hour - 9 * DAY, 500_000), *(token(hour - day * DAY, 1_000_000) for day in range(7))] (folder / "tokens.jsonl").write_text(self.jsonl(tokens), encoding="utf-8") - self.write_council({"rasci.json": { - "work/first": {"title": "First", "status": "done", "worker": "Skills", "start": iso(now - 5 * HOUR), "end": iso(now - 3 * HOUR), "roles": {"Skills": "RA"}}, - "work/second": {"title": "Second", "status": "done", "worker": "Skills", "start": iso(now - 2 * HOUR), "end": iso(now - 1200), "roles": {"Skills": "RA"}, "key_results": [{"text": "shipped", "met": True, "met_at": iso(now - 1300)}]}, - "work/third": {"title": "Third", "status": "running", "worker": "Stage", "start": iso(now - HOUR), "roles": {"Stage": "RA"}}, - }}) + self.write_council({ + "rasci.json": { + "work/first": {"title": "First", "status": "done", "worker": "Skills", "start": iso(now - 5 * HOUR), "end": iso(now - 3 * HOUR), "roles": {"Skills": "RA"}}, + "work/second": {"title": "Second", "status": "done", "worker": "Skills", "start": iso(now - 2 * HOUR), "end": iso(now - 1200), "roles": {"Skills": "RA"}, "key_results": [{"text": "shipped", "met": True, "met_at": iso(now - 1300)}]}, + }, + "news.jsonl": self.jsonl([{"ts": now - 10 * DAY, "from": "Skills", "to": [], "text": "the oldest record", "class": "post", "v": 2}]), + }) (self.council / "scores.jsonl").write_text(json.dumps({"time": now - 2 * HOUR, "remote": "example.org/skills", "path": "/repo", "branch": "main", "sha": "d" * 40, "values": {"score": 90}, "digest": "0" * 64}) + "\n", encoding="utf-8") self.base = f"http://{self.host}/" @@ -144,50 +210,65 @@ class TestRatesChip(HubCase): for width, height in base.WIDTHS: shot = OUT / f"{browser}-{width}" steps += [ - {"width": width, "height": height, "url": f"{self.base}?{width}#home", "wait": 1200, "probe": probe(CHOOSE, width), "shot": f"{shot}-chip.png"}, - {"width": width, "height": height, "url": f"{self.base}?{width}-reloaded#home", "wait": 1200, "probe": probe(OPEN, width), "shot": f"{shot}-popover.png"}, - {"width": width, "height": height, "url": None, "wait": 0, "probe": probe(CLOSE, width), "shot": None}, + {"width": width, "height": height, "url": f"{self.base}?{width}#home", "wait": 1200, "probe": probe(PANEL), "shot": f"{shot}-panel.png"}, + {"width": width, "height": height, "url": None, "wait": 0, "keys": ["ArrowRight"], "probe": probe(STEPPED), "shot": None}, + {"width": width, "height": height, "url": None, "wait": 0, "keys": ["ArrowRight"], "probe": probe(BLOCKED), "shot": f"{shot}-past.png"}, + {"width": width, "height": height, "url": None, "wait": 0, "probe": probe(REPLAY), "shot": None}, + {"width": width, "height": height, "url": None, "wait": 0, "probe": probe(NINE), "shot": f"{shot}-nine.png"}, + {"width": width, "height": height, "url": f"{self.base}?{width}-reloaded#home", "wait": 1200, "probe": probe(KEPT), "shot": None}, ] return steps def check(self, data: dict, browser: str) -> None: results = iter(data["results"]) - fitting = {"wide": False, "bar": False, "chip": True, "period": True} - previous = ["tasks", "tokens", "cpu"] + fitting = {"wide": False, "bar": False, "chip": True, "spill": False} for width, _ in base.WIDTHS: - chosen, opened, closed = next(results), next(results), next(results) - chip = {"day": "2/d", "week": "2/wk", "minute": "β‰ˆ 0.02/min"}[PERIODS[width]] + panel, stepped, blocked, replay, nine, kept = (next(results) for _ in range(6)) with self.subTest(browser=browser, width=width): - self.assertNotIn("error", chosen, chosen) - self.assertEqual(chosen["before"], {"period": BEFORE[width], "metrics": previous}) - self.assertEqual(chosen["saved"], {"period": PERIODS[width], "metrics": previous}) - self.assertEqual((chosen["after"]["period"], chosen["after"]["metrics"], chosen["after"]["values"]["tasks"]), (PERIODS[width], previous, chip)) - self.assertTrue(chosen["after"]["label"].startswith("Rates per "), chosen["after"]) - self.assertEqual((chosen["fits"], chosen["open"]), (fitting, False)) - self.assertEqual(w4.quiet(chosen["violations"]), []) - self.assertNotIn("error", opened, opened) - self.assertEqual((opened["kept"]["period"], opened["kept"]["metrics"], opened["kept"]["values"]["tasks"]), (PERIODS[width], previous, chip)) - self.assertTrue(opened["opened"], opened) - self.assertEqual((opened["head"], opened["rows"], opened["current"]), (HEAD, [[metric, 7] for metric in METRICS], [PERIODS[width]] * len(METRICS))) - self.assertEqual({period: tuple(cell) for period, cell in opened["tasks"].items()}, TASKS) - self.assertIn("scaled from the last hour", opened["hint"]) - self.assertEqual((opened["locked"], opened["fewest"]), (True, [True, True])) - self.assertEqual((opened["swapped"], opened["chip"]), ({"period": PERIODS[width], "metrics": CHOSEN[width]}, CHOSEN[width])) - self.assertEqual((opened["box"], opened["fits"], opened["open"]), (True, fitting, True)) - self.assertEqual(w4.quiet(opened["violations"]), []) - self.assertEqual({key: closed[key] for key in ("was", "escaped", "reopened", "clicked", "outside")}, dict.fromkeys(("was", "escaped", "reopened", "clicked", "outside"), True)) - self.assertEqual((closed["fits"], w4.quiet(closed["violations"])), (fitting, [])) - previous = CHOSEN[width] - self.assertEqual(self.httpd.hub.settings.get()["rates"], {"period": PERIODS[390], "metrics": CHOSEN[390]}) + self.assertNotIn("error", panel, panel) + self.assertEqual(panel["header"]["time"], False) + self.assertEqual(panel["header"]["select"], 0) + self.assertTrue(panel["open"], panel) + self.assertEqual(panel["parts"], PARTS) + self.assertEqual(panel["saved"]["period"], "day", panel) + self.assertTrue(panel["week"], panel) + self.assertEqual(panel["tokens"], {"chip": "1.0M/d", "cell": "1.0M/d", "current": ["day"] * len(METRICS)}, panel) + self.assertLess(abs(panel["rates"]["from"] - (panel["now"] - 7 * DAY)), 120, panel["rates"]) + self.assertEqual((panel["focused"], panel["fits"], w4.quiet(panel["violations"])), (True, fitting, [])) + self.assertEqual(stepped["stepped"], {"from": panel["from"] + 1, "to": 1000}, stepped) + self.assertEqual((stepped["near"], stepped["focused"]), ({"from": 999, "to": 1000}, True), stepped) + self.assertEqual(blocked["blocked"], {"from": 999, "to": 1000}, blocked) + self.assertTrue(blocked["past"], blocked) + self.assertIn(" – ", blocked["label"]) + self.assertFalse(blocked["label"].endswith("Β· live"), blocked) + self.assertEqual(panel["from"], 300, panel) + for asked in (blocked["rates"], blocked["state"]): + self.assertLess(abs(asked["from"] - (blocked["now"] - 9 * DAY)), 0.01 * 10 * DAY, asked) + self.assertLess(abs(asked["to"] - (blocked["now"] - 2 * DAY)), 0.01 * 10 * DAY, asked) + self.assertEqual((blocked["fits"], w4.quiet(blocked["violations"])), (fitting, [])) + self.assertEqual({key: replay[key] for key in ("paused", "held", "ended", "playing")}, {"paused": True, "held": True, "ended": True, "playing": "Replay"}, replay) + self.assertEqual(w4.quiet(replay["violations"]), []) + self.assertEqual(nine["stored"], 9) + if width == 1920: + self.assertEqual((nine["shown"], nine["more"]), (9, None), nine) + if width == 390: + self.assertLess(nine["shown"], 9, nine) + self.assertEqual(nine["more"], f"+{9 - nine['shown']}", nine) + self.assertEqual((nine["fits"], w4.quiet(nine["violations"])), (fitting, [])) + self.assertNotIn("error", kept, kept) + self.assertEqual(kept["kept"], {"window": "24 h Β· /d", "metrics": 9, "unit": ["d"]}) + self.assertEqual({key: kept[key] for key in ("escaped", "reopened", "outside")}, dict.fromkeys(("escaped", "reopened", "outside"), True)) + self.assertEqual((kept["fits"], w4.quiet(kept["violations"])), (fitting, [])) + self.assertEqual(self.httpd.hub.settings.get()["rates"], {"period": "day", "metrics": ["tasks", "tokens", "cpu", "commits", "krs", "ram", "vram", "swap", "disk"]}) - def test_chromium_shows_the_rates_chip_keeps_its_period_over_a_reload_and_opens_and_closes_the_table_at_three_widths(self): + def test_chromium_moves_the_time_range_and_the_rate_unit_into_the_rates_panel_at_three_widths(self): data = self.drive(self.steps("chromium"), None, init=w4.GUARD) (OUT / "chromium-rates.json").write_text(json.dumps(data, indent=1), encoding="utf-8") self.assertEqual(data["errors"], []) self.check(data, "chromium") @unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox") - def test_firefox_shows_the_rates_chip_keeps_its_period_over_a_reload_and_opens_and_closes_the_table_at_three_widths(self): + def test_firefox_moves_the_time_range_and_the_rate_unit_into_the_rates_panel_at_three_widths(self): data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), init=w4.GUARD) (OUT / "firefox-rates.json").write_text(json.dumps(data, indent=1), encoding="utf-8") self.assertEqual([error for error in data["errors"] if "/favicon.ico" not in error], []) diff --git a/tests/test_hub_rates.py b/tests/test_hub_rates.py index f9434ba..fe2d6c6 100644 --- a/tests/test_hub_rates.py +++ b/tests/test_hub_rates.py @@ -18,7 +18,8 @@ HOUR = 3600 DAY = 86400 GIB = 1 << 30 NOW = 1_800_000_000 + 1800 -EXACT_ZERO = {"value": 0.0, "approx": False, "source": None} +LAST_HOUR = NOW - NOW % HOUR +NOTHING = {"value": None, "approx": False, "covered": None} def token(t: int, given: int, cached: int) -> dict: @@ -31,6 +32,10 @@ def sample(t: float, cpu: float, span: int | None = None, vram: tuple[int, int] return row if span is None else {**row, "span": span} +def per_unit(amount: float, covered: float, approx: bool) -> dict[str, dict]: + return {name: {"value": rates.precise(amount if seconds is None else amount * seconds / covered), "approx": approx and seconds is not None, "covered": covered} for name, seconds in rates.PERIODS} + + class TestRates(unittest.TestCase): def setUp(self): tmp = tempfile.TemporaryDirectory() @@ -46,86 +51,88 @@ class TestRates(unittest.TestCase): def lines(self, path: Path, rows: list[dict]) -> None: path.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8") - def rated(self) -> dict: - return rates.rated(self.council, self.folder.parent, NOW) + def rated(self, begin: float, end: float) -> dict: + return rates.rated(self.council, self.folder.parent, NOW, (begin, end)) - def column(self, metric: str) -> dict: - found = self.rated() + def column(self, metric: str, begin: float, end: float) -> dict: + found = self.rated(begin, end) return {period: found["rates"][period][metric] for period in rates.PERIOD_NAMES} - def test_done_tasks_count_in_every_window_their_end_lies_in_and_total_counts_each_done_task(self): - ends = [NOW - 30, NOW - 1800, NOW - 2 * DAY, NOW - 20 * DAY, NOW - 200 * DAY, NOW - 800 * DAY] + def test_a_week_of_seven_million_tokens_gives_a_million_a_day_seven_a_week_and_seven_in_all(self): + self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - 10 * DAY, 5, 0), token(LAST_HOUR - 2 * DAY, 6_000_000, 1_000_000)]) + tokens = self.column("tokens", NOW - 7 * DAY, NOW) + self.assertEqual(tokens, per_unit(7_000_000, 7 * DAY, False)) + self.assertEqual((tokens["day"]["value"], tokens["week"]["value"], tokens["total"]["value"], tokens["month"]["value"]), (1_000_000.0, 7_000_000.0, 7_000_000.0, 30_000_000.0)) + + def test_done_tasks_key_results_and_commits_count_inside_the_window_and_scale_per_unit(self): + ends = [NOW - 30, NOW - 1800, NOW - 2 * DAY, NOW - 20 * DAY] tasks = {f"work/t{index}": {"status": "done", "end": iso(end)} for index, end in enumerate(ends)} others = {"status": "done", "end": iso(NOW - 10)} - self.register({**tasks, "work/legacy": {"status": "done"}, "work/open": {**others, "status": "running"}, "work/halted": {**others, "status": "stopped"}, "operator/run": others}) - counts = dict(zip(rates.PERIOD_NAMES, (1.0, 2.0, 2.0, 3.0, 4.0, 5.0, 7.0), strict=True)) - self.assertEqual(self.column("tasks"), {period: {"value": value, "approx": False, "source": None} for period, value in counts.items()}) - - def test_an_empty_window_takes_the_shortest_longer_window_with_events_scaled_down_and_marked_approx(self): - results = [{"text": "met", "met": True, "met_at": iso(NOW - 1800)}, {"text": "open", "met": False}] - self.register({"work/a": {"status": "running", "key_results": results}}) + results = [{"text": "met", "met": True, "met_at": iso(NOW - 600)}, {"text": "old", "met": True}, {"text": "open", "met": False}] + self.register({**tasks, "work/legacy": {"status": "done"}, "work/open": {**others, "status": "running", "key_results": results}, "work/halted": {**others, "status": "stopped"}, "operator/run": others}) commit = {"time": NOW - 5 * HOUR, "remote": "example.org/repo", "sha": "a" * 40, "values": {}} - self.lines(self.council / "scores.jsonl", [commit, commit, {**commit, "sha": None, "time": NOW - 60}, {**commit, "sha": "b" * 40, "values": None}]) - krs = self.column("krs") - self.assertEqual(krs["minute"], {"value": 0.01667, "approx": True, "source": "hour"}) - self.assertEqual([krs[period] for period in rates.PERIOD_NAMES[1:]], [{"value": 1.0, "approx": False, "source": None}] * 6) - commits = self.column("commits") - self.assertEqual(commits["minute"], {"value": 0.0006944, "approx": True, "source": "day"}) - self.assertEqual(commits["hour"], {"value": 0.04167, "approx": True, "source": "day"}) - self.assertEqual([commits[period] for period in rates.PERIOD_NAMES[2:]], [{"value": 1.0, "approx": False, "source": None}] * 5) + self.lines(self.council / "scores.jsonl", [commit, commit, {**commit, "sha": None, "time": NOW - 60}, {**commit, "sha": "b" * 40, "time": NOW - 3 * DAY}]) + day = self.rated(NOW - DAY, NOW)["rates"] + self.assertEqual({period: day[period]["tasks"] for period in rates.PERIOD_NAMES}, per_unit(2, DAY, False)) + self.assertEqual({period: day[period]["krs"] for period in rates.PERIOD_NAMES}, per_unit(1, DAY, False)) + self.assertEqual({period: day[period]["commits"] for period in rates.PERIOD_NAMES}, per_unit(1, DAY, False)) + past = self.rated(NOW - 3 * DAY, NOW - DAY)["rates"] + self.assertEqual((past["total"]["tasks"]["value"], past["total"]["commits"]["value"], past["day"]["tasks"]["value"]), (1.0, 1.0, 0.5)) - def test_key_results_met_before_met_at_existed_count_only_in_total_and_scale_from_there(self): - self.register({"work/a": {"status": "running", "key_results": [{"text": "a", "met": True}]}}) - self.lines(self.folder / "samples.jsonl", [sample(NOW - 10 * DAY, 5.0)]) - krs = self.column("krs") - self.assertEqual(krs["total"], {"value": 1.0, "approx": False, "source": None}) - self.assertEqual(krs["year"], {"value": 1.0, "approx": True, "source": "total"}) - self.assertEqual(krs["week"], {"value": 0.7, "approx": True, "source": "total"}) - self.assertEqual(krs["minute"], {"value": 6.944e-05, "approx": True, "source": "total"}) + def test_a_window_reaching_before_the_first_token_row_divides_by_the_covered_part_and_marks_the_rates_approx(self): + self.register({"work/old": {"status": "done", "end": iso(NOW - 30 * DAY)}}) + self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - 2 * DAY, 4000, 800)]) + tokens = self.column("tokens", NOW - 7 * DAY, NOW) + covered = NOW - (LAST_HOUR - 2 * DAY) + self.assertEqual(tokens, per_unit(4800, covered, True)) + self.assertEqual(tokens["total"], {"value": 4800.0, "approx": False, "covered": covered}) + self.assertEqual(self.column("tasks", NOW - 7 * DAY, NOW)["day"], {"value": 0.0, "approx": False, "covered": 7 * DAY}) - def test_tokens_share_their_hour_by_overlap_and_the_minute_always_takes_a_longer_window(self): - hour = NOW - NOW % HOUR - self.lines(self.folder / "tokens.jsonl", [token(hour, 1000, 800), token(hour - HOUR, 3000, 600), token(hour - 20 * DAY, 7, 0)]) - tokens = self.column("tokens") - self.assertEqual(tokens["minute"], {"value": 60.0, "approx": True, "source": "hour"}) - self.assertEqual(tokens["hour"], {"value": 3600.0, "approx": False, "source": None}) - self.assertEqual((tokens["day"]["value"], tokens["month"]["value"], tokens["total"]["value"]), (5400.0, 5407.0, 5407.0)) + def test_a_window_before_every_record_holds_no_value(self): + self.register({"work/a": {"status": "done", "end": iso(NOW - DAY)}}) + self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR - DAY, 100, 0)]) + self.lines(self.folder / "samples.jsonl", [sample(NOW - DAY, 40.0)]) + found = self.rated(NOW - 9 * DAY, NOW - 8 * DAY) + self.assertEqual({found["rates"][period][kind] == NOTHING for period in rates.PERIOD_NAMES for kind in rates.COUNTS}, {True}) + self.assertIsNone(found["rates"]["day"]["cpu"]["value"]) + self.assertEqual((found["from"], found["to"], found["since"]), (NOW - 9 * DAY, NOW - 8 * DAY, LAST_HOUR - DAY)) - def test_an_empty_hour_takes_the_day_for_tokens_and_so_does_the_minute(self): - hour = NOW - NOW % HOUR - self.lines(self.folder / "tokens.jsonl", [token(hour - 5 * HOUR, 8000, 640)]) - tokens = self.column("tokens") - self.assertEqual(tokens["minute"], {"value": 6.0, "approx": True, "source": "day"}) - self.assertEqual(tokens["hour"], {"value": 360.0, "approx": True, "source": "day"}) - self.assertEqual(tokens["day"], {"value": 8640.0, "approx": False, "source": None}) + def test_a_window_shorter_than_an_hour_shares_the_token_hour_and_marks_every_token_rate_approx(self): + self.lines(self.folder / "tokens.jsonl", [token(LAST_HOUR, 1000, 800)]) + tokens = self.column("tokens", NOW - 600, NOW) + self.assertEqual(tokens["minute"], {"value": 60.0, "approx": True, "covered": 600}) + self.assertEqual(tokens["total"], {"value": 600.0, "approx": True, "covered": 600}) - def test_gauges_average_each_window_weighting_raw_rows_fifteen_minute_means_and_daily_means_by_their_span(self): + def test_gauges_average_the_window_weighting_each_row_by_its_sampled_seconds_inside_on_both_ends(self): + start = NOW - 10 * DAY - (NOW - 10 * DAY) % DAY self.lines(self.folder / "samples.jsonl", [ - sample(NOW - 500 * DAY, 0.0, span=DAY), - sample(NOW - 200 * DAY, 90.0, span=DAY), - sample(NOW - 10 * DAY, 50.0, span=900), - sample(NOW - 90, 30.0, vram=(4, 8), boot=70), - sample(NOW - 30, 10.0, vram=(2, 8), boot=90), + {**sample(start, 40.0), "span": 3600, "width": DAY}, + {**sample(NOW - 2 * DAY - 300, 70.0, boot=80), "span": 600, "width": 900}, + sample(NOW - 30, 10.0, boot=20), ]) - found = self.rated()["rates"] - self.assertEqual([found[period]["cpu"]["value"] for period in rates.PERIOD_NAMES], [10.0, 20.0, 20.0, 20.0, 46.5, 89.5, 45.0]) - self.assertEqual([found[period]["ram"]["value"] for period in ("minute", "hour")], [11.0, 21.0]) - self.assertEqual(found["minute"]["vram"], {"value": 25.0, "used": 2 * GIB, "approx": False, "source": None}) - self.assertEqual((found["hour"]["vram"]["value"], found["hour"]["vram"]["used"], found["month"]["vram"]["value"]), (37.5, 3 * GIB, 37.5)) - self.assertEqual(found["minute"]["disk"], {"value": 90.0, "mount": "/boot", "used": 90, "total": 100, "approx": False, "source": None}) - self.assertEqual((found["hour"]["disk"]["value"], found["month"]["disk"]["value"], found["month"]["disk"]["used"]), (80.0, 53.5, 54)) - self.assertEqual(self.rated()["since"], NOW - 500 * DAY) + found = self.rated(start + DAY / 2, NOW - 2 * DAY)["rates"] + self.assertEqual({found[period]["cpu"]["value"] for period in rates.PERIOD_NAMES}, {round((1800 * 40 + 200 * 70) / 2000, 1)}) + self.assertEqual(found["hour"]["disk"], {"value": round((1800 * 50 + 200 * 80) / 2000, 1), "mount": "/boot", "used": 53, "total": 100, "approx": False}) + self.assertEqual(found["week"]["vram"], {"value": None, "used": None, "approx": False}) - def test_a_window_without_a_sample_shows_no_gauge_and_kinds_without_any_event_count_an_exact_zero(self): + def test_gauges_of_the_last_minutes_read_vram_and_the_fullest_disk(self): + self.lines(self.folder / "samples.jsonl", [sample(NOW - 90, 30.0, vram=(4, 8), boot=70), sample(NOW - 30, 10.0, vram=(2, 8), boot=90)]) + last = self.rated(NOW - 60, NOW)["rates"]["minute"] + self.assertEqual((last["cpu"]["value"], last["ram"]["value"]), (10.0, 11.0)) + self.assertEqual(last["vram"], {"value": 25.0, "used": 2 * GIB, "approx": False}) + self.assertEqual(last["disk"], {"value": 90.0, "mount": "/boot", "used": 90, "total": 100, "approx": False}) + both = self.rated(NOW - 120, NOW)["rates"]["hour"] + self.assertEqual((both["cpu"]["value"], both["vram"]["value"], both["vram"]["used"], both["disk"]["value"]), (20.0, 37.5, 3 * GIB, 80.0)) + + def test_a_window_without_a_sample_shows_no_gauge_and_kinds_with_records_but_none_inside_count_an_exact_zero(self): self.lines(self.folder / "samples.jsonl", [sample(NOW - 2 * HOUR, 40.0)]) - found = self.rated() - self.assertEqual([found["rates"][period]["cpu"]["value"] for period in rates.PERIOD_NAMES], [None, None, 40.0, 40.0, 40.0, 40.0, 40.0]) - self.assertEqual(found["rates"]["hour"]["vram"], {"value": None, "used": None, "approx": False, "source": None}) - self.assertEqual(found["rates"]["minute"]["disk"], {"value": None, "mount": None, "used": None, "total": None, "approx": False, "source": None}) - self.assertEqual({found["rates"][period][kind] == EXACT_ZERO for period in rates.PERIOD_NAMES for kind in rates.COUNTS}, {True}) - self.assertEqual((found["now"], found["since"], [entry["name"] for entry in found["periods"]]), (NOW, NOW - 2 * HOUR, list(rates.PERIOD_NAMES))) + found = self.rated(NOW - HOUR, NOW)["rates"] + self.assertIsNone(found["day"]["cpu"]["value"]) + self.assertEqual(found["minute"]["disk"], {"value": None, "mount": None, "used": None, "total": None, "approx": False}) + self.assertEqual({found[period][kind]["value"] for period in rates.PERIOD_NAMES for kind in ("tasks", "commits", "krs")}, {0.0}) + self.assertEqual(found["day"]["tokens"], NOTHING) - def test_folded_sampler_rows_feed_the_windows_with_the_seconds_they_sampled(self): + def test_folded_sampler_rows_feed_the_window_with_the_seconds_they_sampled(self): old = NOW - NOW % DAY - 100 * DAY raw = [sample(old + 3600 + index * 60, 20.0) for index in range(30)] + [sample(NOW - 9 * DAY + index * 60, 60.0) for index in range(30)] + [sample(NOW - 59, 10.0)] kept = sampler.retain(sorted(raw, key=lambda row: row["t"]), NOW) @@ -134,10 +141,10 @@ class TestRates(unittest.TestCase): self.assertEqual({row["width"] for row in kept[1:-1]}, {900}) self.assertNotIn("span", kept[-1]) self.lines(self.folder / "samples.jsonl", kept) - found = self.rated()["rates"] month = round((10 * 60 + 60 * 1800) / (60 + 1800), 1) year = round((10 * 60 + 60 * 1800 + 20 * 1800) / (60 + 1800 * 2), 1) - self.assertEqual([found[period]["cpu"]["value"] for period in ("minute", "week", "month", "year")], [10.0, 10.0, month, year]) + cpu = [self.rated(NOW - seconds, NOW)["rates"]["day"]["cpu"]["value"] for seconds in (60, 7 * DAY, 30 * DAY, 365 * DAY)] + self.assertEqual(cpu, [10.0, 10.0, month, year]) def test_a_lone_fifteen_minute_bucket_weighs_its_sampled_seconds_wherever_it_lies_in_its_day(self): day = NOW - NOW % DAY - 200 * DAY @@ -156,22 +163,7 @@ class TestRates(unittest.TestCase): old, recent = NOW - NOW % DAY - 100 * DAY, NOW - NOW % DAY - 8 * DAY raw = [sample(old + 60 * index, 90.0) for index in range(60)] + [sample(recent + 60 * index, 10.0) for index in range(60)] self.lines(self.folder / "samples.jsonl", sampler.retain(raw, NOW)) - self.assertEqual(self.rated()["rates"]["year"]["cpu"]["value"], 50.0) - - def test_a_folded_row_straddling_a_window_start_counts_by_its_share_inside(self): - week, year = NOW - 7 * DAY, NOW - 365 * DAY - self.lines(self.folder / "samples.jsonl", [ - {**sample(year - year % DAY, 40.0), "span": 3600, "width": DAY}, - {**sample(week - 300, 70.0, boot=80), "span": 600, "width": 900}, - sample(NOW - 30, 10.0, boot=20), - ]) - found = self.rated()["rates"] - inside = (year - year % DAY + DAY - year) / DAY * 3600 - self.assertEqual(found["week"]["cpu"]["value"], round((400 * 70 + 60 * 10) / 460, 1)) - self.assertEqual(found["month"]["cpu"]["value"], round((600 * 70 + 60 * 10) / 660, 1)) - self.assertEqual(found["year"]["cpu"]["value"], round((inside * 40 + 600 * 70 + 60 * 10) / (inside + 660), 1)) - self.assertEqual(found["total"]["cpu"]["value"], round((3600 * 40 + 600 * 70 + 60 * 10) / 4260, 1)) - self.assertEqual(found["week"]["disk"]["value"], round((400 * 80 + 60 * 20) / 460, 1)) + self.assertEqual(self.rated(NOW - 365 * DAY, NOW)["rates"]["year"]["cpu"]["value"], 50.0) def test_token_rows_older_than_ninety_days_fold_into_one_row_per_day_agent_and_model_kept_forever(self): day, hour = NOW - NOW % DAY - 100 * DAY, NOW - NOW % HOUR @@ -181,25 +173,11 @@ class TestRates(unittest.TestCase): self.assertEqual(kept, [*daily, token(hour - HOUR, 7, 0)]) self.assertEqual(sampler.compact(kept, NOW + 400 * DAY)[:2], daily) - def test_a_daily_token_row_counts_by_the_share_of_its_day_inside_a_window(self): + def test_a_daily_token_row_counts_by_the_share_of_its_day_inside_the_window(self): year = NOW - 365 * DAY self.lines(self.folder / "tokens.jsonl", [{**token(year - year % DAY, 8640, 0), "width": DAY}]) - tokens = self.column("tokens") - self.assertEqual(tokens["year"], {"value": rates.precise((year - year % DAY + DAY - year) / DAY * 8640), "approx": False, "source": None}) - self.assertEqual(tokens["total"], {"value": 8640.0, "approx": False, "source": None}) - - def test_token_windows_reaching_before_the_first_token_row_are_scaled_estimates_from_the_rows_there_are(self): - hour = NOW - NOW % HOUR - begins = hour - 10 * DAY - self.register({"work/old": {"status": "done", "end": iso(NOW - 400 * DAY)}}) - self.lines(self.folder / "tokens.jsonl", [token(begins, 1000, 0), token(hour - HOUR, 500, 0)]) - tokens = self.column("tokens") - covered = NOW - begins - self.assertEqual(tokens["minute"], {"value": rates.precise(250 / 60), "approx": True, "source": "hour"}) - self.assertEqual([tokens[period] for period in ("hour", "day", "week")], [{"value": value, "approx": False, "source": None} for value in (250.0, 500.0, 500.0)]) - for period, seconds in (("month", 30 * DAY), ("year", 365 * DAY), ("total", 400 * DAY)): - with self.subTest(period=period): - self.assertEqual(tokens[period], {"value": rates.precise(1500 * seconds / covered), "approx": True, "source": "total"}) + total = self.column("tokens", year, NOW)["total"] + self.assertEqual(total, {"value": rates.precise((year - year % DAY + DAY - year) / DAY * 8640), "approx": False, "covered": NOW - year}) def test_counts_shorten_to_thousands_millions_billions_and_trillions(self): probe = "const R = require(process.argv[1]); console.log(JSON.stringify(JSON.parse(process.argv[2]).map(R.compact)));" @@ -209,16 +187,19 @@ class TestRates(unittest.TestCase): class TestHubRates(HubCase): - def test_the_hub_serves_the_rates_of_the_register_the_journal_and_the_sampler(self): - self.write_council({"rasci.json": {"work/a": {"status": "done", "end": iso(1_700_000_000), "key_results": [{"text": "a", "met": True, "met_at": iso(1_700_000_000)}]}}}) - (self.council / "scores.jsonl").write_text(json.dumps({"time": 1_700_000_000, "remote": "example.org/repo", "sha": "c" * 40, "values": {}}) + "\n", encoding="utf-8") - status, headers, body = self.get("/api/rates") + def test_the_hub_serves_the_rates_of_the_window_from_the_register_the_journal_and_the_sampler(self): + done = 1_700_000_000 + self.write_council({"rasci.json": {"work/a": {"status": "done", "end": iso(done), "key_results": [{"text": "a", "met": True, "met_at": iso(done)}]}}}) + (self.council / "scores.jsonl").write_text(json.dumps({"time": done, "remote": "example.org/repo", "sha": "c" * 40, "values": {}}) + "\n", encoding="utf-8") + status, headers, body = self.get(f"/api/rates?from={done - DAY}&to={done + DAY}") self.assertEqual((status, headers["content-type"]), (200, "application/json"), body) found = json.loads(body) self.assertEqual([entry["name"] for entry in found["periods"]], list(rates.PERIOD_NAMES)) - self.assertEqual({kind: found["rates"]["total"][kind]["value"] for kind in rates.COUNTS}, {"tasks": 1.0, "commits": 1.0, "krs": 1.0, "tokens": 0.0}) + self.assertEqual({kind: found["rates"]["total"][kind]["value"] for kind in rates.COUNTS}, {"tasks": 1.0, "commits": 1.0, "krs": 1.0, "tokens": None}) + self.assertEqual({kind: found["rates"]["day"][kind]["approx"] for kind in ("tasks", "commits", "krs")}, {"tasks": True, "commits": True, "krs": True}) self.assertEqual(set(found["rates"]["hour"]), set(rates.METRICS)) - self.assertEqual(found["since"], 1_700_000_000) + self.assertEqual((found["since"], found["from"], found["to"]), (done, done - DAY, done + DAY)) + self.assertEqual(self.get(f"/api/rates?from={done}&to={done - 1}")[0], 400) if __name__ == "__main__": diff --git a/tests/test_hub_settings.py b/tests/test_hub_settings.py index 77428fa..112afbd 100644 --- a/tests/test_hub_settings.py +++ b/tests/test_hub_settings.py @@ -5,7 +5,7 @@ import unittest from hub_case import HubCase from hub_support import STREAMS, Key, key -from kvb_orchestrator import settings +from kvb_orchestrator import rates, settings class TestHubSettings(HubCase): @@ -199,13 +199,13 @@ class TestHubSettings(HubCase): self.assertEqual((settings.SETTINGS["rates"], self.snapshot()["settings"]["rates"]), (default, default)) good = self.guard(self.host) wrongs = [{"period": period, "metrics": ["tasks", "cpu"]} for period in ("second", "Hour", "", None, 1)] - wrongs += [{"period": "day", "metrics": metrics} for metrics in (["tasks"], [], ["tasks", "cpu", "ram", "swap"], ["tasks", "tasks"], ["tasks", "gpu"], [1, 2], "tasks,cpu", None)] + wrongs += [{"period": "day", "metrics": metrics} for metrics in (["tasks"], [], [*rates.METRICS, "tasks"], ["tasks", "tasks"], ["tasks", "gpu"], [1, 2], "tasks,cpu", None)] wrongs += [{"period": "day"}, {"metrics": ["tasks", "cpu"]}, {**default, "extra": 1}, "day", ["day"]] for wrong in wrongs: with self.subTest(wrong=wrong): self.assertEqual(self.post_json("/api/settings", {**settings.SETTINGS, "rates": wrong}, good)[0], 400) self.assertEqual(self.snapshot()["settings"]["rates"], default) - for chosen in ({"period": "minute", "metrics": ["commits", "krs"]}, {"period": "total", "metrics": ["disk", "vram", "swap"]}, {"period": "week", "metrics": ["ram", "tokens"]}): + for chosen in ({"period": "minute", "metrics": ["commits", "krs"]}, {"period": "total", "metrics": list(reversed(rates.METRICS))}, {"period": "week", "metrics": ["ram", "tokens"]}): with self.subTest(chosen=chosen): self.assertIsNone(self.prepared({**self.snapshot()["settings"], "rates": chosen})["payload"]) status, _, body = self.post_json("/api/settings", {**self.snapshot()["settings"], "rates": chosen, "proof": None}, good)