benchloop-client 0.2.23__tar.gz → 0.2.24__tar.gz

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchloop_client
-Version: 0.2.23
+Version: 0.2.24
 Summary: Benchloop CLI — command line tool for benchmark analysis data (metrics, trajectory, reports, artifacts).
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.25.2
@@ -99,6 +99,15 @@ bl brm status --task-id UID
 bl brm list -g G1
 ```
 
+Metrics and Job trajectory requests always explicitly use the Trace source. The
+CLI does not expose a `trace`/`artifacts` source selector.
+
+Group trajectory retrieval and downloads use the backend Trace export API. The
+CLI waits for the export URL, downloads the gzip JSON-lines payload, and keeps
+the existing `group_id`/`trajectories` JSON layout. The export wait timeout is
+30 minutes by default; override it in seconds with
+`--download-timeout SECONDS` on trajectory commands or `pull`.
+
 Group downloads always auto-paginate and include every Job in the Group. In
 particular, `trajectory`, detailed `metrics`, `report`, and `artifacts` enumerate
 the complete Job list instead of relying on the backend Group endpoints that

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/README.md

@@ -87,6 +87,15 @@ bl brm status --task-id UID
 bl brm list -g G1
 ```
 
+Metrics and Job trajectory requests always explicitly use the Trace source. The
+CLI does not expose a `trace`/`artifacts` source selector.
+
+Group trajectory retrieval and downloads use the backend Trace export API. The
+CLI waits for the export URL, downloads the gzip JSON-lines payload, and keeps
+the existing `group_id`/`trajectories` JSON layout. The export wait timeout is
+30 minutes by default; override it in seconds with
+`--download-timeout SECONDS` on trajectory commands or `pull`.
+
 Group downloads always auto-paginate and include every Job in the Group. In
 particular, `trajectory`, detailed `metrics`, `report`, and `artifacts` enumerate
 the complete Job list instead of relying on the backend Group endpoints that

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "benchloop_client"
-version = "0.2.23"
+version = "0.2.24"
 description = "Benchloop CLI — command line tool for benchmark analysis data (metrics, trajectory, reports, artifacts)."
 readme = "README.md"
 requires-python = ">=3.10"

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/src/aliyun/bmcli/commands/_common.py

