feat(dashboard): Add dashboard breakdown controls (#485)

## Summary
- add CI build-count breakdown charts with selectable repo, branch, and
author grouping
- add cost stack grouping by repo, author, and team, with chip-based
focus for one selected value
- bump CI Dashboard version to 0.4.2

## Validation
- `uv run --extra dev coverage run -m pytest`
- `uv run --extra dev coverage report --fail-under=90` (TOTAL 91%)
- `uv run --extra dev ruff check src tests`
- `npm test`
- `npm run build`

## Notes
- Cost stack grouping is requested on demand through
`group_by=repo|author|team` instead of fetching every grouping at once.

Author: dillon-zheng

ci-dashboard/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ci-dashboard"
-version = "0.4.1"
+version = "0.4.2"
 description = "CI dashboard jobs and API scaffold"
 readme = "README.md"
 requires-python = ">=3.11"

ci-dashboard/src/ci_dashboard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ci-dashboard
-Version: 0.4.1
+Version: 0.4.2
 Summary: CI dashboard jobs and API scaffold
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

ci-dashboard/src/ci_dashboard/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

ci-dashboard/src/ci_dashboard/api/queries/builds.py

@@ -25,6 +25,7 @@
 MIGRATION_IMPROVED_LIMIT = 10
 MIGRATION_REGRESSED_LIMIT = 10
 BUILD_TREND_JOB_RANKING_LIMIT = 10
+BUILD_COUNT_BREAKDOWN_LIMIT = 8
 MIGRATION_FIXED_BASELINE_START = date(2025, 12, 15)
 MIGRATION_FIXED_BASELINE_END = date(2026, 1, 14)
 MIGRATION_FIXED_RECENT_START = date(2026, 4, 15)
@@ -358,6 +359,163 @@ def get_cloud_migration_summary(engine: Engine, filters: CommonFilters) -> dict[
     }
 
 
+def get_build_count_breakdown_trend(engine: Engine, filters: CommonFilters) -> dict[str, Any]:
+    return {
+        "repo": _get_build_count_dimension_trend(
+            engine,
+            filters,
+            dimension_key="repo",
+            dimension_expr="COALESCE(NULLIF(b.repo_full_name, ''), '(unknown repo)')",
+            empty_label="(unknown repo)",
+        ),
+        "branch": _get_build_count_dimension_trend(
+            engine,
+            filters,
+            dimension_key="branch",
+            dimension_expr=f"COALESCE(NULLIF({branch_expr('b')}, ''), '(unknown branch)')",
+            empty_label="(unknown branch)",
+        ),
+        "author": _get_build_count_dimension_trend(
+            engine,
+            filters,
+            dimension_key="author",
+            dimension_expr="COALESCE(NULLIF(b.author, ''), '(unknown author)')",
+            empty_label="(unknown author)",
+        ),
+        "meta": {
+            **filters.meta(),
+            "limit": BUILD_COUNT_BREAKDOWN_LIMIT,
+        },
+    }
+
+
+def _get_build_count_dimension_trend(
+    engine: Engine,
+    filters: CommonFilters,
+    *,
+    dimension_key: str,
+    dimension_expr: str,
+    empty_label: str,
+) -> dict[str, Any]:
+    with engine.begin() as connection:
+        where_clause, params = build_common_where(filters, table_alias="b")
+        builds_table = builds_table_expr(connection, filters, alias="b")
+        bucket = bucket_expr(connection, "b.start_time", filters.granularity)
+        rows = connection.execute(
+            text(
+                f"""
+                SELECT
+                  {bucket} AS bucket_start,
+                  {dimension_expr} AS dimension_name,
+                  COUNT(*) AS build_count
+                FROM {builds_table}
+                WHERE {where_clause}
+                GROUP BY bucket_start, {dimension_expr}
+                ORDER BY bucket_start, build_count DESC, dimension_name ASC
+                """
+            ),
+            params,
+        ).mappings()
+        data_rows = [dict(row) for row in rows]
+        if filters.granularity == "week":
+            data_rows = filter_complete_week_rows(
+                data_rows,
+                start_date=filters.start_date,
+                end_date=filters.end_date,
+            )
+
+    totals: dict[str, int] = {}
+    buckets: set[str] = set()
+    counts_by_dimension: dict[str, dict[str, int]] = {}
+    for row in data_rows:
+        bucket_start = str(row["bucket_start"])
+        dimension_name = str(row["dimension_name"] or empty_label)
+        build_count = int(row["build_count"] or 0)
+        buckets.add(bucket_start)
+        totals[dimension_name] = totals.get(dimension_name, 0) + build_count
+        counts_by_dimension.setdefault(dimension_name, {})[bucket_start] = build_count
+
+    ordered_buckets = sorted(buckets)
+    if not ordered_buckets:
+        return {
+            "items": [],
+            "series": [],
+            "meta": {
+                **filters.meta(),
+                "dimension": dimension_key,
+                "limit": BUILD_COUNT_BREAKDOWN_LIMIT,
+            },
+        }
+
+    total_builds = sum(totals.values())
+    ordered_dimensions = sorted(
+        totals,
+        key=lambda name: (-totals[name], name),
+    )
+    visible_dimensions = ordered_dimensions[:BUILD_COUNT_BREAKDOWN_LIMIT]
+    overflow_dimensions = ordered_dimensions[BUILD_COUNT_BREAKDOWN_LIMIT:]
+
+    items = [
+        {
+            "name": dimension_name,
+            "value": totals[dimension_name],
+            "share_pct": rate_pct(totals[dimension_name], total_builds),
+        }
+        for dimension_name in visible_dimensions
+    ]
+    if overflow_dimensions:
+        other_total = sum(totals[dimension_name] for dimension_name in overflow_dimensions)
+        items.append(
+            {
+                "name": "Others",
+                "value": other_total,
+                "share_pct": rate_pct(other_total, total_builds),
+            }
+        )
+
+    series = [
+        {
+            "key": f"{dimension_key}:{dimension_name}",
+            "label": dimension_name,
+            "type": "bar",
+            "points": [
+                [bucket_start, counts_by_dimension.get(dimension_name, {}).get(bucket_start, 0)]
+                for bucket_start in ordered_buckets
+            ],
+        }
+        for dimension_name in visible_dimensions
+    ]
+    if overflow_dimensions:
+        series.append(
+            {
+                "key": f"{dimension_key}:Others",
+                "label": "Others",
+                "type": "bar",
+                "points": [
+                    [
+                        bucket_start,
+                        sum(
+                            counts_by_dimension.get(dimension_name, {}).get(bucket_start, 0)
+                            for dimension_name in overflow_dimensions
+                        ),
+                    ]
+                    for bucket_start in ordered_buckets
+                ],
+            }
+        )
+
+    return {
+        "items": items,
+        "series": series,
+        "meta": {
+            **filters.meta(),
+            "dimension": dimension_key,
+            "limit": BUILD_COUNT_BREAKDOWN_LIMIT,
+            "total_builds": total_builds,
+        },
+    }
+
+
 def get_longest_avg_success_jobs(engine: Engine, filters: CommonFilters) -> dict[str, Any]:
     with engine.begin() as connection:
         where_clause, params = build_common_where(filters, table_alias="b")

ci-dashboard/src/ci_dashboard/api/queries/cost.py

@@ -12,6 +12,7 @@
 from ci_dashboard.api.queries.base import CommonFilters, bucket_expr, rate_pct, to_number
 
 COST_STACK_LIMIT = 8
+VALID_COST_STACK_GROUPS = frozenset({"repo", "author", "team"})
 UNMATCHED_RESOURCE_LIMIT = 20
 UNMATCHED_RESOURCE_MAX_WINDOW_DAYS = 31
 ENGINEERING_GROUP_NAME = "Engineering Group"
@@ -255,76 +256,85 @@ def _get_engineering_share_by_level_threshold(
         )
 
 
-def get_repo_group_cost_stack(engine: Engine, filters: CommonFilters) -> dict[str, Any]:
+def get_repo_group_cost_stack(
+    engine: Engine,
+    filters: CommonFilters,
+    *,
+    group_by: str = "repo",
+) -> dict[str, Any]:
+    if group_by not in VALID_COST_STACK_GROUPS:
+        group_by = "repo"
+
     with engine.begin() as connection:
         where_clause, params = _build_cost_where(filters, table_alias="c")
         bucket = bucket_expr(connection, "c.usage_date", filters.granularity)
+        dimension = _cost_stack_dimension(connection, group_by)
         top_rows = connection.execute(
             text(
                 f"""
                 SELECT
-                  COALESCE(NULLIF(c.repo, ''), '(no repo)') AS repo_name,
+                  {dimension["expr"]} AS dimension_name,
                   SUM(c.list_cost) AS list_cost
-                FROM cost_attribution_daily c
+                FROM {dimension["from_clause"]}
                 WHERE {where_clause}
-                GROUP BY repo_name
-                ORDER BY list_cost DESC, repo_name
+                GROUP BY dimension_name
+                ORDER BY list_cost DESC, dimension_name
                 LIMIT :limit
                 """
             ),
-            {**params, "limit": COST_STACK_LIMIT},
+            {**params, **dimension["params"], "limit": COST_STACK_LIMIT},
         ).mappings()
-        top_repos = [str(row["repo_name"]) for row in top_rows]
-        if not top_repos:
+        top_dimensions = [str(row["dimension_name"] or dimension["empty_label"]) for row in top_rows]
+        if not top_dimensions:
             return {
                 "series": [],
                 "items": [],
-                "meta": {**filters.meta(), "limit": COST_STACK_LIMIT},
+                "meta": {**filters.meta(), "limit": COST_STACK_LIMIT, "group_by": group_by},
             }
 
         dimension_conditions = []
         dimension_params: dict[str, Any] = {}
-        for index, repo_name in enumerate(top_repos):
-            repo_key = f"repo_{index}"
+        for index, dimension_name in enumerate(top_dimensions):
+            dimension_key = f"dimension_{index}"
             dimension_conditions.append(
-                f"COALESCE(NULLIF(c.repo, ''), '(no repo)') = :{repo_key}"
+                f"{dimension['expr']} = :{dimension_key}"
             )
-            dimension_params[repo_key] = repo_name
+            dimension_params[dimension_key] = dimension_name
 
         rows = connection.execute(
             text(
                 f"""
                 SELECT
                   {bucket} AS bucket_start,
-                  COALESCE(NULLIF(c.repo, ''), '(no repo)') AS repo_name,
+                  {dimension["expr"]} AS dimension_name,
                   SUM(c.list_cost) AS list_cost
-                FROM cost_attribution_daily c
+                FROM {dimension["from_clause"]}
                 WHERE {where_clause}
                   AND ({" OR ".join(dimension_conditions)})
-                GROUP BY bucket_start, repo_name
-                ORDER BY bucket_start, repo_name
+                GROUP BY bucket_start, dimension_name
+                ORDER BY bucket_start, dimension_name
                 """
             ),
-            {**params, **dimension_params},
+            {**params, **dimension["params"], **dimension_params},
         ).mappings()
         data_rows = [dict(row) for row in rows]
 
     buckets = _bucket_starts(filters, data_rows)
     values_by_key = {
-        _repo_key(repo_name, index): {bucket: 0.0 for bucket in buckets}
-        for index, repo_name in enumerate(top_repos)
+        _cost_stack_key(group_by, dimension_name, index): {bucket: 0.0 for bucket in buckets}
+        for index, dimension_name in enumerate(top_dimensions)
     }
     labels_by_key = {
-        _repo_key(repo_name, index): repo_name
-        for index, repo_name in enumerate(top_repos)
+        _cost_stack_key(group_by, dimension_name, index): dimension_name
+        for index, dimension_name in enumerate(top_dimensions)
     }
-    repo_key_by_name = {
-        repo_name: _repo_key(repo_name, index)
-        for index, repo_name in enumerate(top_repos)
+    key_by_name = {
+        dimension_name: _cost_stack_key(group_by, dimension_name, index)
+        for index, dimension_name in enumerate(top_dimensions)
     }
     for row in data_rows:
-        repo_name = str(row["repo_name"])
-        key = repo_key_by_name[repo_name]
+        dimension_name = str(row["dimension_name"] or dimension["empty_label"])
+        key = key_by_name[dimension_name]
         values_by_key[key][str(row["bucket_start"])] = _money(row["list_cost"])
 
     return {
@@ -344,7 +354,7 @@ def get_repo_group_cost_stack(engine: Engine, filters: CommonFilters) -> dict[st
             }
             for key in values_by_key
         ],
-        "meta": {**filters.meta(), "limit": COST_STACK_LIMIT},
+        "meta": {**filters.meta(), "limit": COST_STACK_LIMIT, "group_by": group_by},
     }
 
 
@@ -1157,10 +1167,61 @@ def _null_safe_eq(connection: Connection, left_expr: str, right_expr: str) -> st
     return f"{left_expr} <=> {right_expr}"
 
 
-def _repo_key(repo_name: str, index: int) -> str:
-    if repo_name == "(no repo)":
+def _cost_stack_dimension(connection: Connection, group_by: str) -> dict[str, Any]:
+    if group_by not in VALID_COST_STACK_GROUPS:
+        group_by = "repo"
+
+    if group_by == "author":
+        return {
+            "expr": "COALESCE(NULLIF(c.author, ''), '(unknown author)')",
+            "from_clause": "cost_attribution_daily c",
+            "params": {},
+            "empty_label": "(unknown author)",
+        }
+    if group_by == "team":
+        team_match = _like_prefix_expr(connection, "c_group.path", "target_group.path")
+        return {
+            "expr": "COALESCE(NULLIF(target_group.name, ''), '(no team)')",
+            "from_clause": f"""
+                cost_attribution_daily c
+                LEFT JOIN roster_groups c_group
+                  ON c_group.id = c.group_id
+                LEFT JOIN (
+                  SELECT id, path
+                  FROM roster_groups
+                  WHERE name = :cost_stack_root_group_name
+                    AND is_active = 1
+                  ORDER BY id
+                  LIMIT 1
+                ) root_group
+                  ON 1=1
+                LEFT JOIN roster_groups target_parent
+                  ON target_parent.is_active = 1
+                 AND target_parent.parent_id = root_group.id
+                LEFT JOIN roster_groups target_group
+                  ON target_group.is_active = 1
+                 AND target_group.parent_id = target_parent.id
+                 AND {team_match}
+            """,
+            "params": {"cost_stack_root_group_name": ENGINEERING_GROUP_NAME},
+            "empty_label": "(no team)",
+        }
+    return {
+        "expr": "COALESCE(NULLIF(c.repo, ''), '(no repo)')",
+        "from_clause": "cost_attribution_daily c",
+        "params": {},
+        "empty_label": "(no repo)",
+    }
+
+
+def _cost_stack_key(group_by: str, dimension_name: str, index: int) -> str:
+    if group_by == "repo" and dimension_name == "(no repo)":
         return "repo__no_repo"
-    return f"repo__{index}"
+    if group_by == "author" and dimension_name == "(unknown author)":
+        return "author__unknown_author"
+    if group_by == "team" and dimension_name == "(no team)":
+        return "team__no_team"
+    return f"{group_by}__{index}"
 
 
 def _cost_source_value(vendor: str, account_id: str) -> str: