eggpool 0.6.2__tar.gz → 0.6.3__tar.gz

{eggpool-0.6.2 → eggpool-0.6.3}/AGENTS.md

@@ -143,7 +143,7 @@ CI sets `PYTHONHASHSEED=0` and `TZ=UTC`; reproduce locally for deterministic res
 - **Database invariants**: SQLite WAL, single-connection serialization, `async with db.transaction():` for all DML.
 - **Quota and routing**: tier-based routing via `routing_priority`, `QuotaFairScorer`, upstream-authoritative suppression, same-tier fairness rotor.
 - **Error hierarchy**: `AggregatorError` → `UpstreamError` → specific subclasses. `CapabilityError` for thinking/reasoning capability mismatches. `TranscodeLossError` (HTTP 400) for loss-policy reject. `ProtocolMismatchError` for endpoint/model-protocol mismatches.
-- **Process model**: supervisor + Granian worker (`workers=1`), PID file lifecycle, daemon mode (default for `eggpool serve`; `--verbose` for foreground). Default `runtime_threads=2`, `database_worker_threads=2` (separate read-only stats connection). Startup logs `Granian profile: workers=1 runtime_threads=N database_worker_threads=M access_log=...`.
+- **Process model**: supervisor + Granian worker (`workers=1`), PID file lifecycle, daemon mode (default for `eggpool serve`; `--verbose` for foreground). Default `runtime_threads=4`, `database_worker_threads=2` (separate read-only stats connection). Startup logs `Granian profile: workers=1 runtime_threads=N database_worker_threads=M access_log=...`.
 - **Dashboard**: server-rendered HTML, Chart.js v4, grouped timeseries, CSS tooltips. Dashboard HTML pages use a 30s in-memory cache (`DashboardTelemetry`) for heavy aggregate queries. Telemetry exposes p50/p95 render times and slowest route under `/api/stats/runtime`. Progressive graph hydration (Phase 7) decouples page shell render from chart data: chart pages render a loading shell and hydrate via `data-chart-endpoint` after the shell arrives, with per-namespace/per-period cache TTLs (1h=15s, 24h=30-60s, 7d=120-240s, 30d=240-300s) and rollup-first query behavior suppressing raw fallback for windows >2h. Overview token row uses three explicit cards (`Accounted tokens`, `Fresh tokens`, `Provider cache hit rate`) so cache-heavy workloads (`cache_read > fresh_tokens`) cannot look like an arithmetic bug; the headline `Accounted tokens` card surfaces `input + output + cache_read + cache_write` while `Fresh tokens` keeps the legacy `input + output` semantics. The `Provider cache hit rate` card uses protocol-aware canonical terms: `cache_read_tokens_canonical` (hits), `cache_write_tokens_canonical` (warmup, not hits), and `cache_eligible_input_tokens` (denominator). Per-protocol denominator rules: OpenAI-compatible input is total-billed prompt tokens (`prompt_tokens`); Anthropic denominator is `input_tokens + cache_read + cache_creation` because Anthropic `input_tokens` is fresh-only. Cache writes/creation are never described as hits. Cache read share stays bounded to `cache_read / (input + cache_read + cache_write)`. Stats summary payload exposes `total_tokens` (legacy fresh-token volume, kept for API backward compatibility), `fresh_tokens`, and `accounted_tokens` — the dashboard uses `accounted_tokens` without changing the `total_tokens` API value. Dashboard `/models` page joins canonical model-info summaries to rendered rows via `_normalize_dashboard_model_row()` (splitting provider-suffixed `model_id` into `base_model_id`/`provider_id`/`_model_info_lookup_id`) and surfaces join-failure diagnostics through `ModelInfoDashboardState.matched_row_count` / `unmatched_sample`. `CatalogRowsState` mirrors `ModelInfoDashboardState` for the catalog row builder; the previously-silent `except Exception: return []` blocks now log the traceback and set `degraded_reason="fetch_error"`. The catalog accessor `ModelCatalogCache.get_provider_model_entries()` is the source of truth for the provider-scoped `/models` rows: returns a deterministic `dict[(model_id, provider_id), dict]`, excludes the deprecated placeholder, applies configured capability overrides when `_config` is attached, and emits shallow copies so callers cannot mutate the cache. Unresolved rows (`protocol=None`) are kept so the dashboard can render them as `available=False, catalog_status="unavailable"` rather than silently dropping them.
 - **Model capabilities**: protocol-neutral `ThinkingCapability` / `ModelCapabilities` with deterministic merge. Config overrides at `[model_capabilities."<id>".thinking]` and per-provider scoped.
 - **Catalog refresh**: non-destructive by default; destructive withdrawal gated on `authoritative=True AND allow_withdrawals=True`. `static_models` is the source of truth for provider-specific protocol.

