feat: add admin provider analytics dashboard

backend/app/services/generation_jobs.py

@@ -606,23 +606,37 @@ def _aggregate_provider_events(
     }
 
 
+def _event_matches_capability(
+    event: GenerationJobEvent,
+    capability: str | None = None,
+) -> bool:
+    event_capability = str((event.event_metadata or {}).get("capability") or "unknown")
+    return capability is None or event_capability == capability
+
+
 def _provider_events_query(
     *,
-    user_id: str,
+    user_id: str | None = None,
     story_id: int | None = None,
     days: int | None = None,
 ):
     query = (
-        select(GenerationJobEvent)
+        select(
+            GenerationJobEvent,
+            GenerationJob.user_id,
+            GenerationJob.story_id,
+        )
         .join(GenerationJob, GenerationJobEvent.job_id == GenerationJob.id)
         .where(
-            GenerationJob.user_id == user_id,
             GenerationJobEvent.event_type.in_(
                 ["provider_call_succeeded", "provider_call_failed"]
             ),
         )
     )
 
+    if user_id is not None:
+        query = query.where(GenerationJob.user_id == user_id)
+
     if story_id is not None:
         query = query.where(GenerationJob.story_id == story_id)
 
@@ -681,17 +695,12 @@ async def get_user_provider_analytics(
     filtered_event_job_ids = {
         event.job_id
         for event in events
-        if capability is None
-        or str((event.event_metadata or {}).get("capability") or "unknown") == capability
+        if _event_matches_capability(event, capability)
     }
     filtered_story_ids = {
         event.story_id
         for event in events
-        if event.story_id is not None
-        and (
-            capability is None
-            or str((event.event_metadata or {}).get("capability") or "unknown") == capability
-        )
+        if event.story_id is not None and _event_matches_capability(event, capability)
     }
 
     return {
@@ -703,6 +712,87 @@ async def get_user_provider_analytics(
     }
 
 
+async def get_admin_provider_analytics(
+    db: AsyncSession,
+    *,
+    days: int | None = None,
+    capability: str | None = None,
+) -> dict[str, Any]:
+    """Aggregate provider telemetry across every user in the current environment."""
+
+    rows = (await db.execute(_provider_events_query(days=days))).all()
+    events = [event for event, _, _ in rows]
+    filtered_rows = [
+        (event, user_id, story_id)
+        for event, user_id, story_id in rows
+        if _event_matches_capability(event, capability)
+    ]
+
+    by_user: dict[str, dict[str, Any]] = {}
+    filtered_job_ids = {event.job_id for event, _, _ in filtered_rows}
+    filtered_story_ids = {
+        story_id for _, _, story_id in filtered_rows if story_id is not None
+    }
+    filtered_user_ids = {user_id for _, user_id, _ in filtered_rows}
+
+    for event, user_id, story_id in filtered_rows:
+        bucket = by_user.setdefault(
+            user_id,
+            {
+                "user_id": user_id,
+                "call_count": 0,
+                "success_count": 0,
+                "failure_count": 0,
+                "estimated_cost_usd": 0.0,
+                "job_ids": set(),
+                "story_ids": set(),
+            },
+        )
+        bucket["call_count"] += 1
+        bucket["job_ids"].add(event.job_id)
+        if story_id is not None:
+            bucket["story_ids"].add(story_id)
+
+        if event.event_type == "provider_call_succeeded":
+            bucket["success_count"] += 1
+            bucket["estimated_cost_usd"] += (
+                _as_float((event.event_metadata or {}).get("estimated_cost_usd")) or 0.0
+            )
+        else:
+            bucket["failure_count"] += 1
+
+    serialized_users = [
+        {
+            "user_id": user_id,
+            "call_count": bucket["call_count"],
+            "success_count": bucket["success_count"],
+            "failure_count": bucket["failure_count"],
+            "job_count": len(bucket["job_ids"]),
+            "story_count": len(bucket["story_ids"]),
+            "estimated_cost_usd": round(bucket["estimated_cost_usd"], 6),
+        }
+        for user_id, bucket in by_user.items()
+    ]
+    serialized_users.sort(
+        key=lambda item: (
+            -int(item["call_count"]),
+            -float(item["estimated_cost_usd"]),
+            str(item["user_id"]),
+        )
+    )
+
+    return {
+        "scope": "current_environment",
+        "window_days": days,
+        "capability": capability,
+        **_aggregate_provider_events(events, capability=capability),
+        "user_count": len(filtered_user_ids),
+        "job_count": len(filtered_job_ids),
+        "story_count": len(filtered_story_ids),
+        "by_user": serialized_users,
+    }
+
+
 async def get_user_generation_ops_summary(
     db: AsyncSession,
     *,