feat(docker): Busiest Containers shows bars of the last hours beside each figure, scaled to the row's peak with a floor (#5214)

The fill bars were a share of the host's capacity, a sliver on hosts with
80 cores. Each figure now sits beside 24 bars of the last 6 hours (1h/24h
per widget), each row scaled to its own peak but never below 1 core or
1 GiB (configurable per widget), so a 0.05-core container reads flat and
a bar's height means real load. One grouped date_bin query feeds them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

plugins/docker/service.py

@@ -328,6 +328,56 @@ async def container_points(db, host_id: str, name: str, metric: str, since,
     return [(t, float(v)) for t, v in hourly] + [(t, float(v)) for t, v in raw]
 
 
+# Busiest Containers bars (#5214): the recent past in BARS equal slices.
+BARS = 24
+
+
+def bar_slots(now: datetime, hours: int, bars: int = BARS) -> tuple[list[datetime], int]:
+    """The start of each of the last `bars` buckets covering `hours`, oldest
+    first, aligned as date_bin aligns them (to the epoch), and their width in
+    seconds. The newest bucket is the one `now` falls in."""
+    width = max(60, hours * 3600 // bars)
+    last = int(now.timestamp()) // width * width
+    return [datetime.fromtimestamp(last - (bars - 1 - i) * width, timezone.utc)
+            for i in range(bars)], width
+
+
+async def recent_usage(db, keys, since: datetime, width: int) -> dict:
+    """{(host_id, container_name): {bucket start: (cpu_pct, mem_usage_bytes)}}
+    averaged per bucket since `since`, for the given containers, in one query."""
+    keys = set(keys)
+    if not keys:
+        return {}
+    bucket = func.date_bin(
+        func.make_interval(0, 0, 0, 0, 0, 0, int(width)), DockerMetric.scraped_at, func.to_timestamp(0),
+    ).label("bucket")
+    rows = (await db.execute(
+        select(DockerMetric.host_id, DockerMetric.container_name, bucket,
+               func.avg(DockerMetric.cpu_pct), func.avg(DockerMetric.mem_usage_bytes))
+        .where(DockerMetric.scraped_at >= since,
+               DockerMetric.host_id.in_({h for h, _ in keys}),
+               DockerMetric.container_name.in_({n for _, n in keys}))
+        .group_by(DockerMetric.host_id, DockerMetric.container_name, bucket)
+    )).all()
+    out: dict = {}
+    for host_id, name, at, cpu, mem in rows:
+        if (host_id, name) in keys:
+            out.setdefault((host_id, name), {})[at] = (
+                None if cpu is None else float(cpu), None if mem is None else float(mem))
+    return out
+
+
+def scaled_bars(values: list, floor: float) -> dict:
+    """Bar heights in % of a roof: the row's own peak, but never below `floor`,
+    so a container idling at 0.05 cores draws flat and its 0.05 → 0.10 wobble
+    doesn't look like a 1.5 → 3 core spike. None (no samples) stays a gap."""
+    present = [v for v in values if v is not None]
+    peak = max(present) if present else None
+    roof = max(peak or 0.0, floor)
+    return {"bars": [None if v is None else round(100.0 * v / roof, 1) for v in values],
+            "peak": peak, "roof": roof}
+
+
 async def search_logs(db, *, since, host_id: str | None = None, name: str | None = None,
                       text: str = "", stream: str = "", before=None, limit: int = 50) -> list:
     """Retained log lines matching a filter, newest first (limit + 1 fetched by callers