{eggpool-0.6.2 → eggpool-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eggpool
-Version: 0.6.2
+Version: 0.6.3
 Summary: A lightweight proxy that aggregates multiple LLM provider accounts behind one OpenAI-compatible endpoint
 Project-URL: Homepage, https://github.com/eggstack/eggpool
 Project-URL: Repository, https://github.com/eggstack/eggpool

{eggpool-0.6.2 → eggpool-0.6.3}/architecture/README.md

@@ -2693,14 +2693,14 @@ Granular dashboard handlers touched: `handle_runtime`, `handle_cache`, `handle_t
 
 #### Granian Runtime Threads
 
-`ServerConfig.threads` defaults to `2` (was `1`). The default config example now exposes the knob:
+`ServerConfig.threads` defaults to `4` (was `2`). The default config example now exposes the knob:
 
 ```toml
 [server]
-threads = 2
+threads = 4
 ```
 
-Granian still passes `workers=1`. Two runtime threads let a single worker multiplex streaming proxy traffic, dashboard requests, and lightweight background work without the single-event-loop starvation that becomes visible when long-lived SSE streams block the loop. `1` remains the documented minimum-footprint override for extremely constrained devices. Startup logs the effective profile:
+Granian still passes `workers=1`. Four runtime threads let a single worker multiplex streaming proxy traffic, dashboard requests, and lightweight background work without the single-event-loop starvation that becomes visible when long-lived SSE streams block the loop. `1` remains the documented minimum-footprint override for extremely constrained devices. Startup logs the effective profile:
 
 ```text
 Granian profile: workers=1 runtime_threads=N database_worker_threads=M access_log=...
@@ -2945,7 +2945,7 @@ CLI reproducer.
 ### Critical rules
 
 - Do not raise `server.threads` or `workers` to "fix" high-concurrency
-  stream instability. Granian runs `workers=1` and `threads=2`; raising
+  stream instability. Granian runs `workers=1` and `threads=4`; raising
   `threads` does not improve HTTPX concurrency and raising `workers`
   multiplies the SQLite connection budget.
 - Keep `database.worker_threads = 2` (default) so the dashboard

{eggpool-0.6.2 → eggpool-0.6.3}/config.example.toml

@@ -5,9 +5,7 @@ port = 11300
 log_level = "INFO"
 access_log = true
 # Granian runtime threads inside the single worker process. Keep workers=1.
-# 1 is minimum footprint; 2 is usually a better default for Raspberry Pi 4/5
-# and other SBC installs that serve dashboard traffic during active proxy use.
-threads = 2
+threads = 4
 
 [upstream]
 base_url = "https://opencode.ai/zen/go/v1"

{eggpool-0.6.2 → eggpool-0.6.3}/docs/deployment.md

@@ -317,7 +317,7 @@ dashboard responsiveness under request load.
 
 ```toml
 [server]
-threads = 2
+threads = 4
 access_log = false
 
 [database]
@@ -403,7 +403,7 @@ and restart. Revert to `"sampled"` or `"off"` when done.
 | Symptom | Likely cause | Knob to adjust |
 |---|---|---|
 | Dashboard loads slowly under request load | DB lock contention | Set `database.worker_threads = 2` |
-| Dashboard still slow | Runtime thread starvation | Set `server.threads = 2` |
+| Dashboard still slow | Runtime thread starvation | Check dashboard telemetry, then tune `server.threads` above 4 only on capable hardware |
 | High write volume / microSD wear | Routing trace writes | Set `routing.trace.mode = "sampled"` |
 | Background tasks cluster at minute boundaries | Task scheduling | Default is staggered; check `initial_delay_s` |
 | Stale dashboard data | Cache TTL | Wait 30s or check dashboard cache settings |
@@ -565,11 +565,11 @@ address for the probe). Either a live PID or a 200 from the probe
 causes the new `serve` to exit non-zero so a stale PID file is
 never silently overwritten.
 
-The primary tuning knob is `[server].threads` (int, default `2`,
+The primary tuning knob is `[server].threads` (int, default `4`,
 min `1`, max `64`), which sets Granian `runtime_threads` — the
-number of event-loop threads in the worker. The default of two
-threads is recommended for Raspberry Pi 4/5 so the single Granian
-worker can multiplex streaming proxy traffic + dashboard requests
+number of event-loop threads in the worker. The default of four
+threads lets the single Granian worker multiplex streaming proxy
+traffic + dashboard requests
 without single-event-loop starvation. Set `threads = 1` for
 extremely constrained devices, or raise it on capable hardware:
 

{eggpool-0.6.2 → eggpool-0.6.3}/docs/opencode-stream-stability.md

@@ -103,10 +103,10 @@ For OpenCode-style workloads, budget these limits:
 - `database.worker_threads`: 2 is sufficient for dashboards; raise
   to 4 if the dashboard itself lags.
 
-Do **not** raise `server.threads` or `workers`. Granian runs one
-worker with a single asyncio loop. Adding threads does not improve
-HTTPX concurrency, and adding workers multiplies the connection
-budget per upstream IP.
+Keep `server.threads` bounded and leave `workers=1`. The default of
+4 helps the single worker multiplex dashboard work and active streams;
+it does not increase HTTPX pool capacity. Adding workers multiplies the
+connection budget per upstream IP.
 
 ## Closure validation
 
@@ -151,4 +151,4 @@ The `/api/stats/runtime` endpoint exposes these stream-stability sections:
 - `stream_diagnostics` — outcome counters and histograms
 - `finalization_retry_queue` — queue depth, drain stats, overflow/duplicate counters
 - `routing_trace_guard` — skip rate and lock-pressure threshold
-- `db.contention` — lock-wait p50/p95/p99/max and sample count
+- `db.contention` — lock-wait p50/p95/p99/max and sample count

{eggpool-0.6.2 → eggpool-0.6.3}/docs/providers.md

@@ -445,7 +445,7 @@ state:
 
 ```toml
 [server]
-threads = 2
+threads = 4
 
 [database]
 worker_threads = 2
@@ -468,7 +468,7 @@ read timeout to absorb slow model first-token latencies:
 
 ```toml
 [server]
-threads = 2
+threads = 4
 
 [database]
 worker_threads = 2
@@ -482,9 +482,10 @@ write_timeout_s = 30
 pool_timeout_s = 60
 ```
 
-Keep `server.threads` low — Granian already serializes the asyncio
-event loop, so adding threads does not improve HTTPX throughput. The
-real lever is `max_connections`.
+Keep `server.threads` bounded — it helps the single worker multiplex
+dashboard work alongside active streams, but it does not raise HTTPX
+pool capacity. The real upstream-concurrency lever is
+`max_connections`.
 
 ### Diagnostic low-noise mode
 

{eggpool-0.6.2 → eggpool-0.6.3}/docs/raspberry-pi.md

@@ -65,7 +65,7 @@ explicitly set the recommended profile:
 
 ```toml
 [server]
-threads = 2          # 2 runtime threads for dashboard responsiveness
+threads = 4          # runtime threads for dashboard responsiveness
 access_log = false   # optional: reduce I/O noise after initial setup
 
 [database]
@@ -100,20 +100,19 @@ include_score_components = false
 ## Process Model
 
 EggPool's default process model is Pi-friendly: one `eggpool serve`
-supervisor process plus one Granian worker, with two event-loop
+supervisor process plus one Granian worker, with four event-loop
 threads in the worker (configurable via `[server].threads`). Both
 processes appear as `eggpool` in `ps` / `top` (no generic `python`
-entry), so the total footprint is two processes and two threads before
+entry), so the total footprint is two processes and four runtime threads before
 considering any upstream outbound connections.
 
 The single tuning knob for per-worker concurrency is `[server].threads`
-(int, default `2`, max `64`), which maps to Granian `runtime_threads`.
-The default is correct for Pi 4 / Pi 5; raise it only if your workload
-genuinely needs more concurrency than two event loops can deliver:
+(int, default `4`, max `64`), which maps to Granian `runtime_threads`.
+Set it to `1` for minimum footprint or raise it on capable hardware:
 
 ```toml
 [server]
-threads = 2
+threads = 4
 ```
 
 The PID file path is resolved by `eggpool.runtime_paths.default_pid_file()` in this precedence: `$EGGPOOL_PID_FILE` → `$XDG_RUNTIME_DIR/eggpool.pid` → `~/.local/state/eggpool/eggpool.pid` → `/tmp/eggpool-<UID>.pid`, and is owned by the supervisor. If `eggpool serve` ever exits non-zero with a message about an existing instance, that is the duplicate-instance guard catching a live PID or a successful `/v1/healthz` probe — check `pgrep -f eggpool` before retrying.

{eggpool-0.6.2 → eggpool-0.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eggpool"
-version = "0.6.2"
+version = "0.6.3"
 description = "A lightweight proxy that aggregates multiple LLM provider accounts behind one OpenAI-compatible endpoint"
 readme = "README.md"
 requires-python = ">=3.11"

{eggpool-0.6.2 → eggpool-0.6.3}/src/eggpool/_share/config.example.toml

@@ -5,9 +5,9 @@ port = 11300
 log_level = "INFO"
 access_log = true
 # Granian runtime threads inside the single worker process. Keep workers=1.
-# 1 is minimum footprint; 2 is usually a better default for Raspberry Pi 4/5
-# and other SBC installs that serve dashboard traffic during active proxy use.
-threads = 2
+# 1 is minimum footprint; 4 is the default for installs that serve dashboard
+# traffic during active proxy use. Granian still runs workers=1.
+threads = 4
 
 [upstream]
 base_url = "https://opencode.ai/zen/go/v1"

{eggpool-0.6.2 → eggpool-0.6.3}/src/eggpool/app.py

@@ -1002,16 +1002,22 @@ async def _lifespan_runtime(app: FastAPI) -> AsyncGenerator[None]:
             offset_30d_microdollars=acct_cfg.monthly_offset_microdollars,
         )
 
-    # 20. Metrics write coalescer for buffered analytics
+    # 20. Metrics write coalescer for buffered analytics.  Writes stay on the
+    # primary connection; dashboard rollup reads use the same dedicated
+    # read-only stats connection as the rest of StatsService when available.
     rollup_repo = UsageRollupRepository(db)
+    stats_rollup_repo = UsageRollupRepository(stats_db)
+    stats_account_backoff_repo = (
+        account_backoff_repo if stats_db is db else AccountBackoffRepository(stats_db)
+    )
 
     # 21. Statistics service
     app.state.stats = StatsService(
         stats_db,
         health_manager=health_manager,
         ping_repo=PingRepository(stats_db),
-        account_backoff_repo=account_backoff_repo,
-        rollup_repo=rollup_repo,
+        account_backoff_repo=stats_account_backoff_repo,
+        rollup_repo=stats_rollup_repo,
     )
     if config.dashboard.enabled and stats_db is db:
         logger.warning(

{eggpool-0.6.2 → eggpool-0.6.3}/src/eggpool/dashboard/routes.py

@@ -11,7 +11,7 @@ import logging
 import time
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from fastapi import Request  # noqa: TCH002 — FastAPI needs runtime access
 from fastapi.responses import HTMLResponse, JSONResponse
@@ -45,7 +45,7 @@ from eggpool.stats.queries import fetch_disabled_account_count
 from eggpool.stats.segmentation import serialize_canonical_request_segmentation
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Awaitable, Iterable
 
     from fastapi.responses import Response  # noqa: TCH004
 
@@ -67,6 +67,26 @@ _RoutingPayload = tuple[
 _PingsPayload = tuple[list[dict[str, Any]], list[dict[str, Any]]]
 
 logger = logging.getLogger(__name__)
+_DashboardStageResult = TypeVar("_DashboardStageResult")
+
+
+async def _await_dashboard_stage(
+    telemetry: Any | None,
+    page: str,
+    stage: str,
+    awaitable: Awaitable[_DashboardStageResult],
+) -> _DashboardStageResult:
+    """Await one dashboard operation and record its actual elapsed time."""
+    started = time.perf_counter()
+    try:
+        return await awaitable
+    finally:
+        if telemetry is not None:
+            telemetry.record_stage(
+                page,
+                stage,
+                (time.perf_counter() - started) * 1000,
+            )
 
 
 @dataclass(frozen=True, slots=True)
@@ -504,6 +524,28 @@ def _normalize_group_by(group_by: str) -> str:
     return group_by if group_by in _VALID_GROUP_BY else "provider_model"
 
 
+def _aggregate_series_from_grouped(
+    grouped: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Reuse grouped bucket totals for the legacy aggregate table.
+
+    The dedicated timeseries page previously issued both a grouped query
+    and a second flat query, even though the grouped contract already
+    carries lossless ``bucket_totals``.  Keeping the conversion here makes
+    the page's aggregate table a zero-cost view of the query it already
+    needs for the chart and detail table.
+    """
+    totals = grouped.get("bucket_totals")
+    if not isinstance(totals, list):
+        return []
+    result: list[dict[str, Any]] = []
+    for row_obj in cast("list[object]", totals):
+        if isinstance(row_obj, dict):
+            row = cast("dict[str, Any]", row_obj)
+            result.append(dict(row))
+    return result
+
+
 def _clamp_int(value: int, *, minimum: int, maximum: int) -> int:
     """Clamp an integer query value to an inclusive range."""
     return max(minimum, min(value, maximum))
@@ -639,18 +681,22 @@ async def handle_overview(
     time_range = resolve_time_range(period)
     stats = request.app.state.stats
     heatmap_range = _heatmap_time_range(dashboard_config.retain_request_stats_days)
+    telemetry = getattr(request.app.state, "dashboard_telemetry", None)
 
     # Always fetch the disabled count so the Account breakdown empty
     # state can offer a one-click opt-in even when no rows are
     # currently visible. Cheap one-row aggregate; safe on every render.
-    disabled_count = await _get_disabled_account_count(request, show_disabled)
+    disabled_count = await _await_dashboard_stage(
+        telemetry,
+        "overview",
+        "disabled_count",
+        _get_disabled_account_count(request, show_disabled),
+    )
 
     # Fan out the independent stat reads concurrently.  The single
     # shared connection lock serializes per-query execution, so without
     # this the page load is the sum of ten sequential round trips; with
     # it the load is bounded by the slowest query instead.
-    telemetry = getattr(request.app.state, "dashboard_telemetry", None)
-    _gather_start = time.perf_counter()
     (
         accounts,
         models,
@@ -665,70 +711,91 @@ async def handle_overview(
         compression_runtime,
         synthetic_cache_summary,
     ) = await asyncio.gather(
-        stats.get_account_stats(
-            time_range, include_disabled=show_disabled, use_cache=True
-        ),
-        stats.get_model_stats(time_range, use_cache=True),
-        stats.get_recent_events(limit=10),
-        stats.get_bandwidth_timeseries(heatmap_range, use_cache=True),
-        stats.get_ping_summary(time_range, use_cache=True),
-        stats.get_ip_stats(time_range, use_cache=True),
-        stats.get_attempt_stats(time_range),
-        stats.get_operational_event_summary(time_range),
-        stats.get_pending_health_snapshot(),
-        stats.get_cache_observability(time_range.label, use_cache=True),
-        stats.get_compression_runtime(time_range.label, use_cache=True),
-        stats.get_synthetic_cache_summary(time_range.label, use_cache=True),
-    )
-    _gather_ms = (time.perf_counter() - _gather_start) * 1000
-
-    if telemetry is not None:
-        stage_names = [
-            "disabled_count",
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "account_stats",
+            stats.get_account_stats(
+                time_range, include_disabled=show_disabled, use_cache=True
+            ),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "model_stats",
+            stats.get_model_stats(time_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "recent_events",
+            stats.get_recent_events(limit=10),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "bandwidth_daily",
+            stats.get_bandwidth_timeseries(heatmap_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "ping_summary",
+            stats.get_ping_summary(time_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "ip_stats",
+            stats.get_ip_stats(time_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "attempt_stats",
+            stats.get_attempt_stats(time_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "operational_summary",
+            stats.get_operational_event_summary(time_range, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "pending_health",
+            stats.get_pending_health_snapshot(use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "cache_observability",
+            stats.get_cache_observability(time_range.label, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
             "compression_runtime",
-        ]
-        gather_results = [
-            disabled_count,
-            accounts,
-            models,
-            events,
-            bandwidth_daily,
-            ping_summary,
-            ip_stats,
-            attempt_stats,
-            operational_summary,
-            pending_health,
-            cache_observability,
-            compression_runtime,
-        ]
-        for stage_name, _stage_val in zip(stage_names, gather_results, strict=True):
-            telemetry.record_stage(
-                "overview", stage_name, _gather_ms / len(stage_names)
-            )
-        telemetry.record_stage("overview", "synthetic_cache_summary", _gather_ms)
-
+            stats.get_compression_runtime(time_range.label, use_cache=True),
+        ),
+        _await_dashboard_stage(
+            telemetry,
+            "overview",
+            "synthetic_cache_summary",
+            stats.get_synthetic_cache_summary(time_range.label, use_cache=True),
+        ),
+    )
     # ``get_dashboard_overview`` is derived from ``accounts`` and the
     # per-period summary; both are cache hits after the gather above.
-    _overview_start = time.perf_counter()
-    overview = await stats.get_dashboard_overview(
-        time_range, account_stats=accounts, use_cache=True
+    overview = await _await_dashboard_stage(
+        telemetry,
+        "overview",
+        "dashboard_overview",
+        stats.get_dashboard_overview(
+            time_range, account_stats=accounts, use_cache=True
+        ),
     )
-    if telemetry is not None:
-        telemetry.record_stage(
-            "overview",
-            "dashboard_overview",
-            (time.perf_counter() - _overview_start) * 1000,
-        )
 
     from eggpool.metrics.thinking import get_counter
 
@@ -1873,39 +1940,28 @@ async def handle_timeseries(
     bounded_limit = clamp_grouped_limit(limit)
     stats = request.app.state.stats
     telemetry = getattr(request.app.state, "dashboard_telemetry", None)
-    _gather_start = time.perf_counter()
-    series, grouped = cast(
-        "tuple[list[dict[str, Any]] | None, dict[str, Any]]",
-        await asyncio.gather(
-            stats.get_timeseries(
-                time_range,
-                bucket=bucket,
-                account_name=account or None,
-                model_id=model or None,
-                use_cache=True,
-            ),
-            stats.get_grouped_timeseries(
-                time_range,
-                bucket=bucket,
-                group_by=group_by,
-                limit=bounded_limit,
-                account_name=account or None,
-                model_id=model or None,
-                use_cache=True,
-            ),
+    grouped = await _await_dashboard_stage(
+        telemetry,
+        "timeseries",
+        "timeseries_grouped",
+        stats.get_grouped_timeseries(
+            time_range,
+            bucket=bucket,
+            group_by=group_by,
+            limit=bounded_limit,
+            account_name=account or None,
+            model_id=model or None,
+            use_cache=True,
         ),
     )
-    _gather_ms = (time.perf_counter() - _gather_start) * 1000
-    if telemetry is not None:
-        telemetry.record_stage("timeseries", "timeseries_flat", _gather_ms)
-        telemetry.record_stage("timeseries", "timeseries_grouped", _gather_ms)
+    series = _aggregate_series_from_grouped(grouped)
     theme_css, _, current_theme, available = _get_theme_data(request, theme)
     account_options = _collect_account_options(request)
     model_options = _collect_model_options(request)
     _render_start = time.perf_counter()
     response = HTMLResponse(
         content=render_timeseries(
-            series if series is not None else [],
+            series,
             bucket=bucket,
             period=time_range.label,
             theme_css=theme_css,

{eggpool-0.6.2 → eggpool-0.6.3}/src/eggpool/dashboard/static/dashboard.js

@@ -1227,8 +1227,8 @@
   };
 
   if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", bootstrap);
+    document.addEventListener("DOMContentLoaded", namespace.bootstrap);
   } else {
-    bootstrap();
+    namespace.bootstrap();
   }
 })();