charisma-cli 0.3.0__tar.gz → 0.3.1__tar.gz

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/.gitignore

@@ -136,3 +136,7 @@ allure-results/*
 allure-results-live/
 *tasks.meta.json
 *.code-workspace
+
+# Session-specific work-state tracking (see .kiro update-work-state skill)
+.current-task.md
+.agents/pipeline-status.json

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
 Author: Charisma Team
 License-Expression: MIT
@@ -75,15 +75,31 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `CHARISMA_TOKEN`      | Yes      | Service or CI bearer token                         |
 | `CHARISMA_PROJECT_ID` | Yes      | Project alias for result routing                   |
 | `CHARISMA_RESULTS`    | No       | Path to allure-results (default: `allure-results`) |
+| `CHARISMA_RUN_KEY`    | No       | Run identity / merge key (`--run-key` fallback)    |
+| `BUILD_ID`            | No       | CI build identifier (`--build-id` fallback; `CHARISMA_BUILD_ID` also honored) |
+| `BUILD_PLAN_KEY`      | No       | Build plan key (`--build-plan-key` fallback; `CHARISMA_BUILD_PLAN_KEY` also honored) |
+| `ENVIRONMENT`         | No       | Environment code (`--environment` fallback; `CHARISMA_ENVIRONMENT` also honored) |
+| `COMPONENT`           | No       | Component alias (`--component` fallback; `CHARISMA_COMPONENT` also honored) |
+| `SOURCE_URL`          | No       | CI/CD build link (`--source-url` fallback; `CHARISMA_SOURCE_URL` also honored) |
 
 ## Flags
 
-| Flag             | Description                                  |
-| ---------------- | -------------------------------------------- |
-| `--results PATH` | Allure results directory (overrides env var) |
-| `--project ID`   | Project alias (overrides env var)            |
-| `--silent`       | Don't fail pipeline if upload errors occur   |
-| `--skip-too-big` | Skip result files larger than 2MB            |
+Both `upload` and `watch` accept the identical option set.
+
+| Flag                 | Description                                                      |
+| -------------------- | --------------------------------------------------------------- |
+| `--endpoint URL`     | Charisma API endpoint (overrides `CHARISMA_ENDPOINT`)           |
+| `--token TOKEN`      | Bearer token (overrides `CHARISMA_TOKEN`)                       |
+| `--results PATH`     | Allure results directory (overrides env var)                    |
+| `--project ID`       | Project alias (overrides env var)                               |
+| `--silent`           | Don't fail pipeline if upload errors occur                      |
+| `--skip-too-big`     | Skip result files larger than 2MB                               |
+| `--component ALIAS`  | Component alias within the project                              |
+| `--source-url URL`   | CI/CD build link for this run                                   |
+| `--build-plan-key K` | Explicit build plan key for resolution (forwarded as `buildPlanKey`) |
+| `--build-id ID`      | CI build identifier for this run (forwarded as `buildId`)       |
+| `--environment ENV`  | Environment code (e.g. `qat`, `prod`), stored on the launch     |
+| `--run-key KEY`      | Run identity / merge key (reruns + parallel workers share it)   |
 
 ## Launch URL in CI
 

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/README.md

@@ -50,15 +50,31 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `CHARISMA_TOKEN`      | Yes      | Service or CI bearer token                         |
 | `CHARISMA_PROJECT_ID` | Yes      | Project alias for result routing                   |
 | `CHARISMA_RESULTS`    | No       | Path to allure-results (default: `allure-results`) |
+| `CHARISMA_RUN_KEY`    | No       | Run identity / merge key (`--run-key` fallback)    |
+| `BUILD_ID`            | No       | CI build identifier (`--build-id` fallback; `CHARISMA_BUILD_ID` also honored) |
+| `BUILD_PLAN_KEY`      | No       | Build plan key (`--build-plan-key` fallback; `CHARISMA_BUILD_PLAN_KEY` also honored) |
+| `ENVIRONMENT`         | No       | Environment code (`--environment` fallback; `CHARISMA_ENVIRONMENT` also honored) |
+| `COMPONENT`           | No       | Component alias (`--component` fallback; `CHARISMA_COMPONENT` also honored) |
+| `SOURCE_URL`          | No       | CI/CD build link (`--source-url` fallback; `CHARISMA_SOURCE_URL` also honored) |
 
 ## Flags
 
-| Flag             | Description                                  |
-| ---------------- | -------------------------------------------- |
-| `--results PATH` | Allure results directory (overrides env var) |
-| `--project ID`   | Project alias (overrides env var)            |
-| `--silent`       | Don't fail pipeline if upload errors occur   |
-| `--skip-too-big` | Skip result files larger than 2MB            |
+Both `upload` and `watch` accept the identical option set.
+
+| Flag                 | Description                                                      |
+| -------------------- | --------------------------------------------------------------- |
+| `--endpoint URL`     | Charisma API endpoint (overrides `CHARISMA_ENDPOINT`)           |
+| `--token TOKEN`      | Bearer token (overrides `CHARISMA_TOKEN`)                       |
+| `--results PATH`     | Allure results directory (overrides env var)                    |
+| `--project ID`       | Project alias (overrides env var)                               |
+| `--silent`           | Don't fail pipeline if upload errors occur                      |
+| `--skip-too-big`     | Skip result files larger than 2MB                               |
+| `--component ALIAS`  | Component alias within the project                              |
+| `--source-url URL`   | CI/CD build link for this run                                   |
+| `--build-plan-key K` | Explicit build plan key for resolution (forwarded as `buildPlanKey`) |
+| `--build-id ID`      | CI build identifier for this run (forwarded as `buildId`)       |
+| `--environment ENV`  | Environment code (e.g. `qat`, `prod`), stored on the launch     |
+| `--run-key KEY`      | Run identity / merge key (reruns + parallel workers share it)   |
 
 ## Launch URL in CI
 

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "charisma-cli"
-version = "0.3.0"
+version = "0.3.1"
 description = "CLI tool that watches allure-results and streams test results + attachments to Charisma."
 readme = "README.md"
 license = "MIT"

charisma_cli-0.3.1/src/charisma_cli/__init__.py

@@ -0,0 +1,7 @@
+"""charisma-cli: Stream allure results to Charisma in real time."""
+
+# Single source of truth for the CLI version. At build time the wheel metadata
+# is generated from pyproject.toml [project].version, so keeping this literal
+# equal to pyproject guarantees `--version` reports the published version. The
+# prepare-commit step owns the PATCH bump — do not hand-bump here.
+__version__ = "0.3.1"

charisma_cli-0.3.1/src/charisma_cli/config.py

@@ -0,0 +1,149 @@
+"""Configuration dataclass with env var + CLI flag resolution."""
+
+import os
+from dataclasses import dataclass
+
+import click
+
+
+def _resolve_env(bare_name: str) -> str | None:
+    """Resolve an env var by its bare name, falling back to the CHARISMA_ prefix.
+
+    Bare-name-first (e.g. ``BUILD_ID``) keeps parity with CI systems that export
+    generic build metadata, while the ``CHARISMA_`` prefixed form (e.g.
+    ``CHARISMA_BUILD_ID``) is honored as a namespaced fallback. Returns the first
+    non-empty value, or None.
+    """
+    for name in (bare_name, f"CHARISMA_{bare_name}"):
+        value = os.getenv(name)
+        if value and value.strip():
+            return value.strip()
+    return None
+
+
+@dataclass
+class Config:
+    """Resolved configuration for charismactl.
+
+    Fields are populated via from_env() which merges CLI flag overrides
+    with environment variable fallbacks.
+    """
+
+    endpoint: str
+    token: str
+    project: str
+    results_dir: str
+    silent: bool
+    skip_too_big: bool
+    drain_timeout: int
+    build_id: str | None
+    commit_sha: str | None
+    branch: str | None
+    component: str | None = None
+    source_url: str | None = None
+    build_plan_key: str | None = None
+    environment: str | None = None
+    name: str | None = None
+    tags: list[str] | None = None
+    run_key: str | None = None
+
+    @classmethod
+    def from_env(
+        cls,
+        *,
+        endpoint: str | None = None,
+        token: str | None = None,
+        project: str | None = None,
+        results: str | None = None,
+        silent: bool = False,
+        skip_too_big: bool = False,
+        drain_timeout: int = 30,
+        component: str | None = None,
+        source_url: str | None = None,
+        build_plan_key: str | None = None,
+        build_id: str | None = None,
+        environment: str | None = None,
+        run_key: str | None = None,
+    ) -> "Config":
+        """Build Config by resolving CLI flags over environment variables.
+
+        Resolution order: CLI flag (if not None) > env var > default.
+
+        Args:
+            endpoint: --endpoint flag override
+            token: --token flag override
+            project: --project flag override
+            results: --results flag override
+            silent: --silent flag
+            skip_too_big: --skip-too-big flag
+            drain_timeout: drain timeout in seconds
+            component: --component flag override (component alias within the
+                project). Env: COMPONENT, fallback CHARISMA_COMPONENT.
+            source_url: --source-url flag override (CI/CD build link). Env:
+                SOURCE_URL, fallback CHARISMA_SOURCE_URL.
+            build_plan_key: --build-plan-key flag override (explicit build plan
+                key). Env: BUILD_PLAN_KEY, fallback CHARISMA_BUILD_PLAN_KEY.
+            build_id: --build-id flag override (CI build identifier). Env:
+                BUILD_ID, fallback CHARISMA_BUILD_ID. Flag wins over env.
+            environment: --environment flag override (env code, e.g. "qat").
+                Persisted to the first-class launch environment column. Env:
+                ENVIRONMENT, fallback CHARISMA_ENVIRONMENT.
+            run_key: --run-key flag override. Client-supplied merge key: the
+                backend derives the launch id as uuid5(project/run_key) and
+                get-or-creates, so reruns and parallel producers sharing a key
+                land in one launch. Empty/whitespace resolves to None (a new
+                random launch, unchanged behavior).
+
+        Returns:
+            Fully resolved Config instance.
+
+        Raises:
+            click.UsageError: If required fields (endpoint, token) are missing.
+        """
+        # Connection config resolves from the CHARISMA_-prefixed name ONLY (no
+        # bare form): a generic ENDPOINT/TOKEN/PROJECT_ID/RUN_KEY in the
+        # environment must not silently reconfigure the client. Build/run
+        # metadata below uses _resolve_env (bare-first, prefixed fallback) so it
+        # picks up generic CI variables. Do NOT "unify" these — the split is
+        # intentional and mirrors pytest-charisma (bare_env_var=None for config).
+        resolved_endpoint = (endpoint or os.getenv("CHARISMA_ENDPOINT", "")).strip()
+        resolved_token = (token or os.getenv("CHARISMA_TOKEN", "")).strip()
+        resolved_project = (project or os.getenv("CHARISMA_PROJECT_ID", "")).strip()
+        resolved_results = results or os.getenv("CHARISMA_RESULTS", "allure-results")
+        resolved_run_key = (run_key or os.getenv("CHARISMA_RUN_KEY", "")).strip() or None
+        resolved_component = (component or _resolve_env("COMPONENT") or "").strip() or None
+        resolved_source_url = (source_url or _resolve_env("SOURCE_URL") or "").strip() or None
+        resolved_build_plan_key = (build_plan_key or _resolve_env("BUILD_PLAN_KEY") or "").strip() or None
+        resolved_build_id = (build_id or _resolve_env("BUILD_ID") or "").strip() or None
+        resolved_environment = (environment or _resolve_env("ENVIRONMENT") or "").strip() or None
+        # Human-readable launch name (LAUNCH_NAME) and comma-separated tags
+        # (TAGS, e.g. "CI/CD,performance") shown on the Launches page.
+        resolved_name = (_resolve_env("LAUNCH_NAME") or "").strip() or None
+        resolved_tags = [t.strip() for t in (_resolve_env("TAGS") or "").split(",") if t.strip()] or None
+
+        if not resolved_endpoint:
+            raise click.UsageError(
+                "Missing required configuration: endpoint. Set CHARISMA_ENDPOINT or pass --endpoint."
+            )
+        if not resolved_token:
+            raise click.UsageError("Missing required configuration: token. Set CHARISMA_TOKEN or pass --token.")
+
+        return cls(
+            endpoint=resolved_endpoint,
+            token=resolved_token,
+            project=resolved_project,
+            results_dir=resolved_results,
+            silent=silent,
+            skip_too_big=skip_too_big,
+            drain_timeout=drain_timeout,
+            build_id=resolved_build_id,
+            commit_sha=_resolve_env("COMMIT_SHA"),
+            branch=_resolve_env("BRANCH"),
+            component=resolved_component,
+            source_url=resolved_source_url,
+            build_plan_key=resolved_build_plan_key,
+            environment=resolved_environment,
+            name=resolved_name,
+            tags=resolved_tags,
+            run_key=resolved_run_key,
+        )

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/src/charisma_cli/main.py

@@ -2,6 +2,7 @@
 
 import signal
 import sys
+from collections.abc import Callable
 from pathlib import Path
 from queue import PriorityQueue
 
@@ -39,6 +40,11 @@ def _resolve_config(
     results: str,
     silent: bool,
     skip_too_big: bool,
+    component: str | None = None,
+    source_url: str | None = None,
+    build_plan_key: str | None = None,
+    build_id: str | None = None,
+    environment: str | None = None,
     run_key: str | None = None,
 ) -> Config:
     """Resolve CLI config from flags + env vars. Re-raises UsageError on failure."""
@@ -49,6 +55,11 @@ def _resolve_config(
         results=results,
         silent=silent,
         skip_too_big=skip_too_big,
+        component=component,
+        source_url=source_url,
+        build_plan_key=build_plan_key,
+        build_id=build_id,
+        environment=environment,
         run_key=run_key,
     )
 
@@ -135,23 +146,50 @@ def _print_summary(uploader: Uploader) -> None:
     )
 
 
+def _common_options(func: Callable) -> Callable:
+    """Apply the shared connection + launch-metadata options to a command.
+
+    `watch` and `upload` accept the identical option set; defining it once here
+    keeps them from drifting (a new launch field is added in one place, not two).
+    Decorators apply bottom-up, so the visible order on the command matches the
+    order below.
+    """
+    options = [
+        click.option("--endpoint", envvar="CHARISMA_ENDPOINT", default=None, help="Charisma API endpoint."),
+        click.option("--token", envvar="CHARISMA_TOKEN", default=None, help="Bearer token."),
+        click.option(
+            "--results", envvar="CHARISMA_RESULTS", default="allure-results", help="Allure results directory."
+        ),
+        click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias."),
+        click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur."),
+        click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB."),
+        click.option("--component", default=None, help="Component alias within the project."),
+        click.option("--source-url", default=None, help="CI/CD build link for this run."),
+        click.option("--build-plan-key", default=None, help="Explicit build plan key for resolution."),
+        click.option("--build-id", default=None, help="CI build identifier for this run (forwarded as buildId)."),
+        click.option(
+            "--environment",
+            default=None,
+            help="Environment code (e.g. 'qat', 'prod'). Stored as the launch environment.",
+        ),
+        click.option(
+            "--run-key",
+            envvar="CHARISMA_RUN_KEY",
+            default=None,
+            help="Run identity / merge key (NOT the build id). Producers sharing this key "
+            "stream into one launch (launch id = uuid5(project/run-key)) — powers "
+            "rerun-in-place and parallel workers; reruns record retry attempts. Use your "
+            "CI run/pipeline id (e.g. GITHUB_RUN_ID) so retries merge but separate runs "
+            "stay separate. Omit for a new launch.",
+        ),
+    ]
+    for option in reversed(options):
+        func = option(func)
+    return func
+
+
 @cli.command()
-@click.option("--endpoint", envvar="CHARISMA_ENDPOINT", default=None, help="Charisma API endpoint.")
-@click.option("--token", envvar="CHARISMA_TOKEN", default=None, help="Bearer token.")
-@click.option("--results", envvar="CHARISMA_RESULTS", default="allure-results", help="Allure results directory.")
-@click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
-@click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
-@click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
-@click.option(
-    "--run-key",
-    envvar="CHARISMA_RUN_KEY",
-    default=None,
-    help="Run identity / merge key (NOT the build id). Producers sharing this key "
-    "stream into one launch (launch id = uuid5(project/run-key)) — powers "
-    "rerun-in-place and parallel workers; reruns record retry attempts. Use your "
-    "CI run/pipeline id (e.g. GITHUB_RUN_ID) so retries merge but separate runs "
-    "stay separate. Omit for a new launch.",
-)
+@_common_options
 @click.argument("command", nargs=-1, required=True)
 def watch(
     endpoint: str | None,
@@ -160,6 +198,11 @@ def watch(
     project: str,
     silent: bool,
     skip_too_big: bool,
+    component: str | None,
+    source_url: str | None,
+    build_plan_key: str | None,
+    build_id: str | None,
+    environment: str | None,
     run_key: str | None,
     command: tuple[str, ...],
 ) -> None:
@@ -167,7 +210,20 @@ def watch(
 
     Usage: charismactl watch --project my-project -- pytest -n 4 tests/
     """
-    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big, run_key)
+    config = _resolve_config(
+        endpoint,
+        token,
+        project,
+        results,
+        silent,
+        skip_too_big,
+        component,
+        source_url,
+        build_plan_key,
+        build_id,
+        environment,
+        run_key,
+    )
 
     queue: PriorityQueue[FileEvent] = PriorityQueue()
     uploader = Uploader(config, queue)
@@ -220,7 +276,12 @@ def watch(
 
     # Drain and close — stop the watcher AFTER drain so the consumer's final
     # queue flush still sees anything the observer enqueued during drain.
-    uploader.drain(timeout=config.drain_timeout)
+    # drain() is progress-based and returns False if it stalled or any send
+    # failed — same partial-send guard as `upload`. In watch mode a dropped
+    # upload must not be masked by a passing test run (exit 0), so an incomplete
+    # drain forces a non-zero exit while still preserving a failing test's own
+    # exit code.
+    fully_drained = uploader.drain(timeout=config.drain_timeout)
     watcher.stop()
     uploader.stop()
 
@@ -232,26 +293,22 @@ def watch(
 
     _warn_if_results_unsent(uploader, config)
     _print_summary(uploader)
+
+    if not fully_drained:
+        click.echo(
+            "Error: upload did not finish — the consumer stalled or results "
+            "failed to send; some results were dropped. Exiting non-zero so this "
+            "run is not treated as a successful upload.",
+            err=True,
+        )
+        # Preserve a failing test's exit code; otherwise surface the upload
+        # failure as exit 1 instead of letting a passing test mask it.
+        sys.exit(exit_code if exit_code != 0 else 1)
     sys.exit(exit_code)
 
 
 @cli.command()
-@click.option("--endpoint", envvar="CHARISMA_ENDPOINT", default=None, help="Charisma API endpoint.")
-@click.option("--token", envvar="CHARISMA_TOKEN", default=None, help="Bearer token.")
-@click.option("--results", envvar="CHARISMA_RESULTS", default="allure-results", help="Allure results directory.")
-@click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
-@click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
-@click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
-@click.option(
-    "--run-key",
-    envvar="CHARISMA_RUN_KEY",
-    default=None,
-    help="Run identity / merge key (NOT the build id). Producers sharing this key "
-    "stream into one launch (launch id = uuid5(project/run-key)) — powers "
-    "rerun-in-place and parallel workers; reruns record retry attempts. Use your "
-    "CI run/pipeline id (e.g. GITHUB_RUN_ID) so retries merge but separate runs "
-    "stay separate. Omit for a new launch.",
-)
+@_common_options
 def upload(
     endpoint: str | None,
     token: str | None,
@@ -259,13 +316,31 @@ def upload(
     project: str,
     silent: bool,
     skip_too_big: bool,
+    component: str | None,
+    source_url: str | None,
+    build_plan_key: str | None,
+    build_id: str | None,
+    environment: str | None,
     run_key: str | None,
 ) -> None:
     """Upload completed allure-results to Charisma (post-execution).
 
     Usage: charismactl upload --project my-project --results allure-results
     """
-    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big, run_key)
+    config = _resolve_config(
+        endpoint,
+        token,
+        project,
+        results,
+        silent,
+        skip_too_big,
+        component,
+        source_url,
+        build_plan_key,
+        build_id,
+        environment,
+        run_key,
+    )
 
     queue: PriorityQueue[FileEvent] = PriorityQueue()
     uploader = Uploader(config, queue)
@@ -292,9 +367,14 @@ def upload(
             if category is not None:
                 queue.put(FileEvent(path=filepath, category=category))
 
-    # Process and drain
+    # Process and drain. drain() is progress-based: it runs to completion for a
+    # healthy upload of any size and only returns False if the consumer STALLS
+    # (no progress for drain_timeout seconds). A False return means results were
+    # dropped — we must still close the launch and print the summary, then exit
+    # non-zero so CI sees a failure instead of a green build with a partial send
+    # (the upload results_sent=700/10158-queued bug).
     uploader.start()
-    uploader.drain(timeout=config.drain_timeout)
+    fully_drained = uploader.drain(timeout=config.drain_timeout)
     uploader.stop()
 
     # Close launch
@@ -303,3 +383,12 @@ def upload(
     uploader.stop()
 
     _print_summary(uploader)
+
+    if not fully_drained:
+        click.echo(
+            "Error: upload did not finish — the consumer stalled and some results "
+            "were not sent. Exiting non-zero so this run is not treated as a "
+            "successful upload.",
+            err=True,
+        )
+        sys.exit(1)

{charisma_cli-0.3.0 → charisma_cli-0.3.1}/src/charisma_cli/uploader.py

@@ -171,7 +171,7 @@ class Uploader:
             self._client.close()
             self._client = None
 
-    def drain(self, timeout: float) -> None:
+    def drain(self, timeout: float) -> bool:
         """Signal drain and wait until all consumed items are flushed/sent.
 
         Waits for BOTH the queue to empty AND the in-memory batch to be flushed.
@@ -182,32 +182,102 @@ class Uploader:
         result unsent — the ``watch results_sent=0`` bug. Once the queue is empty,
         this forces a final batch flush so pending results are sent before return.
 
+        Progress-based completion (not a fixed wall-clock cap): a large run (e.g.
+        10k+ parametrizations) legitimately takes minutes to upload, far longer
+        than any safe fixed timeout. A fixed deadline silently abandoned every
+        still-queued item on expiry — the ``upload`` partial-send bug where a
+        1201-/10k-result run reported ``results_sent=700`` and exited 0 while
+        thousands of results sat undrained. Instead, this keeps waiting as long
+        as the backlog (queue + unfinished tasks) is shrinking, and only gives up
+        when progress STALLS — no item processed for ``timeout`` seconds. A
+        healthy upload runs to completion no matter how large; only a genuine
+        hang (dead connection, wedged consumer) trips the stall guard.
+
         Args:
-            timeout: Maximum seconds to wait for the queue+batch to drain.
+            timeout: Stall timeout in seconds — the maximum time to wait with NO
+                progress before giving up. This is an idle window, not a total
+                deadline; total drain time is unbounded while progress continues.
+
+        Returns:
+            True only if EVERY consumed result was accepted by the backend:
+            the queue is empty, the batch is flushed, no batch failed
+            (``results_failed == 0``), and uploads were not disabled mid-run by
+            the circuit breaker (``_disabled``) or a 401 (``_auth_failed``).
+            False otherwise. A False return means results were NOT fully sent and
+            the caller MUST surface it as a failure (non-zero exit) rather than
+            report success. Draining the queue is necessary but NOT sufficient:
+            on a connection failure the consumer still dequeues every item (and
+            counts it failed) so the backlog reaches 0 — checking only emptiness
+            would wrongly report success on a partial send. Success therefore
+            requires send-level confirmation, not just an empty queue.
         """
         self._drain_event.set()
-        deadline = time.monotonic() + timeout
 
         # Phase 1: wait for the queue to empty AND for the consumer to finish
         # processing every dequeued item. Checking queue.empty() alone is racy:
         # an item that has been dequeued but not yet appended to the batch is in
         # neither the queue nor the batch. unfinished_tasks (decremented by the
         # consumer's task_done()) closes that window.
-        while (not self._queue.empty() or self._queue.unfinished_tasks > 0) and time.monotonic() < deadline:
+        #
+        # Stall detection: track the outstanding backlog and the monotonic time
+        # it last decreased. As long as the backlog keeps falling we keep
+        # waiting (a big run is slow, not stuck). If the backlog does not move
+        # for ``timeout`` seconds we conclude the consumer is wedged and stop.
+        def _backlog() -> int:
+            return self._queue.qsize() + max(self._queue.unfinished_tasks, 0)
+
+        # Guard a non-positive stall window: treat it as "no stall tolerance is
+        # meaningless" and fall back to a small positive floor, so a healthy but
+        # slow run is never abandoned on the first idle 50ms tick.
+        stall_timeout = timeout if timeout > 0 else 0.5
+
+        last_backlog = _backlog()
+        last_progress = time.monotonic()
+        while _backlog() > 0:
             time.sleep(0.05)
+            current = _backlog()
+            if current < last_backlog:
+                last_backlog = current
+                last_progress = time.monotonic()
+            elif time.monotonic() - last_progress >= stall_timeout:
+                break
 
-        # Phase 2: the consumer is idle and everything is now in the batch (or
-        # already sent). Force out any partial batch that hasn't hit the 50-item
-        # or 2s trigger, so drain() honors its contract: everything consumed has
-        # been sent when it returns.
+        # Phase 2: force out any partial batch that hasn't hit the 50-item or 2s
+        # trigger, so drain() honors its contract: everything consumed has been
+        # sent when it returns fully drained.
         self._flush_batch()
 
-        if not self._queue.empty() or self._queue.unfinished_tasks > 0 or self._batch:
-            logger.warning(
-                "Drain timeout expired with %d queued and %d batched items remaining",
+        # Success requires BOTH an empty backlog AND send-level confirmation.
+        # Draining the queue alone is not enough: on a connection failure the
+        # consumer dequeues every item, counts it failed, and empties the queue —
+        # so emptiness would falsely report success while results were dropped
+        # (the connection-failure variant of the partial-send bug). Require that
+        # nothing failed and uploads were not disabled mid-run.
+        backlog_clear = self._queue.empty() and self._queue.unfinished_tasks <= 0 and not self._batch
+        sends_ok = (
+            self._summary.results_failed == 0
+            and not self._disabled
+            and not self._auth_failed
+        )
+        fully_drained = backlog_clear and sends_ok
+
+        if not backlog_clear:
+            logger.error(
+                "Drain stalled with no progress for %.0fs — %d queued and %d batched items "
+                "were NOT sent (results dropped)",
+                stall_timeout,
                 self._queue.qsize(),
                 len(self._batch),
             )
+        elif not sends_ok:
+            logger.error(
+                "Drain completed but %d result(s) failed to send "
+                "(uploads_disabled=%s, auth_failed=%s) — results dropped",
+                self._summary.results_failed,
+                self._disabled,
+                self._auth_failed,
+            )
+        return fully_drained
 
     def open_launch(self) -> str | None:
         """Open a streaming launch via the API.
@@ -239,6 +309,18 @@ class Uploader:
             payload["commitSha"] = self._config.commit_sha
         if self._config.branch:
             payload["branch"] = self._config.branch
+        if self._config.component:
+            payload["componentAlias"] = self._config.component
+        if self._config.source_url:
+            payload["sourceUrl"] = self._config.source_url
+        if self._config.build_plan_key:
+            payload["buildPlanKey"] = self._config.build_plan_key
+        if self._config.environment:
+            payload["environment"] = self._config.environment
+        if self._config.name:
+            payload["name"] = self._config.name
+        if self._config.tags:
+            payload["tags"] = self._config.tags
 
         for attempt in range(MAX_RETRIES + 1):
             try: