Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
perf(dashboard): poll once at a time and initialize once (#3470)
trs-803201bab56008
diff --git a/headroom/dashboard/templates/dashboard.html b/headroom/dashboard/templates/dashboard.htmlindex 4dd793a44..a0d0a8c85 100644--- a/headroom/dashboard/templates/dashboard.html+++ b/headroom/dashboard/templates/dashboard.html@@ -113,7 +113,10 @@.hover-bg-surface:hover { background: var(--color-surface); }</style></head>-<body class="text-gray-200 min-h-screen" x-data="dashboard()" x-init="init()">+<!-- No x-init: Alpine already calls the x-data object's own init(). Naming it+ here too ran init() twice, which started two 5s poll timers and registered+ the R shortcut twice, doubling every request the dashboard makes. -->+<body class="text-gray-200 min-h-screen" x-data="dashboard()"><!-- Header --><header class="border-b border-border px-6 py-4 flex flex-col gap-3 md:flex-row md:items-center md:justify-between"><div class="flex items-center gap-4">@@ -2009,6 +2012,7 @@savingsHistory: [],expandedRows: {},pollInterval: null,+ polling_: false,statsPollMs: 5000,lifetimePollMs: 30000,historyPollMs: 30000,@@ -2042,18 +2046,29 @@async pollDashboard(force = false) {if (!force && document.hidden) return;+ // The timer and the R shortcut share this method, and each+ // run fetches at least /stats and /health. If a poll is+ // still outstanding, skip rather than stack a second+ // sequence on top of it; finally, so a rejection releases+ // the guard instead of wedging polling permanently.+ if (this.polling_) return;+ this.polling_ = true;- await this.fetchStats();+ try {+ await this.fetchStats();- const now = Date.now();- if (this.viewMode === 'lifetime' && (force || now - this.lastLifetimeFetchMs >= this.lifetimePollMs)) {- await this.fetchLifetimeStats();- }- if (this.viewMode === 'history' && (force || now - this.lastHistoryFetchMs >= this.historyPollMs)) {- await this.fetchHistoryStats();- }- if (this.feedOpen && (force || now - this.lastFeedFetchMs >= this.feedPollMs)) {- await this.fetchTransformations();+ const now = Date.now();+ if (this.viewMode === 'lifetime' && (force || now - this.lastLifetimeFetchMs >= this.lifetimePollMs)) {+ await this.fetchLifetimeStats();+ }+ if (this.viewMode === 'history' && (force || now - this.lastHistoryFetchMs >= this.historyPollMs)) {+ await this.fetchHistoryStats();+ }+ if (this.feedOpen && (force || now - this.lastFeedFetchMs >= this.feedPollMs)) {+ await this.fetchTransformations();+ }+ } finally {+ this.polling_ = false;}},diff --git a/headroom/dashboard/templates/settings.html b/headroom/dashboard/templates/settings.htmlindex b326c6e8b..37728d44a 100644--- a/headroom/dashboard/templates/settings.html+++ b/headroom/dashboard/templates/settings.html@@ -32,7 +32,9 @@@media (prefers-reduced-motion: reduce) { * { transition: none !important; animation: none !important; } }</style></head>-<body class="text-gray-800 dark:text-gray-100 min-h-screen" x-data="settingsPage()" x-init="init()">+<!-- No x-init: Alpine already calls the x-data object's own init(). Naming it+ here too fetched /settings/schema twice on every load. -->+<body class="text-gray-800 dark:text-gray-100 min-h-screen" x-data="settingsPage()"><div class="max-w-3xl mx-auto px-4 py-8"><div class="flex items-center justify-between mb-6"><div>diff --git a/tests/test_dashboard_poll_guard_playwright.py b/tests/test_dashboard_poll_guard_playwright.pynew file mode 100644index 000000000..1e99dbfb1--- /dev/null+++ b/tests/test_dashboard_poll_guard_playwright.py@@ -0,0 +1,186 @@+"""One dashboard poll runs at a time.++A five-second ``setInterval`` and the ``R`` shortcut both call+``pollDashboard()``, which never waited for a previous invocation to finish.+Each invocation fetches ``/stats`` and ``/health``, so a slow endpoint or a+repeated manual refresh put two full sequences in flight at once.++These tests drive the real Alpine component in a browser. They gate+``window.fetch`` on a promise the test resolves, which is what makes "while the+first request is still pending" a deterministic state rather than a race.+"""++from __future__ import annotations++from collections.abc import Iterator++import pytest++from headroom.dashboard import get_dashboard_html, get_settings_html+from tests.test_dashboard_cache_net_playwright import _open_dashboard+from tests.test_dashboard_cache_ttl_playwright import _sample_stats++playwright = pytest.importorskip("playwright.sync_api")+Page = playwright.Page+sync_playwright = playwright.sync_playwright++# Replaces fetch with a call recorder that hangs until the test releases it,+# and stops the interval so the test drives pollDashboard() itself.+_GATE_FETCH = """+() => {+ const component = Alpine.$data(document.body);+ clearInterval(component.pollInterval);+ window.__urls = [];+ const gate = new Promise((resolve) => { window.__release = resolve; });+ window.fetch = (url) => {+ window.__urls.push(String(url));+ return gate.then(() => new Response('{}', {+ status: 200,+ headers: { 'content-type': 'application/json' },+ }));+ };+}+"""++# One poll fetches /stats and /health together.+FETCHES_PER_POLL = 2+++def page() -> Iterator[Page]: # type: ignore[valid-type]+ with sync_playwright() as p:+ browser = p.chromium.launch()+ page = browser.new_page()+ _open_dashboard(page, _sample_stats())+ page.evaluate(_GATE_FETCH)+ yield page+ browser.close()+++ "html",+ [get_dashboard_html(), get_settings_html()],+ ids=["dashboard", "settings"],+)+def test_no_template_asks_alpine_to_run_init_again(html: str) -> None:+ """Both templates had it; the settings page fetched its schema twice."""+ assert 'x-init="init()"' not in html+++def test_the_component_initializes_once() -> None:+ """Alpine calls the x-data object's ``init()`` itself.++ Naming it in ``x-init`` as well ran it twice: two 5s poll timers, two R+ shortcut listeners and two opening fetch sequences, for the lifetime of the+ page. Counting the opening sequence is enough to pin it — the duplicate+ timer and listener can only exist if ``init()`` ran more than once.+ """+ with sync_playwright() as p:+ browser = p.chromium.launch()+ page = browser.new_page()+ polled: list[str] = []+ page.on(+ "request",+ lambda request: (+ polled.append(request.url)+ if "/stats" in request.url or "/health" in request.url+ else None+ ),+ )++ _open_dashboard(page, _sample_stats())++ assert len(polled) == FETCHES_PER_POLL, polled+ browser.close()+++def _url_count(page: Page) -> int: # type: ignore[valid-type]+ return int(page.evaluate("() => window.__urls.length"))+++def test_a_second_poll_during_the_first_issues_no_further_requests(page: Page) -> None: # type: ignore[valid-type]+ """The timer's entry point: two unforced polls, one fetch sequence."""+ counts = page.evaluate(+ """async () => {+ const component = Alpine.$data(document.body);+ const first = component.pollDashboard();+ const second = component.pollDashboard();+ const inFlight = window.__urls.length;+ window.__release();+ await Promise.all([first, second]);+ return { inFlight, settled: window.__urls.length };+ }"""+ )++ assert counts == {"inFlight": FETCHES_PER_POLL, "settled": FETCHES_PER_POLL}+++def test_a_poll_after_the_first_completes_still_runs(page: Page) -> None: # type: ignore[valid-type]+ """The guard suppresses overlap, not the next scheduled refresh."""+ page.evaluate(+ """async () => {+ const component = Alpine.$data(document.body);+ const first = component.pollDashboard();+ window.__release();+ await first;+ await component.pollDashboard();+ }"""+ )++ assert _url_count(page) == 2 * FETCHES_PER_POLL+++def test_manual_refresh_during_a_poll_does_not_duplicate_it(page: Page) -> None: # type: ignore[valid-type]+ """The R shortcut shares the guard, and works again once the poll lands."""+ # Deliberately not returned: evaluate() awaits a returned promise, and this+ # one cannot settle until the gate is released further down.+ page.evaluate("() => { Alpine.$data(document.body).pollDashboard(); }")+ assert _url_count(page) == FETCHES_PER_POLL++ page.keyboard.press("r")+ page.wait_for_timeout(100)+ assert _url_count(page) == FETCHES_PER_POLL++ page.evaluate("() => window.__release()")+ page.wait_for_timeout(100)+ page.keyboard.press("r")+ page.wait_for_timeout(100)+ assert _url_count(page) == 2 * FETCHES_PER_POLL+++def test_a_failed_poll_releases_the_guard(page: Page) -> None: # type: ignore[valid-type]+ """A rejection must not wedge the dashboard on stale numbers forever."""+ recovered = page.evaluate(+ """async () => {+ const component = Alpine.$data(document.body);+ component.fetchStats = () => Promise.reject(new Error('boom'));+ await component.pollDashboard().catch(() => {});++ let calls = 0;+ component.fetchStats = () => { calls += 1; return Promise.resolve(); };+ await component.pollDashboard();+ return calls;+ }"""+ )++ assert recovered == 1+++def test_a_hidden_tab_still_skips_unforced_polls(page: Page) -> None: # type: ignore[valid-type]+ """Guarding must not cost the existing background-tab saving."""+ counts = page.evaluate(+ """async () => {+ Object.defineProperty(document, 'hidden', {+ configurable: true,+ get: () => true,+ });+ const component = Alpine.$data(document.body);++ component.pollDashboard();+ const unforced = window.__urls.length;+ component.pollDashboard(true);+ return { unforced, forced: window.__urls.length };+ }"""+ )++ assert counts == {"unforced": 0, "forced": FETCHES_PER_POLL}