Upload folder using huggingface_hub

README.md

@@ -1,13 +1,20 @@
 ---
-title: P10 Observability
-emoji: 📊
+title: P10 LLM Observability Dashboard
+emoji: 🖥️
 colorFrom: indigo
-colorTo: green
+colorTo: purple
 sdk: gradio
-sdk_version: 6.17.3
-python_version: '3.13'
+sdk_version: 5.29.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# P10 · LLM Observability Dashboard
+
+Unified observability for LLM systems — eval scores, SLO burn rates,
+latency percentiles, cost tracking, prompt versioning, and anomaly alerts.
+
+Ties together P06 (code review), P08 (SRE agent), P09 (eval framework).
+Part of the [Staff SRE · AI Engineer Portfolio](https://github.com/amarshiv86).
+
+> Auto-loads on startup. Click Refresh to update.

app.py

@@ -0,0 +1,272 @@
+"""
+P10 · Observability Dashboard — HuggingFace Space
+Full dashboard: eval scores, costs, latency, SLOs, prompt versions, alerts.
+gradio==5.29.0 + audioop-lts for Python 3.13 compatibility.
+"""
+
+import os
+import sys
+
+import gradio as gr
+
+sys.path.insert(0, os.path.dirname(__file__))
+from src.collector import get_dashboard_data
+from src.alerts import detect_all_anomalies
+
+SEVERITY_EMOJI = {
+    "critical": "🔴",
+    "warning":  "🟠",
+    "info":     "🔵",
+    "OK":       "✅",
+    "ELEVATED": "🟡",
+    "WARNING":  "🟠",
+    "CRITICAL": "🔴",
+}
+
+STATUS_COLOR = {
+    "OK":       "#22d3a0",
+    "ELEVATED": "#f59e0b",
+    "WARNING":  "#f97316",
+    "CRITICAL": "#ef4444",
+}
+
+
+def build_eval_panel(data: dict) -> str:
+    history = data["eval_history"]
+    latest = data["latest_eval"]
+    score = latest.get("avg_composite", 0)
+    pass_rate = latest.get("pass_rate", 0)
+
+    trend = ""
+    if len(history) >= 2:
+        prev = history[-2]["avg_composite"]
+        curr = history[-1]["avg_composite"]
+        delta = curr - prev
+        trend = f" ({'↑' if delta >= 0 else '↓'}{abs(delta):.2f})"
+
+    lines = [
+        f"## 📊 Eval Score Trend",
+        f"**Latest:** {score:.2f}/10{trend} · Pass rate: {pass_rate}%",
+        "",
+        "| Run | Date | Score | Pass Rate |",
+        "|-----|------|-------|-----------|",
+    ]
+    for r in history[-8:]:
+        bar = "█" * int(r["avg_composite"]) + "░" * (10 - int(r["avg_composite"]))
+        lines.append(
+            f"| `{r['run_id'][-6:]}` "
+            f"| {r['timestamp'][:10]} "
+            f"| `{bar}` {r['avg_composite']:.2f} "
+            f"| {r.get('pass_rate', 0):.0f}% |"
+        )
+    return "\n".join(lines)
+
+
+def build_slo_panel(data: dict) -> str:
+    slo = data["slo"]
+    lines = ["## 🎯 SLO Status"]
+    lines.append("")
+    lines.append("| Service | SLO | Error Rate | Burn Rate | Budget Left | Status |")
+    lines.append("|---------|-----|------------|-----------|-------------|--------|")
+    for svc, m in slo.items():
+        emoji = SEVERITY_EMOJI.get(m["status"], "❓")
+        lines.append(
+            f"| `{svc}` "
+            f"| {m['slo_pct']}% "
+            f"| {m['error_rate_pct']}% "
+            f"| {m['burn_rate']}x "
+            f"| {m['budget_remaining_pct']}% "
+            f"| {emoji} {m['status']} |"
+        )
+    return "\n".join(lines)
+
+
+def build_latency_panel(data: dict) -> str:
+    lat = data["latency"]
+    lines = ["## ⚡ Latency (p50 / p95 / p99)"]
+    lines.append("")
+    lines.append("| Service | p50 | p95 | p99 | SLO | Status |")
+    lines.append("|---------|-----|-----|-----|-----|--------|")
+    for svc, m in lat.items():
+        ok = "✅ OK" if m["slo_ok"] else "❌ BREACH"
+        lines.append(
+            f"| `{svc}` "
+            f"| {m['p50_ms']}ms "
+            f"| {m['p95_ms']}ms "
+            f"| {m['p99_ms']}ms "
+            f"| {m['slo_ms']}ms "
+            f"| {ok} |"
+        )
+    return "\n".join(lines)
+
+
+def build_cost_panel(data: dict) -> str:
+    cost = data["cost_metrics"]
+    daily = cost["daily"]
+    lines = [
+        "## 💰 LLM Cost Tracker (7 days)",
+        "",
+        f"**Total 7d:** ${cost['total_7d']:.4f} · "
+        f"**Avg daily:** ${cost['avg_daily']:.4f}",
+        "",
+        "| Date | qwen2.5-0.5b | phi-3-mini | mistral-7b | Total |",
+        "|------|-------------|------------|------------|-------|",
+    ]
+    for d in daily:
+        lines.append(
+            f"| {d['date']} "
+            f"| ${d.get('qwen2.5-0.5b', 0):.4f} "
+            f"| ${d.get('phi-3-mini', 0):.4f} "
+            f"| ${d.get('mistral-7b', 0):.4f} "
+            f"| **${d['total']:.4f}** |"
+        )
+    lines.append("")
+    lines.append("**By model:**")
+    for model, cost_val in cost["by_model"].items():
+        lines.append(f"- `{model}`: ${cost_val:.4f}")
+    return "\n".join(lines)
+
+
+def build_prompt_panel(data: dict) -> str:
+    versions = data["prompt_versions"]
+    lines = [
+        "## 📝 Prompt Version History",
+        "",
+        "| Version | Date | Project | Description | Avg Score | Requests |",
+        "|---------|------|---------|-------------|-----------|----------|",
+    ]
+    for v in versions:
+        score_bar = "█" * int(v["avg_score"]) + "░" * (10 - int(v["avg_score"]))
+        lines.append(
+            f"| `{v['version']}` "
+            f"| {v['date'][:10]} "
+            f"| `{v['project']}` "
+            f"| {v['description']} "
+            f"| `{score_bar}` {v['avg_score']} "
+            f"| {v['requests']} |"
+        )
+    return "\n".join(lines)
+
+
+def build_alerts_panel(alerts: list) -> str:
+    if not alerts:
+        return "## 🔔 Alerts\n\n✅ **No anomalies detected**"
+
+    lines = [f"## 🔔 Alerts ({len(alerts)} active)", ""]
+    for a in alerts:
+        emoji = SEVERITY_EMOJI.get(a.severity, "❓")
+        lines += [
+            f"### {emoji} `{a.severity.upper()}` — {a.service}",
+            f"**{a.message}**",
+            f"- Value: `{a.value}` · Threshold: `{a.threshold}`",
+            f"- 💡 {a.recommendation}",
+            "",
+        ]
+    return "\n".join(lines)
+
+
+def refresh_dashboard() -> tuple:
+    """Fetch all data and build all panels."""
+    data = get_dashboard_data()
+    anomalies = detect_all_anomalies(data)
+
+    alert_count = len([a for a in anomalies if a.severity == "critical"])
+    warning_count = len([a for a in anomalies if a.severity == "warning"])
+
+    header = (
+        f"## 🖥️ LLM Observability Dashboard\n"
+        f"**Last updated:** {data['timestamp'][:19]} UTC · "
+        f"🔴 {alert_count} critical · 🟠 {warning_count} warnings\n\n"
+        f"_P10 · Staff SRE + AI Engineer Portfolio — ties together P06, P08, P09_"
+    )
+
+    return (
+        header,
+        build_alerts_panel(anomalies),
+        build_eval_panel(data),
+        build_slo_panel(data),
+        build_latency_panel(data),
+        build_cost_panel(data),
+        build_prompt_panel(data),
+    )
+
+
+# ── Gradio UI ──────────────────────────────────────────────────────────────────
+with gr.Blocks(title="P10 · Observability Dashboard", theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown("""
+    # 🖥️ P10 · LLM Observability Dashboard
+    **Staff SRE + AI Engineer Portfolio**
+
+    Unified observability for LLM systems — eval scores (P09), SLO burn rates (P08 pattern),
+    latency percentiles, cost tracking, prompt versioning, and anomaly alerts.
+
+    Click **Refresh** to load live data.
+    """)
+
+    refresh_btn = gr.Button("🔄 Refresh Dashboard", variant="primary", size="lg")
+
+    header_out = gr.Markdown()
+
+    with gr.Row():
+        with gr.Column():
+            alerts_out = gr.Markdown()
+        with gr.Column():
+            eval_out = gr.Markdown()
+
+    with gr.Row():
+        with gr.Column():
+            slo_out = gr.Markdown()
+        with gr.Column():
+            latency_out = gr.Markdown()
+
+    cost_out = gr.Markdown()
+    prompt_out = gr.Markdown()
+
+    with gr.Accordion("📖 Architecture", open=False):
+        gr.Markdown("""
+        ## How P10 connects to the rest of the portfolio
+
+        | Data source | Project | What it provides |
+        |-------------|---------|-----------------|
+        | SQLite eval DB | P09 | Score history + regression tracking |
+        | Mock Prometheus | P08 pattern | SLO burn rates + error budget |
+        | Mock cost tracker | P10 | Token cost by model per day |
+        | Mock Jaeger | P10 | Latency p50/p95/p99 per service |
+        | Prompt store | P10 | Version history + score per version |
+
+        **In production** you would replace mocks with:
+        - Prometheus for SLO/latency
+        - LangSmith for traces + cost
+        - PagerDuty for alert routing
+        - A real prompt registry (MLflow or custom)
+
+        **SRE additions:**
+        - Anomaly detection on all metrics (burn rate, cost spike, eval regression)
+        - Alert severity: critical pages immediately, warning creates ticket
+        - Error budget burn rate tracked and projected
+        - Prompt version tied to eval score — shows which prompt version caused regression
+        """)
+
+    gr.Markdown("""
+    ---
+    [GitHub](https://github.com/amarshiv86/p10-observability) ·
+    [P09 Eval](https://huggingface.co/spaces/amarshiv86/p09-llm-eval) ·
+    [P08 Agent](https://huggingface.co/spaces/amarshiv86/p08-sre-agent) ·
+    [Portfolio](https://github.com/amarshiv86)
+    """)
+
+    refresh_btn.click(
+        fn=refresh_dashboard,
+        outputs=[header_out, alerts_out, eval_out, slo_out,
+                 latency_out, cost_out, prompt_out],
+    )
+
+    # Auto-load on startup
+    demo.load(
+        fn=refresh_dashboard,
+        outputs=[header_out, alerts_out, eval_out, slo_out,
+                 latency_out, cost_out, prompt_out],
+    )
+
+demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio==5.29.0
+audioop-lts

src/alerts.py

@@ -0,0 +1,149 @@
+"""
+P10 · Alert Manager
+Anomaly detection on dashboard metrics.
+Generates structured alerts — in production would push to Slack/PagerDuty.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Alert:
+    id: str
+    severity: str        # critical | warning | info
+    category: str        # slo | cost | latency | eval | prompt
+    service: str
+    message: str
+    value: float
+    threshold: float
+    recommendation: str
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "severity": self.severity,
+            "category": self.category,
+            "service": self.service,
+            "message": self.message,
+            "value": self.value,
+            "threshold": self.threshold,
+            "recommendation": self.recommendation,
+        }
+
+
+# ── Anomaly detectors ─────────────────────────────────────────────────────────
+def check_slo_alerts(slo_data: dict) -> list[Alert]:
+    alerts = []
+    for svc, metrics in slo_data.items():
+        burn = metrics["burn_rate"]
+        if burn > 14.4:
+            alerts.append(Alert(
+                id=f"slo-{svc}-critical",
+                severity="critical",
+                category="slo",
+                service=svc,
+                message=f"Burn rate {burn}x — exhausts budget in <2h",
+                value=burn,
+                threshold=14.4,
+                recommendation=f"Page on-call immediately. Check recent deploys for {svc}.",
+            ))
+        elif burn > 6:
+            alerts.append(Alert(
+                id=f"slo-{svc}-warning",
+                severity="warning",
+                category="slo",
+                service=svc,
+                message=f"Burn rate {burn}x — exhausts budget in <5 days",
+                value=burn,
+                threshold=6.0,
+                recommendation=f"Investigate {svc} error rate. Review slow query logs.",
+            ))
+    return alerts
+
+
+def check_latency_alerts(latency_data: dict) -> list[Alert]:
+    alerts = []
+    for svc, metrics in latency_data.items():
+        p99 = metrics["p99_ms"]
+        slo = metrics["slo_ms"]
+        ratio = p99 / slo
+        if ratio > 0.9:
+            severity = "critical" if ratio > 1.0 else "warning"
+            alerts.append(Alert(
+                id=f"latency-{svc}",
+                severity=severity,
+                category="latency",
+                service=svc,
+                message=f"p99 {p99}ms is {ratio*100:.0f}% of {slo}ms SLO",
+                value=p99,
+                threshold=slo,
+                recommendation=f"Check {svc} for slow queries or resource saturation.",
+            ))
+    return alerts
+
+
+def check_cost_alerts(cost_data: dict) -> list[Alert]:
+    alerts = []
+    avg = cost_data.get("avg_daily", 0)
+    daily = cost_data.get("daily", [])
+    if len(daily) >= 2:
+        today = daily[-1]["total"]
+        yesterday = daily[-2]["total"]
+        if yesterday > 0 and today > yesterday * 1.5:
+            alerts.append(Alert(
+                id="cost-spike",
+                severity="warning",
+                category="cost",
+                service="llm-costs",
+                message=f"Daily cost ${today:.4f} is 50%+ above yesterday ${yesterday:.4f}",
+                value=today,
+                threshold=yesterday * 1.5,
+                recommendation="Check for unusual traffic or prompt loops causing extra tokens.",
+            ))
+    return alerts
+
+
+def check_eval_alerts(eval_history: list[dict]) -> list[Alert]:
+    alerts = []
+    if len(eval_history) >= 2:
+        current = eval_history[-1]["avg_composite"]
+        previous = eval_history[-2]["avg_composite"]
+        if previous > 0:
+            drop_pct = ((previous - current) / previous) * 100
+            if drop_pct > 10:
+                alerts.append(Alert(
+                    id="eval-regression",
+                    severity="critical",
+                    category="eval",
+                    service="llm-quality",
+                    message=f"Eval score dropped {drop_pct:.1f}% ({previous:.2f} → {current:.2f})",
+                    value=current,
+                    threshold=previous * 0.9,
+                    recommendation="Block deployment. Review recent prompt changes or model updates.",
+                ))
+            elif drop_pct > 5:
+                alerts.append(Alert(
+                    id="eval-warning",
+                    severity="warning",
+                    category="eval",
+                    service="llm-quality",
+                    message=f"Eval score dropped {drop_pct:.1f}% — approaching regression threshold",
+                    value=current,
+                    threshold=previous * 0.95,
+                    recommendation="Investigate prompt changes. Run extended test suite.",
+                ))
+    return alerts
+
+
+def detect_all_anomalies(dashboard_data: dict) -> list[Alert]:
+    """Run all anomaly detectors and return combined alert list."""
+    alerts = []
+    alerts += check_slo_alerts(dashboard_data.get("slo", {}))
+    alerts += check_latency_alerts(dashboard_data.get("latency", {}))
+    alerts += check_cost_alerts(dashboard_data.get("cost_metrics", {}))
+    alerts += check_eval_alerts(dashboard_data.get("eval_history", []))
+
+    # Sort: critical first, then warning, then info
+    priority = {"critical": 0, "warning": 1, "info": 2}
+    return sorted(alerts, key=lambda a: priority.get(a.severity, 3))

src/collector.py

@@ -0,0 +1,234 @@
+"""
+P10 · Observability Dashboard — Data Collector
+Pulls metrics from:
+- P09 SQLite eval DB (real)
+- Mock LLM cost tracker
+- Mock latency metrics
+- Mock SLO burn rates (reuses P08 pattern)
+- Prompt version store (local JSON)
+- Mock alert feed
+"""
+
+import json
+import os
+import random
+import sqlite3
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+def now_utc() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def past(hours: int) -> str:
+    return (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
+
+
+def past_days(days: int) -> str:
+    return (datetime.now(timezone.utc) - timedelta(days=days)).strftime("%Y-%m-%d")
+
+
+# ── P09 Eval scores (real SQLite) ─────────────────────────────────────────────
+P09_DB_PATH = os.environ.get(
+    "P09_DB_PATH",
+    os.path.join(os.path.dirname(__file__), "..", "data", "processed", "eval_history.db"),
+)
+
+MOCK_EVAL_HISTORY = [
+    {"run_id": f"run_{i:03d}", "timestamp": past_days(30 - i * 2),
+     "avg_composite": round(5.5 + i * 0.18 + random.uniform(-0.2, 0.2), 2),
+     "pass_rate": round(60 + i * 2.5 + random.uniform(-3, 3), 1),
+     "model_name": "qwen2.5-0.5b"}
+    for i in range(15)
+]
+
+
+def get_eval_history(n: int = 15) -> list[dict]:
+    """Get eval score history from P09 SQLite DB. Falls back to mock."""
+    db_path = os.path.abspath(P09_DB_PATH)
+    try:
+        if os.path.exists(db_path):
+            conn = sqlite3.connect(db_path)
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute("""
+                SELECT run_id, timestamp, avg_composite, pass_rate, model_name
+                FROM eval_runs ORDER BY timestamp DESC LIMIT ?
+            """, (n,)).fetchall()
+            conn.close()
+            if rows:
+                return [dict(r) for r in reversed(rows)]
+    except Exception:
+        pass
+    return MOCK_EVAL_HISTORY[-n:]
+
+
+def get_latest_eval() -> dict:
+    history = get_eval_history(1)
+    return history[-1] if history else {"avg_composite": 0, "pass_rate": 0}
+
+
+# ── LLM Cost tracker (mock) ───────────────────────────────────────────────────
+MODELS = ["qwen2.5-0.5b", "phi-3-mini", "mistral-7b"]
+MODEL_COSTS = {
+    "qwen2.5-0.5b":  {"input_per_1k": 0.00,  "output_per_1k": 0.00},
+    "phi-3-mini":    {"input_per_1k": 0.001, "output_per_1k": 0.002},
+    "mistral-7b":    {"input_per_1k": 0.002, "output_per_1k": 0.004},
+}
+
+
+def get_cost_metrics(days: int = 7) -> dict:
+    """Mock LLM cost breakdown by model and day."""
+    daily = []
+    for d in range(days):
+        date = past_days(days - d - 1)
+        day_cost = {}
+        for model in MODELS:
+            requests = random.randint(20, 150)
+            avg_input = random.randint(200, 800)
+            avg_output = random.randint(50, 300)
+            costs = MODEL_COSTS[model]
+            cost = (
+                requests * avg_input / 1000 * costs["input_per_1k"]
+                + requests * avg_output / 1000 * costs["output_per_1k"]
+            )
+            day_cost[model] = round(cost, 4)
+        daily.append({"date": date, **day_cost,
+                      "total": round(sum(day_cost.values()), 4)})
+
+    total_7d = round(sum(d["total"] for d in daily), 4)
+    return {
+        "daily": daily,
+        "total_7d": total_7d,
+        "avg_daily": round(total_7d / days, 4),
+        "by_model": {
+            m: round(sum(d[m] for d in daily), 4) for m in MODELS
+        },
+    }
+
+
+# ── Latency metrics (mock p50/p95/p99) ───────────────────────────────────────
+SERVICES_LATENCY = {
+    "p06-code-review": {"p50": 1200, "p95": 3400, "p99": 5800, "slo_ms": 30000},
+    "p08-sre-agent":   {"p50": 800,  "p95": 2100, "p99": 4200, "slo_ms": 10000},
+    "p09-eval":        {"p50": 45,   "p95": 120,  "p99": 280,  "slo_ms": 5000},
+}
+
+
+def get_latency_metrics() -> dict:
+    services = {}
+    for svc, base in SERVICES_LATENCY.items():
+        jitter = lambda x: int(x * random.uniform(0.85, 1.15))
+        p50 = jitter(base["p50"])
+        p95 = jitter(base["p95"])
+        p99 = jitter(base["p99"])
+        services[svc] = {
+            "p50_ms": p50,
+            "p95_ms": p95,
+            "p99_ms": p99,
+            "slo_ms": base["slo_ms"],
+            "slo_ok": p99 < base["slo_ms"],
+            "trend": random.choice(["stable", "stable", "improving", "degrading"]),
+        }
+    return services
+
+
+# ── SLO burn rates (reuses P08 mock pattern) ────────────────────────���─────────
+SLO_SERVICES = {
+    "api-gateway":          {"slo": 99.9,  "error_rate": 0.08},
+    "payment-service":      {"slo": 99.95, "error_rate": 0.02},
+    "auth-service":         {"slo": 99.9,  "error_rate": 0.45},
+    "notification-service": {"slo": 99.5,  "error_rate": 0.03},
+}
+
+
+def get_slo_metrics() -> dict:
+    services = {}
+    for svc, cfg in SLO_SERVICES.items():
+        budget_pct = 1 - (cfg["slo"] / 100)
+        burn_rate = cfg["error_rate"] / (budget_pct * 100)
+        jitter = random.uniform(0.9, 1.1)
+        burn_rate = round(burn_rate * jitter, 2)
+
+        if burn_rate > 14.4:
+            status = "CRITICAL"
+        elif burn_rate > 6:
+            status = "WARNING"
+        elif burn_rate > 1:
+            status = "ELEVATED"
+        else:
+            status = "OK"
+
+        services[svc] = {
+            "slo_pct": cfg["slo"],
+            "error_rate_pct": round(cfg["error_rate"] * jitter, 3),
+            "burn_rate": burn_rate,
+            "status": status,
+            "budget_remaining_pct": round(max(0, 100 - burn_rate * 2), 1),
+        }
+    return services
+
+
+# ── Prompt version history ────────────────────────────────────────────────────
+PROMPT_VERSIONS = [
+    {"version": "v1.0", "date": past_days(30), "project": "p06-code-review",
+     "description": "Initial prompt — basic severity classification",
+     "avg_score": 5.2, "requests": 120},
+    {"version": "v1.1", "date": past_days(22), "project": "p06-code-review",
+     "description": "Added JSON output format requirement",
+     "avg_score": 6.4, "requests": 340},
+    {"version": "v1.2", "date": past_days(14), "project": "p06-code-review",
+     "description": "Added category field and severity guide",
+     "avg_score": 7.1, "requests": 520},
+    {"version": "v1.0", "date": past_days(20), "project": "p08-sre-agent",
+     "description": "Initial ReAct prompt with 5 tools",
+     "avg_score": 4.8, "requests": 85},
+    {"version": "v1.1", "date": past_days(10), "project": "p08-sre-agent",
+     "description": "Added tool output format examples",
+     "avg_score": 6.2, "requests": 210},
+    {"version": "v1.0", "date": past_days(7), "project": "p09-eval",
+     "description": "LLM judge prompt with 0-10 scale",
+     "avg_score": 6.8, "requests": 450},
+]
+
+
+def get_prompt_versions() -> list[dict]:
+    return sorted(PROMPT_VERSIONS, key=lambda x: x["date"], reverse=True)
+
+
+# ── Alert feed ────────────────────────────────────────────────────────────────
+MOCK_ALERTS = [
+    {"id": "ALT-001", "severity": "critical", "service": "auth-service",
+     "message": "SLO burn rate 4.5x — error budget at risk",
+     "fired_at": past(2), "status": "firing"},
+    {"id": "ALT-002", "severity": "warning", "service": "api-gateway",
+     "message": "p99 latency 3400ms approaching 30s SLO",
+     "fired_at": past(1), "status": "firing"},
+    {"id": "ALT-003", "severity": "warning", "service": "p09-eval",
+     "message": "Eval pass rate dropped from 90% to 80%",
+     "fired_at": past(4), "status": "resolved"},
+    {"id": "ALT-004", "severity": "info", "service": "payment-service",
+     "message": "Certificate expiring in 7 days",
+     "fired_at": past(18), "status": "firing"},
+]
+
+
+def get_alerts() -> list[dict]:
+    return MOCK_ALERTS
+
+
+# ── Full dashboard snapshot ───────────────────────────────────────────────────
+def get_dashboard_data() -> dict[str, Any]:
+    """Single call that returns all dashboard panels."""
+    return {
+        "timestamp": now_utc(),
+        "eval_history": get_eval_history(),
+        "latest_eval": get_latest_eval(),
+        "cost_metrics": get_cost_metrics(),
+        "latency": get_latency_metrics(),
+        "slo": get_slo_metrics(),
+        "prompt_versions": get_prompt_versions(),
+        "alerts": get_alerts(),
+    }