codeboarding 0.14.1__tar.gz → 0.14.2__tar.gz

{codeboarding-0.14.1/codeboarding.egg-info → codeboarding-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.1
+Version: 0.14.2
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.14.1 → codeboarding-0.14.2}/README.md

@@ -212,10 +212,11 @@ for the actual depth. Existing baseline loading behavior is unchanged: prefer
 
 ## Telemetry
 
-CodeBoarding collects anonymous, aggregate usage telemetry (which command ran,
-success/failure, duration, and token cost) to help us improve the tool. It is on
-by default and never collects source code, file names, repository names, paths,
-prompts, model outputs, API keys, or any personal information. Opt out anytime:
+CodeBoarding collects usage telemetry (which command ran, success/failure,
+duration, token cost, repository size and languages, and the account the
+repository belongs to) to help us improve the tool. It is on by default and
+never collects source code, file names, repository names, paths, prompts, model
+outputs, or API keys. Opt out anytime:
 
 ```bash
 export CODEBOARDING_TELEMETRY=false   # or: export DO_NOT_TRACK=1

{codeboarding-0.14.1 → codeboarding-0.14.2/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.1
+Version: 0.14.2
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.14.1 → codeboarding-0.14.2}/codeboarding.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 clustering_ids.py
 constants.py
 github_action.py
+health_main.py
 install.py
 logging_config.py
 main.py

codeboarding-0.14.2/health_main.py

@@ -0,0 +1,152 @@
+"""Standalone entry point for running health checks on a repository.
+
+Runs static analysis and health checks only — no LLM agents or diagram generation.
+Useful for testing health checks in isolation and for CI/CD health gates.
+
+Usage:
+    # Local repository (output written to <repo>/.codeboarding/health/)
+    python health_main.py --local /path/to/repo
+
+    # Remote repository (cloned to cwd/repos/, output to cwd/<repo_name>/.codeboarding/health/)
+    python health_main.py https://github.com/user/repo
+"""
+
+import argparse
+import logging
+from pathlib import Path
+
+from health.runner import run_health_checks
+from health.config import initialize_health_dir, load_health_config
+from logging_config import setup_logging
+from repo_utils import clone_repository, get_repo_name
+from static_analyzer import get_static_analysis
+from utils import CODEBOARDING_DIR_NAME, get_artifact_dir
+from vscode_constants import update_config
+
+logger = logging.getLogger(__name__)
+
+
+def run_health_check_local(
+    repo_path: Path,
+    project_name: str | None = None,
+) -> None:
+    """Run health checks on a local repository.
+
+    Args:
+        repo_path: Path to a local repository
+        project_name: Optional project name (default: repo directory name)
+    """
+    resolved_repo_path = repo_path.resolve()
+    if not resolved_repo_path.is_dir():
+        raise ValueError(f"Repository path does not exist: {resolved_repo_path}")
+
+    resolved_project_name = project_name or resolved_repo_path.name
+    output_dir = resolved_repo_path / CODEBOARDING_DIR_NAME
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    setup_logging(log_dir=output_dir)
+
+    _run_health_checks(resolved_repo_path, resolved_project_name, output_dir)
+
+
+def run_health_check_remote(
+    repo_url: str,
+    project_name: str | None = None,
+) -> None:
+    """Run health checks on a remote repository.
+
+    Args:
+        repo_url: URL of a remote Git repository
+        project_name: Optional project name (default: extracted from URL)
+    """
+    repo_root = Path("repos")
+    repo_name = clone_repository(repo_url, repo_root)
+    resolved_repo_path = repo_root / repo_name
+    resolved_project_name = project_name or get_repo_name(repo_url)
+    output_dir = Path.cwd() / repo_name / CODEBOARDING_DIR_NAME
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    setup_logging(log_dir=output_dir)
+
+    _run_health_checks(resolved_repo_path, resolved_project_name, output_dir)
+
+
+def _run_health_checks(repo_path: Path, project_name: str, output_dir: Path) -> None:
+    """Core health check logic shared by local and remote paths."""
+    logger.info(f"Running health checks on '{project_name}' at {repo_path}")
+
+    static_analysis = get_static_analysis(repo_path, cache_dir=get_artifact_dir(repo_path))
+
+    # Load health check configuration and initialize health config dir
+    health_config_dir = output_dir / "health"
+    initialize_health_dir(health_config_dir)
+    health_config = load_health_config(health_config_dir)
+
+    report = run_health_checks(static_analysis, project_name, config=health_config, repo_path=repo_path)
+
+    if report is None:
+        logger.warning("Health checks skipped: no languages found in static analysis results")
+        return
+
+    report_path = health_config_dir / "health_report.json"
+    report_path.write_text(report.model_dump_json(indent=2, exclude_none=True))
+
+    logger.info(f"Health report written to {report_path} (overall score: {report.overall_score:.3f})")
+
+
+def main():
+    """Main entry point that parses CLI arguments and routes to subcommands."""
+    parser = argparse.ArgumentParser(
+        description="Run static analysis health checks on a repository (local or remote)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Local repository (output written to <repo>/.codeboarding/health/)
+  python health_main.py --local /path/to/repo
+
+  # Remote repository (cloned to cwd/repos/, output to cwd/<repo_name>/.codeboarding/health/)
+  python health_main.py https://github.com/user/repo
+
+        """,
+    )
+    parser.add_argument(
+        "repositories",
+        nargs="*",
+        help="One or more remote Git repository URLs to run health checks on",
+    )
+    parser.add_argument("--local", type=Path, help="Path to a local repository")
+    parser.add_argument(
+        "--project-name",
+        type=str,
+        default=None,
+        help="Name of the project (default: extracted from repo path or URL)",
+    )
+    parser.add_argument(
+        "--binary-location", type=Path, help="Path to the binary directory for language servers and tools"
+    )
+
+    args = parser.parse_args()
+
+    # Validate: must provide either remote repos or --local, not both
+    has_remote = bool(args.repositories)
+    has_local = args.local is not None
+
+    if has_remote == has_local:
+        parser.error("Provide either one or more remote repositories or --local, but not both.")
+
+    # Resolve binary paths for tools (tokei, LSP servers, etc.)
+    if args.binary_location:
+        update_config(args.binary_location)
+
+    try:
+        if has_local:
+            run_health_check_local(args.local, args.project_name)
+        else:
+            for repo_url in args.repositories:
+                run_health_check_remote(repo_url, args.project_name)
+    except ValueError as e:
+        parser.error(str(e))
+
+
+if __name__ == "__main__":
+    main()

{codeboarding-0.14.1 → codeboarding-0.14.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.14.1"
+version = "0.14.2"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"

{codeboarding-0.14.1 → codeboarding-0.14.2}/repo_utils/__init__.py

@@ -66,6 +66,8 @@ def sanitize_repo_url(repo_url: str) -> str:
     Normalizes Git URLs to ensure proper format for cloning.
     Preserves HTTPS URLs for CI compatibility while supporting SSH URLs.
     """
+    repo_url = repo_url.rstrip("/")  # else the suffix below yields ``.../repo/.git``
+
     if repo_url.startswith("git@") or repo_url.startswith("ssh://"):
         return repo_url  # already in SSH format
     elif repo_url.startswith("https://") or repo_url.startswith("http://"):
@@ -94,8 +96,7 @@ def remote_repo_exists(repo_url: str) -> bool:
 
 
 def get_repo_name(repo_url: str):
-    repo_url = sanitize_repo_url(repo_url)
-    base = repo_url.rstrip("/").split("/")[-1]
+    base = sanitize_repo_url(repo_url).split("/")[-1]
     repo_name, _ = os.path.splitext(base)
     return repo_name
 

codeboarding-0.14.2/telemetry/__init__.py

@@ -0,0 +1,11 @@
+"""Opt-out usage telemetry.
+
+One singleton (``telemetry``) sends events to PostHog. Disabled with
+``CODEBOARDING_TELEMETRY=false`` (or ``DO_NOT_TRACK=1``). No repo content, paths,
+or API keys are ever sent; the repository's owning account is, so events are
+pseudonymous rather than anonymous. See ``service.py`` for the identity rules.
+"""
+
+from telemetry.service import ProductTelemetry, telemetry
+
+__all__ = ["ProductTelemetry", "telemetry"]

{codeboarding-0.14.1 → codeboarding-0.14.2}/telemetry/service.py

@@ -30,16 +30,40 @@ def _telemetry_disabled() -> bool:
     return os.getenv("CODEBOARDING_TELEMETRY", "true").strip().lower() == "false"
 
 
+def _org() -> str:
+    """The account a run's repository belongs to, or '' when none is named.
+
+    Why: ``CODEBOARDING_ORG`` when a caller knows the owner, else the owner half
+    of ``GITHUB_REPOSITORY``; the repository's own name is never read.
+    """
+    owner = os.getenv("CODEBOARDING_ORG", "").strip() or os.getenv("GITHUB_REPOSITORY", "").strip().partition("/")[0]
+    return owner.lower()
+
+
+#: Properties describing the process rather than the event. A payload that could
+#: set one could hide automated traffic inside usage, or claim an owner it does
+#: not have — so they are dropped from caller properties before the origin is
+#: applied. Listed rather than derived from ``_origin()``: ``org`` is absent
+#: there when no owner is known, which is exactly the case a caller could fill.
+ORIGIN_KEYS = frozenset({"source", "internal", "org"})
+
+
 def _origin() -> dict[str, object]:
-    """Who invoked this run, and whether that is a person using the product.
+    """Who invoked this run, whether that is product usage, and which deployment.
 
-    ``source`` is the existing discriminator: "vscode" when invoked by the
-    extension, "oss" for the OSS CLI, "github_action" in CI, "tests" for the
-    engine's own suite, "evals" for the benchmark harness, "core" for any other
-    embedding. ``internal`` is derived from it so the two can never disagree.
+    Why: ``internal`` is derived from ``source`` so the two cannot disagree, and
+    ``org`` is omitted rather than blank so an absent key reads as unknown.
     """
     source = os.getenv("CODEBOARDING_SOURCE", "core")
-    return {"source": source, "internal": source in INTERNAL_SOURCES}
+    origin: dict[str, object] = {"source": source, "internal": source in INTERNAL_SOURCES}
+    if org := _org():
+        origin["org"] = org
+    return origin
+
+
+def _with_origin(properties: dict | None) -> dict:
+    """Caller properties, unable to claim any of :data:`ORIGIN_KEYS`."""
+    return {k: v for k, v in (properties or {}).items() if k not in ORIGIN_KEYS} | _origin()
 
 
 class ProductTelemetry:
@@ -88,12 +112,7 @@ class ProductTelemetry:
             self._client.capture(
                 distinct_id=self.user_id,
                 event=event,
-                # Origin LAST, so it wins. Who invoked the run is a property of
-                # the process, not a field an event model gets to claim — and
-                # `internal` is the one property a product metric filters on, so
-                # a payload that could overwrite it is a payload that could hide
-                # automated traffic inside usage.
-                properties={**(properties or {}), **_origin()},
+                properties=_with_origin(properties),
             )
         except Exception as e:
             logger.debug("Telemetry capture failed: %s", e)
@@ -106,12 +125,7 @@ class ProductTelemetry:
             self._client.capture_exception(
                 exc,
                 distinct_id=self.user_id,
-                # Origin LAST, so it wins. Who invoked the run is a property of
-                # the process, not a field an event model gets to claim — and
-                # `internal` is the one property a product metric filters on, so
-                # a payload that could overwrite it is a payload that could hide
-                # automated traffic inside usage.
-                properties={**(properties or {}), **_origin()},
+                properties=_with_origin(properties),
             )
         except Exception as e:
             logger.debug("Telemetry capture_exception failed: %s", e)

codeboarding-0.14.2/tests/test_telemetry_service.py

@@ -0,0 +1,205 @@
+"""What every event carries about who produced it.
+
+``source`` has always said which invoker a run came from. What it could not say
+is whether that invoker is a *person using the product*: a dashboard measuring
+usage had to spell out ``source not in ('tests', 'evals')`` and was silently
+wrong from the moment another internal source was added. ``internal`` is derived
+from the source in one place so that filter is one condition and stays correct.
+
+These exercise ``ProductTelemetry`` itself rather than ``telemetry.events``,
+which stubs ``capture`` out — the stamping happens below that stub, so it is
+invisible to every test in ``test_telemetry_events.py``.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from telemetry.service import INTERNAL_SOURCES, ProductTelemetry
+
+
+@pytest.fixture
+def client(monkeypatch):
+    """A recorder in place of the PostHog SDK, on the live singleton."""
+    seen = SimpleNamespace(captures=[], exceptions=[])
+    service = ProductTelemetry()
+    monkeypatch.setattr(
+        service,
+        "_client",
+        SimpleNamespace(
+            capture=lambda **kw: seen.captures.append(kw),
+            capture_exception=lambda exc, **kw: seen.exceptions.append((exc, kw)),
+            flush=lambda: None,
+        ),
+    )
+    seen.service = service
+    return seen
+
+
+def test_a_product_run_is_not_marked_internal(client, monkeypatch):
+    monkeypatch.setenv("CODEBOARDING_SOURCE", "oss")
+
+    client.service.capture("analysis_started", {"command": "run_full"})
+
+    props = client.captures[0]["properties"]
+    assert props["source"] == "oss"
+    assert props["internal"] is False
+
+
+@pytest.mark.parametrize("source", sorted(INTERNAL_SOURCES))
+def test_every_internal_source_is_marked_internal(client, monkeypatch, source):
+    """The benchmark harness sets ``evals``; the engine's own suite sets ``tests``.
+    Neither is a person using the product, and neither may be counted as one."""
+    monkeypatch.setenv("CODEBOARDING_SOURCE", source)
+
+    client.service.capture("analysis_completed", {"status": "success"})
+
+    props = client.captures[0]["properties"]
+    assert props["source"] == source
+    assert props["internal"] is True
+
+
+def test_an_unknown_source_defaults_to_product_traffic(client, monkeypatch):
+    """A source nobody declared is an embedding of the library, which IS usage.
+    Defaulting the other way would quietly drop a real integration's runs."""
+    monkeypatch.setenv("CODEBOARDING_SOURCE", "some-new-wrapper")
+
+    client.service.capture("analysis_started", {})
+
+    assert client.captures[0]["properties"]["internal"] is False
+
+
+def test_the_origin_travels_on_exceptions_too(client, monkeypatch):
+    """``$exception`` is an event like any other, and error-rate dashboards are
+    exactly where a run of the benchmark's deliberate failure cases would hurt."""
+    monkeypatch.setenv("CODEBOARDING_SOURCE", "evals")
+    exc = RuntimeError("boom")
+
+    client.service.capture_exception(exc, properties={"command": "run_incremental"})
+
+    _, kwargs = client.exceptions[0]
+    assert kwargs["properties"]["internal"] is True
+    assert kwargs["properties"]["command"] == "run_incremental"
+
+
+def test_a_caller_property_never_overwrites_the_origin(client, monkeypatch):
+    """The origin merges LAST, so a caller cannot claim it.
+
+    It used to go first, which left an event model free to overwrite `source`
+    simply by having a field of that name. No schema does today — but `internal`
+    is the one property a product metric filters on, so a payload that could
+    overwrite it is a payload that could hide automated traffic inside usage, and
+    that is not a thing to leave resting on nobody having added the field yet."""
+    monkeypatch.setenv("CODEBOARDING_SOURCE", "evals")
+
+    client.service.capture("repo_scanned", {"source": "oss", "internal": False})
+
+    props = client.captures[0]["properties"]
+    assert props["source"] == "evals"
+    assert props["internal"] is True
+
+
+def test_ci_runs_report_the_repository_owner(client, monkeypatch):
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.setenv("GITHUB_REPOSITORY", "Acme-Corp/widgets")
+
+    client.service.capture("analysis_started", {})
+
+    assert client.captures[0]["properties"]["org"] == "acme-corp"
+
+
+def test_the_same_owner_always_reads_the_same_way(client, monkeypatch):
+    """The owner is the join key across surfaces and across runs, so casing and
+    the two ways of naming one have to agree on a single value."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.setenv("GITHUB_REPOSITORY", "Acme/widgets")
+    client.service.capture("analysis_started", {})
+
+    monkeypatch.delenv("GITHUB_REPOSITORY", raising=False)
+    monkeypatch.setenv("CODEBOARDING_ORG", "acme")
+    client.service.capture("analysis_started", {})
+
+    assert client.captures[0]["properties"]["org"] == client.captures[1]["properties"]["org"]
+
+
+def test_only_the_owner_is_taken_from_the_repository_slug(client, monkeypatch):
+    """Why: the name is the half that says something about the code."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.setenv("GITHUB_REPOSITORY", "acme/secret-prototype")
+
+    client.service.capture("analysis_started", {})
+
+    props = client.captures[0]["properties"]
+    assert props["org"] == "acme"
+    assert "secret-prototype" not in str(props)
+
+
+def test_an_embedding_can_name_the_owner_itself(client, monkeypatch):
+    """The VSCode extension resolves the owner from the workspace's git remote
+    and sets ``CODEBOARDING_ORG``, which has to win: a run driven by the editor
+    inside a CI-like environment belongs to the workspace, not the runner."""
+    monkeypatch.setenv("CODEBOARDING_ORG", "Acme")
+    monkeypatch.setenv("GITHUB_REPOSITORY", "someone-else/runner")
+
+    client.service.capture("analysis_started", {})
+
+    assert client.captures[0]["properties"]["org"] == "acme"
+
+
+def test_a_local_run_reports_no_owner_at_all(client, monkeypatch):
+    """Nothing infers an owner. With neither variable set the key is absent
+    rather than empty, so a query can tell "no owner" from "owner is blank"."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.delenv("GITHUB_REPOSITORY", raising=False)
+
+    client.service.capture("analysis_started", {})
+
+    assert "org" not in client.captures[0]["properties"]
+
+
+def test_a_caller_property_never_overwrites_the_owner(client, monkeypatch):
+    """``org`` merges with the rest of the origin, after the payload, for the
+    same reason ``internal`` does: it is a property of the process."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.setenv("GITHUB_REPOSITORY", "acme/widgets")
+
+    client.service.capture("repo_scanned", {"org": "somebody-else"})
+
+    assert client.captures[0]["properties"]["org"] == "acme"
+
+
+def test_a_caller_cannot_supply_an_owner_when_there_is_none(client, monkeypatch):
+    """Merging the origin last stops a payload *overwriting* an owner, but not
+    inventing one: with no owner resolved the key is absent, so a caller's value
+    would have survived into it and attributed the run to an account it has
+    nothing to do with. The reserved keys come off the payload first."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.delenv("GITHUB_REPOSITORY", raising=False)
+
+    client.service.capture("repo_scanned", {"org": "somebody-else", "total_loc": 10})
+
+    props = client.captures[0]["properties"]
+    assert "org" not in props
+    assert props["total_loc"] == 10
+
+
+def test_a_caller_cannot_supply_an_owner_on_exceptions_either(client, monkeypatch):
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.delenv("GITHUB_REPOSITORY", raising=False)
+
+    client.service.capture_exception(RuntimeError("boom"), properties={"org": "somebody-else"})
+
+    _, kwargs = client.exceptions[0]
+    assert "org" not in kwargs["properties"]
+
+
+def test_the_owner_travels_on_exceptions_too(client, monkeypatch):
+    """Why: exceptions take a different code path, and error-rate dashboards are
+    where knowing whether one deployment or all of them is hitting a bug pays."""
+    monkeypatch.delenv("CODEBOARDING_ORG", raising=False)
+    monkeypatch.setenv("GITHUB_REPOSITORY", "acme/widgets")
+
+    client.service.capture_exception(RuntimeError("boom"), properties={"command": "run_full"})
+
+    _, kwargs = client.exceptions[0]
+    assert kwargs["properties"]["org"] == "acme"

codeboarding-0.14.1/telemetry/__init__.py

@@ -1,10 +0,0 @@
-"""Anonymous, opt-out usage telemetry.
-
-One singleton (``telemetry``) sends anonymous events to PostHog. Disabled with
-``CODEBOARDING_TELEMETRY=false`` (or ``DO_NOT_TRACK=1``). No repo content, paths,
-or API keys are ever sent. See ``service.py`` for the identity rules.
-"""
-
-from telemetry.service import ProductTelemetry, telemetry
-
-__all__ = ["ProductTelemetry", "telemetry"]

codeboarding-0.14.1/tests/test_telemetry_service.py

@@ -1,99 +0,0 @@
-"""What every event carries about who produced it.
-
-``source`` has always said which invoker a run came from. What it could not say
-is whether that invoker is a *person using the product*: a dashboard measuring
-usage had to spell out ``source not in ('tests', 'evals')`` and was silently
-wrong from the moment another internal source was added. ``internal`` is derived
-from the source in one place so that filter is one condition and stays correct.
-
-These exercise ``ProductTelemetry`` itself rather than ``telemetry.events``,
-which stubs ``capture`` out — the stamping happens below that stub, so it is
-invisible to every test in ``test_telemetry_events.py``.
-"""
-
-from types import SimpleNamespace
-
-import pytest
-
-from telemetry.service import INTERNAL_SOURCES, ProductTelemetry
-
-
-@pytest.fixture
-def client(monkeypatch):
-    """A recorder in place of the PostHog SDK, on the live singleton."""
-    seen = SimpleNamespace(captures=[], exceptions=[])
-    service = ProductTelemetry()
-    monkeypatch.setattr(
-        service,
-        "_client",
-        SimpleNamespace(
-            capture=lambda **kw: seen.captures.append(kw),
-            capture_exception=lambda exc, **kw: seen.exceptions.append((exc, kw)),
-            flush=lambda: None,
-        ),
-    )
-    seen.service = service
-    return seen
-
-
-def test_a_product_run_is_not_marked_internal(client, monkeypatch):
-    monkeypatch.setenv("CODEBOARDING_SOURCE", "oss")
-
-    client.service.capture("analysis_started", {"command": "run_full"})
-
-    props = client.captures[0]["properties"]
-    assert props["source"] == "oss"
-    assert props["internal"] is False
-
-
-@pytest.mark.parametrize("source", sorted(INTERNAL_SOURCES))
-def test_every_internal_source_is_marked_internal(client, monkeypatch, source):
-    """The benchmark harness sets ``evals``; the engine's own suite sets ``tests``.
-    Neither is a person using the product, and neither may be counted as one."""
-    monkeypatch.setenv("CODEBOARDING_SOURCE", source)
-
-    client.service.capture("analysis_completed", {"status": "success"})
-
-    props = client.captures[0]["properties"]
-    assert props["source"] == source
-    assert props["internal"] is True
-
-
-def test_an_unknown_source_defaults_to_product_traffic(client, monkeypatch):
-    """A source nobody declared is an embedding of the library, which IS usage.
-    Defaulting the other way would quietly drop a real integration's runs."""
-    monkeypatch.setenv("CODEBOARDING_SOURCE", "some-new-wrapper")
-
-    client.service.capture("analysis_started", {})
-
-    assert client.captures[0]["properties"]["internal"] is False
-
-
-def test_the_origin_travels_on_exceptions_too(client, monkeypatch):
-    """``$exception`` is an event like any other, and error-rate dashboards are
-    exactly where a run of the benchmark's deliberate failure cases would hurt."""
-    monkeypatch.setenv("CODEBOARDING_SOURCE", "evals")
-    exc = RuntimeError("boom")
-
-    client.service.capture_exception(exc, properties={"command": "run_incremental"})
-
-    _, kwargs = client.exceptions[0]
-    assert kwargs["properties"]["internal"] is True
-    assert kwargs["properties"]["command"] == "run_incremental"
-
-
-def test_a_caller_property_never_overwrites_the_origin(client, monkeypatch):
-    """The origin merges LAST, so a caller cannot claim it.
-
-    It used to go first, which left an event model free to overwrite `source`
-    simply by having a field of that name. No schema does today — but `internal`
-    is the one property a product metric filters on, so a payload that could
-    overwrite it is a payload that could hide automated traffic inside usage, and
-    that is not a thing to leave resting on nobody having added the field yet."""
-    monkeypatch.setenv("CODEBOARDING_SOURCE", "evals")
-
-    client.service.capture("repo_scanned", {"source": "oss", "internal": False})
-
-    props = client.captures[0]["properties"]
-    assert props["source"] == "evals"
-    assert props["internal"] is True