@@ -31,6 +31,12 @@ OutputDirOption = typer.Option(
 SkipExistingOption = typer.Option(
     False, "--skip-existing", help="Skip files that already exist on disk."
 )
+DownloadTimeoutOption = typer.Option(
+    1800,
+    "--download-timeout",
+    min=1,
+    help="Maximum seconds to wait for a Group Trace trajectory export.",
+)
 
 
 def expand(values: Optional[list[str]]) -> list[str]:

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/src/aliyun/bmcli/commands/metrics.py

@@ -25,6 +25,7 @@ from aliyun.bmcli.runtime import get_runtime, report_and_exit, safe_run_concurre
 app = typer.Typer(help="Run metrics (Group overall/detail, Job).", no_args_is_help=True)
 
 _SCOPES = ("overall", "detail", "all")
+_TRACE_SOURCE = "trace"
 
 _GROUP_RUN_METRIC_FIELDS = (
     "job_count",
@@ -112,7 +113,9 @@ def _validate_scope(scope: str) -> str:
 
 
 def _fetch_job(client, job_id: str):
-    data = client.get_json(f"/openapi/metrics/{job_id}")
+    data = client.get_json(
+        f"/openapi/metrics/{job_id}", params={"source": _TRACE_SOURCE}
+    )
     return _format_job_payload(data, job_id)
 
 
@@ -125,7 +128,12 @@ def fetch_group_detail(
         nonlocal tokenized_metrics
         data = client.get_json(
             "/openapi/metrics",
-            params={"group_id": group_id, "skip": skip, "limit": limit},
+            params={
+                "group_id": group_id,
+                "skip": skip,
+                "limit": limit,
+                "source": _TRACE_SOURCE,
+            },
         )
         if isinstance(data, dict) and tokenized_metrics is None:
             tokenized_metrics = data.get("tokenized_metrics")
@@ -154,7 +162,10 @@ def fetch_group_detail(
 
 
 def _fetch_group_overall(client, group_id: str):
-    data = client.get_json(f"/openapi/groups/{group_id}/metrics/overall")
+    data = client.get_json(
+        f"/openapi/groups/{group_id}/metrics/overall",
+        params={"source": _TRACE_SOURCE},
+    )
     return _format_group_overall(data, group_id)
 
 

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/src/aliyun/bmcli/commands/pull.py

@@ -14,6 +14,7 @@ from aliyun.bmcli.commands._common import (
     JobOption,
     OutputDirOption,
     SkipExistingOption,
+    DownloadTimeoutOption,
     expand,
     resolve_output_dir,
     write_empty_tgz,
@@ -29,7 +30,10 @@ from aliyun.bmcli.commands.metrics import (
     fetch_group_detail,
 )
 from aliyun.bmcli.commands.tasks import _fetch_all as fetch_all_tasks
-from aliyun.bmcli.commands.trajectory import write_group_trajectories
+from aliyun.bmcli.commands.trajectory import (
+    fetch_job_trajectory,
+    write_group_trajectories,
+)
 from aliyun.bmcli.client import ArtifactMissingError, AuthError
 from aliyun.bmcli.ids import enforce_mutually_exclusive, require_any
 from aliyun.bmcli.runtime import get_runtime
@@ -61,6 +65,7 @@ def pull(
     ),
     output_dir: Optional[str] = OutputDirOption,
     skip_existing: bool = SkipExistingOption,
+    download_timeout: int = DownloadTimeoutOption,
 ) -> None:
     """Aggregate downloads for the given groups/jobs into the layout."""
     rt = get_runtime(ctx)
@@ -107,7 +112,7 @@ def pull(
                 f"{jid}:trajectory",
                 lambda jid=jid: _fetch_and_write_json(
                     root / f"{jid}_trajectory.json",
-                    lambda: client.get_json(f"/openapi/jobs/{jid}/trajectory"),
+                    lambda: fetch_job_trajectory(client, jid),
                 ),
             )
         if "report" in selected:
@@ -160,7 +165,7 @@ def pull(
                         rt.concurrency,
                         trajectory_dest,
                         pretty=rt.pretty,
-                        ids=job_ids(_group_jobs()),
+                        download_timeout=download_timeout,
                     ),
                 )
         if "report" in selected:

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/src/aliyun/bmcli/commands/trajectory.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
+import gzip
 import json
 import os
 import shutil
 import tempfile
+import time
 import zipfile
 from pathlib import Path
-from typing import Optional
+from typing import Any, Iterator, Optional
 from urllib.parse import quote
 
 import typer
@@ -20,23 +22,230 @@ from aliyun.bmcli.commands._common import (
     OutputDirOption,
     SkipExistingOption,
     TaskIdOption,
+    DownloadTimeoutOption,
     expand,
     resolve_output_dir,
     resolve_task_id,
     task_job_ids,
 )
-from aliyun.bmcli.commands.group_data import (
-    fetch_all_jobs,
-    fetch_job_resources,
-    job_ids,
-    raise_for_failures,
-)
 from aliyun.bmcli.exit_codes import OK, PARTIAL
 from aliyun.bmcli.ids import enforce_mutually_exclusive, require_any
 from aliyun.bmcli.runtime import get_runtime, report_and_exit, safe_run_concurrent
 
 app = typer.Typer(help="Trajectory data (Group, Job).", no_args_is_help=True)
 
+_TRACE_SOURCE = "trace"
+_TRACE_DOWNLOAD_POLL_INTERVAL_SECONDS = 15.0
+_TRACE_DOWNLOAD_TOTAL_TIMEOUT_SECONDS = 1800
+
+
+def fetch_job_trajectory(client, job_id: str):
+    """Fetch one Job trajectory from the Trace-backed OpenAPI path."""
+    return client.get_json(
+        f"/openapi/jobs/{job_id}/trajectory",
+        params={"source": _TRACE_SOURCE},
+    )
+
+
+def _trace_field(data: dict[str, Any], snake_name: str, camel_name: str) -> Any:
+    if snake_name in data:
+        return data[snake_name]
+    return data.get(camel_name)
+
+
+def _trace_remaining(deadline: float) -> float:
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise RuntimeError("trace trajectory download total timeout exceeded")
+    return remaining
+
+
+def _trace_sleep(seconds: float, deadline: float) -> None:
+    time.sleep(min(seconds, _trace_remaining(deadline)))
+
+
+def _trace_retry_delay(data: dict[str, Any]) -> float:
+    raw_delay = _trace_field(data, "retry_after_seconds", "retryAfterSeconds")
+    try:
+        return max(1.0, min(float(raw_delay), _TRACE_DOWNLOAD_POLL_INTERVAL_SECONDS))
+    except (TypeError, ValueError):
+        return _TRACE_DOWNLOAD_POLL_INTERVAL_SECONDS
+
+
+def _trace_download_url(data: dict[str, Any]) -> str:
+    value = _trace_field(data, "download_url", "downloadUrl")
+    if not isinstance(value, str) or not value.strip():
+        raise RuntimeError("trace trajectory download response has no download_url")
+    return value.strip()
+
+
+def _wait_for_group_trace_download_url(
+    client, group_id: str, timeout_seconds: int = _TRACE_DOWNLOAD_TOTAL_TIMEOUT_SECONDS
+) -> str:
+    """Create and poll the backend Group Trace download job."""
+    if timeout_seconds <= 0:
+        raise ValueError("trace download timeout must be greater than 0 seconds")
+    encoded_group_id = quote(group_id, safe="")
+    create_path = f"/openapi/groups/{encoded_group_id}/trace-trajectory/download"
+    deadline = time.monotonic() + timeout_seconds
+
+    while True:
+        payload = client.get_json(create_path)
+        if not isinstance(payload, dict):
+            raise RuntimeError("trace trajectory download response must be a JSON object")
+        status = str(payload.get("status", "")).strip().lower()
+
+        if status == "succeeded":
+            return _trace_download_url(payload)
+        if status == "waiting_for_data":
+            delay = _trace_retry_delay(payload)
+            output.log(
+                f"trace trajectory not ready for group_id={group_id}; "
+                f"retrying in {delay:.1f}s"
+            )
+            _trace_sleep(delay, deadline)
+            continue
+        if status != "running":
+            raise RuntimeError(
+                f"unknown trace trajectory download status: {status or '<missing>'}"
+            )
+
+        download_job_name = _trace_field(payload, "download_job_name", "downloadJobName")
+        if not isinstance(download_job_name, str) or not download_job_name.strip():
+            raise RuntimeError(
+                "trace trajectory download response has no download_job_name"
+            )
+        encoded_name = quote(download_job_name.strip(), safe="")
+        status_path = (
+            f"/openapi/groups/{encoded_group_id}/trace-trajectory/download/{encoded_name}"
+        )
+        while True:
+            status_payload = client.get_json(status_path)
+            if not isinstance(status_payload, dict):
+                raise RuntimeError(
+                    "trace trajectory download status must be a JSON object"
+                )
+            status = str(status_payload.get("status", "")).strip().lower()
+            if status == "succeeded":
+                return _trace_download_url(status_payload)
+            if status != "running":
+                raise RuntimeError(
+                    f"unknown trace trajectory download status: "
+                    f"{status or '<missing>'}"
+                )
+            _trace_sleep(_TRACE_DOWNLOAD_POLL_INTERVAL_SECONDS, deadline)
+
+
+def _download_group_trace_archive(client, download_url: str, parent: Path) -> Path:
+    raw_path: Path | None = None
+    with tempfile.NamedTemporaryFile(
+        prefix=".trace-trajectory-",
+        suffix=".tmp",
+        dir=parent,
+        delete=False,
+    ) as raw_file:
+        raw_path = Path(raw_file.name)
+    try:
+        client.download_file(download_url, raw_path)
+        return raw_path
+    except Exception:
+        raw_path.unlink(missing_ok=True)
+        raise
+
+
+def _iter_trace_records(download_path: Path) -> Iterator[dict[str, Any]]:
+    with download_path.open("rb") as probe:
+        is_gzip = probe.read(2) == b"\x1f\x8b"
+    opener = gzip.open if is_gzip else open
+    with opener(download_path, "rt", encoding="utf-8-sig") as source:
+        for line_number, line in enumerate(source, start=1):
+            if not line.strip():
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise RuntimeError(
+                    f"invalid trace trajectory JSON at line {line_number}"
+                ) from exc
+            if not isinstance(record, dict):
+                raise RuntimeError(
+                    f"trace trajectory row at line {line_number} is not an object"
+                )
+            yield record
+
+
+def _trace_record_job_id(record: dict[str, Any]) -> str | None:
+    value = _trace_field(record, "job_id", "jobId")
+    if value is None:
+        value = record.get("JobId")
+    if not isinstance(value, str) or not value.strip():
+        return None
+    return value.strip()
+
+
+def _fetch_group_trace_job_ids(client, group_id: str) -> list[str]:
+    path = f"/openapi/groups/{quote(group_id, safe='')}/job-ids"
+    payload = client.get_json(path)
+    if not isinstance(payload, dict):
+        raise RuntimeError("group job-ids response must be a JSON object")
+    raw_job_ids = payload.get("job_ids", [])
+    if not isinstance(raw_job_ids, list):
+        raise RuntimeError("job-ids response field 'job_ids' must be a list")
+
+    result: list[str] = []
+    seen: set[str] = set()
+    for raw_job_id in raw_job_ids:
+        if not isinstance(raw_job_id, str) or not raw_job_id.strip():
+            raise RuntimeError("job-ids response contains an invalid job_id")
+        job_id = raw_job_id.strip()
+        if job_id not in seen:
+            seen.add(job_id)
+            result.append(job_id)
+    return result
+
+
+def fetch_group_trace_trajectory(
+    client,
+    group_id: str,
+    *,
+    download_timeout: int = _TRACE_DOWNLOAD_TOTAL_TIMEOUT_SECONDS,
+) -> dict[str, Any]:
+    """Fetch a Group trajectory through the backend Trace download API.
+
+    The backend performs the SLS export. The CLI only converts the downloaded
+    JSON-lines file into its existing Group response shape; it never requests
+    trajectory data one Job at a time.
+    """
+    with tempfile.TemporaryDirectory(prefix=".trace-trajectory-") as temp_dir:
+        temp_root = Path(temp_dir)
+        download_url = _wait_for_group_trace_download_url(
+            client, group_id, download_timeout
+        )
+        raw_path = _download_group_trace_archive(client, download_url, temp_root)
+        try:
+            group_job_ids = _fetch_group_trace_job_ids(client, group_id)
+            rows_by_job: dict[str, list[dict[str, Any]]] = {}
+            for record in _iter_trace_records(raw_path):
+                job_id = _trace_record_job_id(record)
+                if job_id is None:
+                    raise RuntimeError("trace trajectory row is missing job_id")
+                rows_by_job.setdefault(job_id, []).append(record)
+
+            ordered_job_ids = list(group_job_ids)
+            known_job_ids = set(ordered_job_ids)
+            ordered_job_ids.extend(
+                job_id for job_id in rows_by_job if job_id not in known_job_ids
+            )
+            return {
+                "group_id": group_id,
+                "trajectories": [
+                    {"job_id": job_id, "trajectory": rows_by_job.get(job_id, [])}
+                    for job_id in ordered_job_ids
+                ],
+            }
+        finally:
+            raw_path.unlink(missing_ok=True)
+
 
 def write_group_trajectories(
     client,
@@ -46,52 +255,30 @@ def write_group_trajectories(
     *,
     pretty: bool,
     ids: list[str] | None = None,
+    download_timeout: int = _TRACE_DOWNLOAD_TOTAL_TIMEOUT_SECONDS,
 ) -> Path:
-    if ids is None:
-        ids = job_ids(fetch_all_jobs(client, group_id))
+    # ``concurrency`` and ``ids`` remain in the helper signature for callers
+    # from older CLI code, but Group Trace downloads are now backend-owned.
+    del concurrency, ids
+    data = fetch_group_trace_trajectory(
+        client, group_id, download_timeout=download_timeout
+    )
     output.ensure_dir(dest.parent)
 
-    with tempfile.TemporaryDirectory(
-        prefix=f".{group_id}-trajectories-", dir=dest.parent
-    ) as temp_dir:
-        temp_root = Path(temp_dir)
-
-        def fetch_one(api, job_id: str) -> Path:
-            data = api.get_json(f"/openapi/jobs/{job_id}/trajectory")
-            path = temp_root / f"{quote(job_id, safe='-_.')}.json"
-            output.write_json_file(path, data, pretty=pretty)
-            return path
-
-        result = fetch_job_resources(client, ids, fetch_one, concurrency)
-        raise_for_failures("trajectories", result.failures)
-
-        temp_output = None
-        try:
-            with tempfile.NamedTemporaryFile(
-                mode="w",
-                encoding="utf-8",
-                prefix=f".{dest.name}.",
-                suffix=".tmp",
-                dir=dest.parent,
-                delete=False,
-            ) as target:
-                temp_output = Path(target.name)
-                separator = ",\n" if pretty else ","
-                target.write('{\n  "group_id": ' if pretty else '{"group_id":')
-                json.dump(group_id, target, ensure_ascii=False)
-                target.write(
-                    ',\n  "trajectories": [\n' if pretty else ',"trajectories":['
-                )
-                for index, path in enumerate(result.items):
-                    if index:
-                        target.write(separator)
-                    with path.open("r", encoding="utf-8") as source:
-                        shutil.copyfileobj(source, target)
-                target.write("  ]\n}\n" if pretty else "]}\n")
-            os.replace(temp_output, dest)
-        finally:
-            if temp_output is not None:
-                temp_output.unlink(missing_ok=True)
+    temp_output: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            prefix=f".{dest.name}.",
+            suffix=".tmp",
+            dir=dest.parent,
+            delete=False,
+        ) as target:
+            temp_output = Path(target.name)
+        output.write_json_file(temp_output, data, pretty=pretty)
+        os.replace(temp_output, dest)
+    finally:
+        if temp_output is not None:
+            temp_output.unlink(missing_ok=True)
     return dest
 
 
@@ -174,6 +361,7 @@ def get(
     ctx: typer.Context,
     group: Optional[list[str]] = GroupOption,
     job: Optional[list[str]] = JobOption,
+    download_timeout: int = DownloadTimeoutOption,
 ) -> None:
     """Query trajectory; prints a JSON array to stdout."""
     rt = get_runtime(ctx)
@@ -185,13 +373,15 @@ def get(
     if jobs:
         res = safe_run_concurrent(
             jobs,
-            lambda jid: rt.client.get_json(f"/openapi/jobs/{jid}/trajectory"),
+            lambda jid: fetch_job_trajectory(rt.client, jid),
             rt.concurrency,
         )
     else:
         res = safe_run_concurrent(
             groups,
-            lambda gid: rt.client.get_json(f"/openapi/groups/{gid}/trajectory"),
+            lambda gid: fetch_group_trace_trajectory(
+                rt.client, gid, download_timeout=download_timeout
+            ),
             rt.concurrency,
         )
     report_and_exit(res, emit=True, pretty=rt.pretty)
@@ -205,6 +395,7 @@ def download(
     task_id: Optional[str] = TaskIdOption,
     output_dir: Optional[str] = OutputDirOption,
     skip_existing: bool = SkipExistingOption,
+    download_timeout: int = DownloadTimeoutOption,
 ) -> None:
     """Download complete trajectory data to the standard file layout."""
     rt = get_runtime(ctx)
@@ -258,9 +449,7 @@ def download(
                 job_id: str,
             ) -> tuple[str, Path, Optional[Path], Optional[str]]:
                 try:
-                    data = rt.client.get_json(
-                        f"/openapi/jobs/{quote(job_id, safe='')}/trajectory"
-                    )
+                    data = fetch_job_trajectory(rt.client, quote(job_id, safe=""))
                     # job_id comes from the server-side task snapshot. Encode it
                     # before using it as a local filename so an unexpected slash
                     # or traversal segment can never escape the temporary folder.
@@ -325,7 +514,7 @@ def download(
             output.log(f"skip existing {dest}")
             job_progress.advance(str(dest))
             return str(dest)
-        data = rt.client.get_json(f"/openapi/jobs/{job_id}/trajectory")
+        data = fetch_job_trajectory(rt.client, job_id)
         output.write_json_file(dest, data, pretty=rt.pretty)
         output.log(f"wrote {dest}")
         job_progress.advance(str(dest))
@@ -343,6 +532,7 @@ def download(
             rt.concurrency,
             dest,
             pretty=rt.pretty,
+            download_timeout=download_timeout,
         )
         output.log(f"wrote {dest}")
         group_progress.advance(str(dest))

{benchloop_client-0.2.23 → benchloop_client-0.2.24}/tests/test_cmd_metrics.py

@@ -17,7 +17,9 @@ class TestMetricsGetJobUrl:
         mock_client.get_json.return_value = {"score": 0.9}
         result = invoke(runner, ["--api-key", "k", "metrics", "get", "-j", "J1"])
         assert result.exit_code == 0
-        mock_client.get_json.assert_called_once_with("/openapi/metrics/J1")
+        mock_client.get_json.assert_called_once_with(
+            "/openapi/metrics/J1", params={"source": "trace"}
+        )
 
     def test_get_job_stdout_is_json_array(self, runner, mock_client):
         mock_client.get_json.return_value = {"score": 0.9}
@@ -114,6 +116,13 @@ class TestMetricsGetGroupUrl:
         urls = [c.args[0] for c in mock_client.get_json.call_args_list]
         assert "/openapi/groups/G1/metrics/overall" in urls
         assert "/openapi/metrics" in urls
+        metric_calls = [
+            call
+            for call in mock_client.get_json.call_args_list
+            if call.args[0]
+            in {"/openapi/groups/G1/metrics/overall", "/openapi/metrics"}
+        ]
+        assert {call.kwargs["params"]["source"] for call in metric_calls} == {"trace"}
 
     def test_get_group_scope_overall_calls_one_endpoint(self, runner, mock_client):
         mock_client.get_json.return_value = {}
@@ -125,6 +134,7 @@ class TestMetricsGetGroupUrl:
         urls = [c.args[0] for c in mock_client.get_json.call_args_list]
         assert "/openapi/groups/G1/metrics/overall" in urls
         assert "/openapi/metrics" not in urls
+        assert mock_client.get_json.call_args.kwargs["params"] == {"source": "trace"}
 
     def test_get_group_scope_detail_calls_one_endpoint(self, runner, mock_client):
         mock_client.get_json.return_value = {}
@@ -136,6 +146,12 @@ class TestMetricsGetGroupUrl:
         urls = [c.args[0] for c in mock_client.get_json.call_args_list]
         assert "/openapi/metrics" in urls
         assert "/openapi/groups/G1/metrics/overall" not in urls
+        metric_calls = [
+            call
+            for call in mock_client.get_json.call_args_list
+            if call.args[0] == "/openapi/metrics"
+        ]
+        assert all(call.kwargs["params"]["source"] == "trace" for call in metric_calls)
 
     def test_get_group_stdout_is_json_array(self, runner, mock_client):
         mock_client.get_json.return_value = {}
@@ -349,7 +365,9 @@ class TestMetricsDownloadJob:
             runner,
             ["--api-key", "k", "metrics", "download", "-j", "J1", "-o", str(tmp_path)],
         )
-        mock_client.get_json.assert_called_once_with("/openapi/metrics/J1")
+        mock_client.get_json.assert_called_once_with(
+            "/openapi/metrics/J1", params={"source": "trace"}
+        )
 
 
 class TestMetricsDownloadGroup:
@@ -445,6 +463,13 @@ class TestMetricsDownloadGroup:
         urls = [c.args[0] for c in mock_client.get_json.call_args_list]
         assert "/openapi/groups/G1/metrics/overall" in urls
         assert "/openapi/metrics" in urls
+        metric_calls = [
+            call
+            for call in mock_client.get_json.call_args_list
+            if call.args[0]
+            in {"/openapi/groups/G1/metrics/overall", "/openapi/metrics"}
+        ]
+        assert {call.kwargs["params"]["source"] for call in metric_calls} == {"trace"}
 
     def test_download_group_detail_auto_paginates_all_metrics(
         self, runner, mock_client, tmp_path
@@ -491,12 +516,17 @@ class TestMetricsDownloadGroup:
             call.kwargs["params"]["skip"]
             for call in mock_client.get_json.call_args_list
         ] == [0, 2]
+        assert all(
+            call.kwargs["params"]["source"] == "trace"
+            for call in mock_client.get_json.call_args_list
+        )
 
     def test_download_group_detail_recovers_from_duplicate_page_boundaries(
         self, runner, mock_client, tmp_path
     ):
         def response(path, params=None):
             assert path == "/openapi/metrics"
+            assert params["source"] == "trace"
             skip = params["skip"]
             limit = params["limit"]
             if limit == 1000: