metergraph 0.3.2__tar.gz → 0.4.0__tar.gz

{metergraph-0.3.2 → metergraph-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.3.2
+Version: 0.4.0
 Summary: Fire-and-forget LLM spend capture for Metergraph
 Author: Pioneer Square Labs
 License-Expression: Apache-2.0
@@ -85,10 +85,18 @@ Configuration:
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
+SDK 0.4 associates traces with their GitHub repository automatically. On the
+first `init()` in a Git checkout, it reads the `origin` remote and creates
+`.metergraph/config.json` at the repository root if that file is absent.
+Commit this non-secret file so production can use repository-aware ingest
+without Git metadata. An existing file is authoritative and is never changed
+by the SDK. If discovery or creation is unavailable, ingest remains compatible
+with protocol v1.
+
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
 provider call. Each wire batch is bounded to 512 KiB after optional gzip.
-SDK 0.3 captures the scrubbed provider request and a normalized response
+SDK 0.4 captures the scrubbed provider request and a normalized response
 envelope, including assistant content and tool calls, by default. Provider
 credentials and transport headers are removed. Request and response are each
 limited to 100 KiB of UTF-8 with an explicit truncation marker.
@@ -133,7 +141,7 @@ and AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN configuration unchanged.
 wrap() returns the same client and initializes itself from the environment:
 METERGRAPH_APP_TOKEN is required (capture is silently off without it) and
 METERGRAPH_INGEST_URL is only for self-hosted servers. Add both to
-.env.example, and never commit a real token. SDK 0.3 captures scrubbed provider
+.env.example, and never commit a real token. SDK 0.4 captures scrubbed provider
 requests and normalized responses by default for the hosted dashboard; use
 METERGRAPH_CAPTURE_TEXT=0 or capture_text=False around sensitive operations.
 Provider credentials and transport headers must never be captured. Capture is

{metergraph-0.3.2 → metergraph-0.4.0}/README.md

@@ -64,10 +64,18 @@ Configuration:
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
+SDK 0.4 associates traces with their GitHub repository automatically. On the
+first `init()` in a Git checkout, it reads the `origin` remote and creates
+`.metergraph/config.json` at the repository root if that file is absent.
+Commit this non-secret file so production can use repository-aware ingest
+without Git metadata. An existing file is authoritative and is never changed
+by the SDK. If discovery or creation is unavailable, ingest remains compatible
+with protocol v1.
+
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
 provider call. Each wire batch is bounded to 512 KiB after optional gzip.
-SDK 0.3 captures the scrubbed provider request and a normalized response
+SDK 0.4 captures the scrubbed provider request and a normalized response
 envelope, including assistant content and tool calls, by default. Provider
 credentials and transport headers are removed. Request and response are each
 limited to 100 KiB of UTF-8 with an explicit truncation marker.
@@ -112,7 +120,7 @@ and AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN configuration unchanged.
 wrap() returns the same client and initializes itself from the environment:
 METERGRAPH_APP_TOKEN is required (capture is silently off without it) and
 METERGRAPH_INGEST_URL is only for self-hosted servers. Add both to
-.env.example, and never commit a real token. SDK 0.3 captures scrubbed provider
+.env.example, and never commit a real token. SDK 0.4 captures scrubbed provider
 requests and normalized responses by default for the hosted dashboard; use
 METERGRAPH_CAPTURE_TEXT=0 or capture_text=False around sensitive operations.
 Provider credentials and transport headers must never be captured. Capture is

{metergraph-0.3.2 → metergraph-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metergraph"
-version = "0.3.2"
+version = "0.4.0"
 description = "Fire-and-forget LLM spend capture for Metergraph"
 readme = "README.md"
 requires-python = ">=3.10"

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph/__init__.py

@@ -14,6 +14,8 @@ from ._capture import Options, Runtime, set_runtime
 from ._capture import wrap as _wrap
 from ._config import ConfigPoller
 from ._context import route, set_session, set_tags, snapshot, trace, wrap_executor
+from ._repo_config import ensure_repo_config
+from ._session import SessionManager
 from ._track import track
 from ._transport import Writer
 from ._version import SDK_VERSION
@@ -24,6 +26,7 @@ DEFAULT_INGEST_URL = "https://d2xus7mp8zdv6t.cloudfront.net"
 log = logging.getLogger("metergraph")
 _writer: Writer | None = None
 _config: ConfigPoller | None = None
+_session_manager: SessionManager | None = None
 _initialized = False
 _warned_no_token = False
 
@@ -47,7 +50,7 @@ def init(
     disabled: bool | None = None,
 ) -> None:
     """Initialize capture. This function is idempotent and never raises."""
-    global _initialized, _warned_no_token, _writer, _config
+    global _initialized, _warned_no_token, _writer, _config, _session_manager
     if _initialized:
         return
     if os.getenv("METERGRAPH_DISABLED") == "1" or disabled:
@@ -65,9 +68,23 @@ def init(
         return
     _initialized = True
     try:
+        app_root_resolved = os.path.realpath(app_root or os.getcwd())
+        repo_config = ensure_repo_config(app_root_resolved)
+        session = (
+            SessionManager(
+                token,
+                ingest_url,
+                repository=repo_config.repository,
+                sdk_version=SDK_VERSION,
+            )
+            if repo_config is not None
+            else None
+        )
+        _session_manager = session
         _writer = Writer(
             token,
             ingest_url,
+            session=session,
             queue_size=int(os.getenv("METERGRAPH_QUEUE_SIZE", "2000")),
             batch_size=int(os.getenv("METERGRAPH_BATCH_SIZE", "100")),
             flush_seconds=float(os.getenv("METERGRAPH_FLUSH_SECONDS", "5")),
@@ -79,7 +96,8 @@ def init(
                 else capture_text
             ),
             redact=redact,
-            app_root=os.path.realpath(app_root or os.getcwd()),
+            app_root=app_root_resolved,
+            repo_root=repo_config.repo_root if repo_config is not None else None,
             skip_frames=tuple(skip_frames or ()),
             environment=environment or os.getenv("METERGRAPH_ENV"),
             text_max_bytes=min(
@@ -110,6 +128,7 @@ def init(
             _writer.shutdown()
         _writer = None
         _config = None
+        _session_manager = None
         log.warning(
             "Metergraph initialization failed; application is running uninstrumented"
         )
@@ -214,13 +233,16 @@ def flush(timeout: float = 3.0) -> bool:
 
 
 def shutdown() -> None:
-    global _writer, _config
+    global _writer, _config, _session_manager
     if _config:
         _config.stop()
         _config = None
     if _writer:
         _writer.shutdown()
         _writer = None
+    if _session_manager:
+        _session_manager.stop()
+        _session_manager = None
     set_runtime(None)
 
 

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph/_capture.py

@@ -556,10 +556,11 @@ def _tool_events(
 
 
 def _capture_frames(
-    app_root: str, skip_frames: tuple[str, ...]
+    app_root: str, skip_frames: tuple[str, ...], repo_root: str | None = None
 ) -> tuple[str | None, str | None, list[dict]]:
     frames: list[dict] = []
     root = os.path.realpath(app_root)
+    repo_root_real = os.path.realpath(repo_root) if repo_root else None
     frame = sys._getframe(2)
     while frame is not None and len(frames) < 5:
         filename = os.path.realpath(frame.f_code.co_filename)
@@ -569,7 +570,19 @@ def _capture_frames(
             relative = os.path.relpath(filename, root)
             module = str(Path(relative).with_suffix("")).replace(os.sep, ".")
             qualname = getattr(frame.f_code, "co_qualname", frame.f_code.co_name)
-            frames.append({"m": module, "f": qualname, "l": frame.f_lineno})
+            entry = {"m": module, "f": qualname, "l": frame.f_lineno}
+            try:
+                inside_repo = bool(
+                    repo_root_real
+                    and os.path.commonpath((filename, repo_root_real)) == repo_root_real
+                )
+            except ValueError:
+                inside_repo = False
+            if inside_repo:
+                entry["p"] = os.path.relpath(filename, repo_root_real).replace(
+                    os.sep, "/"
+                )
+            frames.append(entry)
         frame = frame.f_back
     if not frames:
         return None, None, []
@@ -581,6 +594,7 @@ class Options:
     capture_text: bool = True
     redact: Callable[[str, str], str] | None = None
     app_root: str = os.getcwd()
+    repo_root: str | None = None
     skip_frames: tuple[str, ...] = ()
     environment: str | None = None
     text_max_bytes: int = 100 * 1024
@@ -609,6 +623,7 @@ class Runtime:
                 "threading.py",
                 *self.options.skip_frames,
             ),
+            self.options.repo_root,
         )
         return CallState(
             runtime=self,

metergraph-0.4.0/src/metergraph/_repo_config.py

@@ -0,0 +1,165 @@
+"""Repository-aware ingest protocol v2: discover, detect, and write
+.metergraph/config.json.
+
+Discovery is purely file-based (never shells out to git), so a committed
+config is honored in production without needing a .git directory at all.
+Detection + write only ever runs when discovery finds nothing: it shells out
+to git to find the repo's top level and GitHub origin, then writes the config
+there exactly once. An existing file is always authoritative and is never
+overwritten. Every failure mode here is fail-open -- callers get None and
+fall back to legacy protocol v1, never an exception.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+
+
+log = logging.getLogger("metergraph")
+
+CONFIG_DIRNAME = ".metergraph"
+CONFIG_FILENAME = "config.json"
+SUPPORTED_CONFIG_VERSION = 2
+_MAX_WALK_UP = 64
+_GIT_TIMEOUT_SECONDS = 5
+
+_REMOTE_PATTERNS = (
+    re.compile(r"^git@github\.com:(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
+    re.compile(r"^https://github\.com/(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
+    re.compile(r"^ssh://git@github\.com/(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
+)
+
+
+@dataclass(frozen=True)
+class RepoConfig:
+    repository: str
+    repo_root: str
+
+
+def normalize_github_remote(url: str) -> str | None:
+    """Return 'owner/repo' from a GitHub SSH or HTTPS remote URL, or None
+    if the URL isn't a recognized GitHub origin."""
+    trimmed = url.strip()
+    for pattern in _REMOTE_PATTERNS:
+        match = pattern.match(trimmed)
+        if match:
+            return match.group("path")
+    return None
+
+
+def discover_repo_config(app_root: str) -> RepoConfig | None:
+    """Walk upward from app_root looking for .metergraph/config.json.
+
+    Returns None -- silently, this is the normal v1 state -- when nothing is
+    found. Logs a warning (but still returns None) if a config file exists
+    but fails to parse or carries an unsupported schema version.
+    """
+    current = os.path.realpath(app_root)
+    for _ in range(_MAX_WALK_UP):
+        candidate = os.path.join(current, CONFIG_DIRNAME, CONFIG_FILENAME)
+        if os.path.isfile(candidate):
+            return _load(candidate, current)
+        parent = os.path.dirname(current)
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def _load(path: str, repo_root: str) -> RepoConfig | None:
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            doc = json.load(handle)
+    except (OSError, json.JSONDecodeError) as exc:
+        log.warning("metergraph: found %s but could not read it: %s", path, exc)
+        return None
+    if not isinstance(doc, dict) or doc.get("version") != SUPPORTED_CONFIG_VERSION:
+        log.warning(
+            "metergraph: %s has an unsupported schema version; ignoring "
+            "(expected version %d)",
+            path,
+            SUPPORTED_CONFIG_VERSION,
+        )
+        return None
+    repository = doc.get("repository")
+    if not isinstance(repository, str) or "/" not in repository:
+        log.warning("metergraph: %s is missing a valid 'repository' field; ignoring", path)
+        return None
+    return RepoConfig(repository=repository, repo_root=repo_root)
+
+
+def _run_git(args: list[str], cwd: str) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=_GIT_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    output = result.stdout.strip()
+    return output or None
+
+
+def _git_top_level(app_root: str) -> str | None:
+    top = _run_git(["rev-parse", "--show-toplevel"], app_root)
+    return os.path.realpath(top) if top else None
+
+
+def _git_origin_url(repo_root: str) -> str | None:
+    return _run_git(["remote", "get-url", "origin"], repo_root)
+
+
+def _write_config_atomically(repo_root: str, repository: str) -> RepoConfig | None:
+    """Create .metergraph/config.json if -- and only if -- it doesn't
+    already exist. Uses O_CREAT|O_EXCL for an atomic create-only-if-absent;
+    a concurrent writer (or a file that appeared between discovery and this
+    call) always wins over us, and we simply read back whatever is there."""
+    config_dir = os.path.join(repo_root, CONFIG_DIRNAME)
+    config_path = os.path.join(config_dir, CONFIG_FILENAME)
+    payload = json.dumps({"version": SUPPORTED_CONFIG_VERSION, "repository": repository}) + "\n"
+    try:
+        os.makedirs(config_dir, exist_ok=True)
+        fd = os.open(config_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+        try:
+            os.write(fd, payload.encode("utf-8"))
+        finally:
+            os.close(fd)
+    except FileExistsError:
+        pass
+    except OSError as exc:
+        log.warning("metergraph: could not write %s: %s", config_path, exc)
+        return None
+    return _load(config_path, repo_root)
+
+
+def ensure_repo_config(app_root: str) -> RepoConfig | None:
+    """Discover an existing repo config, or detect+write one once at the
+    git top level. Fail-open: any detection or write failure returns None
+    (legacy protocol v1), never raises."""
+    existing = discover_repo_config(app_root)
+    if existing is not None:
+        return existing
+    try:
+        repo_root = _git_top_level(app_root)
+        if repo_root is None:
+            return None
+        origin = _git_origin_url(repo_root)
+        if origin is None:
+            return None
+        repository = normalize_github_remote(origin)
+        if repository is None:
+            return None
+        return _write_config_atomically(repo_root, repository)
+    except Exception as exc:
+        log.debug("metergraph: repo config detection failed: %s", exc)
+        return None

metergraph-0.4.0/src/metergraph/_session.py

@@ -0,0 +1,156 @@
+"""Repository-aware ingest protocol v2: app-token -> session-token exchange.
+
+The app token is sent only on POST /v1/ingest/sessions. The resulting
+session token is cached in memory and reused until it's within
+REFRESH_MARGIN_SECONDS of expiry, at which point the next get_token() call
+transparently re-exchanges it. Exchanges happen lazily on the writer's own
+background delivery thread (never on the caller's request path), so a
+blocking round trip here adds no latency to the customer's LLM call. Every
+failure mode is fail-open: get_token() returns None and callers drop/buffer
+that batch rather than ever sending the app token to /v1/ingest.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from typing import Any
+
+from ._failure_log import FailureLogger
+
+
+DEFAULT_TIMEOUT_SECONDS = 3.0
+DEFAULT_TTL_SECONDS = 300.0
+REFRESH_MARGIN_SECONDS = 30.0
+MAX_BACKOFF_SECONDS = 60.0
+
+
+def _parse_expires_at(value: Any) -> float | None:
+    if not isinstance(value, str):
+        return None
+    text = value[:-1] + "+00:00" if value.endswith("Z") else value
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.timestamp()
+
+
+class SessionManager:
+    def __init__(
+        self,
+        app_token: str,
+        base_url: str,
+        *,
+        repository: str,
+        sdk_version: str,
+        timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    ) -> None:
+        self._app_token = app_token
+        self._url = f"{base_url.rstrip('/')}/v1/ingest/sessions"
+        self._repository = repository
+        self._sdk_version = sdk_version
+        self._timeout = max(0.1, timeout_seconds)
+        self._lock = threading.Lock()
+        self._token: str | None = None
+        self._expires_at = 0.0
+        self._stopped = False
+        self._retry_at = 0.0
+        self._backoff = 1.0
+        self._failure_log = FailureLogger()
+        if hasattr(os, "register_at_fork"):
+            os.register_at_fork(after_in_child=self._after_fork)
+
+    def _after_fork(self) -> None:
+        # A lock held by another thread at fork stays locked forever in the
+        # child. The cached token itself is safe to reuse; only reset the lock.
+        self._lock = threading.Lock()
+
+    def get_token(self) -> str | None:
+        with self._lock:
+            if self._stopped:
+                return None
+            if self._token is not None and time.time() < self._expires_at - REFRESH_MARGIN_SECONDS:
+                return self._token
+            if time.monotonic() < self._retry_at:
+                return None
+        self._exchange()
+        with self._lock:
+            return None if self._stopped else self._token
+
+    def invalidate(self) -> None:
+        with self._lock:
+            self._token = None
+            self._expires_at = 0.0
+            self._retry_at = 0.0
+            self._backoff = 1.0
+
+    def stop(self) -> None:
+        with self._lock:
+            self._stopped = True
+            self._token = None
+            self._expires_at = 0.0
+
+    def _exchange(self) -> None:
+        body = json.dumps(
+            {
+                "protocol_version": 2,
+                "repository": self._repository,
+                "sdk_version": self._sdk_version,
+            }
+        ).encode()
+        request = urllib.request.Request(
+            self._url,
+            data=body,
+            headers={
+                "Authorization": f"Bearer {self._app_token}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                doc = json.loads(response.read())
+        except urllib.error.HTTPError as exc:
+            self._failure_log.report(
+                "session_exchange_error",
+                f"session exchange to {self._url} failed with HTTP {exc.code}",
+            )
+            self._mark_failed()
+            return
+        except Exception as exc:
+            self._failure_log.report(
+                "session_exchange_error",
+                f"session exchange to {self._url} failed: {type(exc).__name__}: {exc}",
+            )
+            self._mark_failed()
+            return
+        token = doc.get("session_token") if isinstance(doc, dict) else None
+        if not isinstance(token, str) or not token:
+            self._failure_log.report(
+                "session_exchange_error",
+                f"session exchange to {self._url} returned no session_token",
+            )
+            self._mark_failed()
+            return
+        expires_at = _parse_expires_at(doc.get("expires_at")) or (
+            time.time() + DEFAULT_TTL_SECONDS
+        )
+        with self._lock:
+            if not self._stopped:
+                self._token = token
+                self._expires_at = expires_at
+                self._retry_at = 0.0
+                self._backoff = 1.0
+
+    def _mark_failed(self) -> None:
+        with self._lock:
+            self._retry_at = time.monotonic() + self._backoff
+            self._backoff = min(self._backoff * 2, MAX_BACKOFF_SECONDS)

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph/_transport.py

@@ -27,11 +27,13 @@ class Writer:
         token: str,
         base_url: str,
         *,
+        session: Any | None = None,
         queue_size: int = 2000,
         batch_size: int = 100,
         flush_seconds: float = 5.0,
     ) -> None:
         self._token = token
+        self._session = session
         self._url = f"{base_url.rstrip('/')}/v1/ingest"
         self._queue_size = max(1, queue_size)
         self._batch_size = max(1, min(batch_size, 1000))
@@ -109,13 +111,17 @@ class Writer:
         if self._fatal or time.monotonic() < self._retry_at:
             self._dropped += len(rows)
             return False
+        token = self._session.get_token() if self._session is not None else self._token
+        if token is None:
+            self._dropped += len(rows)
+            return False
         meta = {"dropped": self._dropped, "transport_errors": self._errors}
         body = json.dumps(
             {"schema_version": 1, "rows": rows, "meta": meta},
             separators=(",", ":"),
         ).encode()
         headers = {
-            "Authorization": f"Bearer {self._token}",
+            "Authorization": f"Bearer {token}",
             "Content-Type": "application/json",
             "User-Agent": f"metergraph-python/{SDK_VERSION}",
         }
@@ -142,6 +148,10 @@ class Writer:
             return True
         except urllib.error.HTTPError as exc:
             if exc.code in (401, 403):
+                if self._session is not None:
+                    self._session.invalidate()
+                    self._dropped += len(rows)
+                    return False
                 self._fatal = True
                 log.warning(
                     "Metergraph authentication failed; capture disabled for this process"

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph/_version.py

@@ -8,4 +8,4 @@ import importlib.metadata
 try:
     SDK_VERSION = importlib.metadata.version("metergraph")
 except Exception:
-    SDK_VERSION = "0.3.2"
+    SDK_VERSION = "0.4.0"

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.3.2
+Version: 0.4.0
 Summary: Fire-and-forget LLM spend capture for Metergraph
 Author: Pioneer Square Labs
 License-Expression: Apache-2.0
@@ -85,10 +85,18 @@ Configuration:
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
+SDK 0.4 associates traces with their GitHub repository automatically. On the
+first `init()` in a Git checkout, it reads the `origin` remote and creates
+`.metergraph/config.json` at the repository root if that file is absent.
+Commit this non-secret file so production can use repository-aware ingest
+without Git metadata. An existing file is authoritative and is never changed
+by the SDK. If discovery or creation is unavailable, ingest remains compatible
+with protocol v1.
+
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
 provider call. Each wire batch is bounded to 512 KiB after optional gzip.
-SDK 0.3 captures the scrubbed provider request and a normalized response
+SDK 0.4 captures the scrubbed provider request and a normalized response
 envelope, including assistant content and tool calls, by default. Provider
 credentials and transport headers are removed. Request and response are each
 limited to 100 KiB of UTF-8 with an explicit truncation marker.
@@ -133,7 +141,7 @@ and AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN configuration unchanged.
 wrap() returns the same client and initializes itself from the environment:
 METERGRAPH_APP_TOKEN is required (capture is silently off without it) and
 METERGRAPH_INGEST_URL is only for self-hosted servers. Add both to
-.env.example, and never commit a real token. SDK 0.3 captures scrubbed provider
+.env.example, and never commit a real token. SDK 0.4 captures scrubbed provider
 requests and normalized responses by default for the hosted dashboard; use
 METERGRAPH_CAPTURE_TEXT=0 or capture_text=False around sensitive operations.
 Provider credentials and transport headers must never be captured. Capture is

{metergraph-0.3.2 → metergraph-0.4.0}/src/metergraph.egg-info/SOURCES.txt

@@ -5,6 +5,8 @@ src/metergraph/_capture.py
 src/metergraph/_config.py
 src/metergraph/_context.py
 src/metergraph/_failure_log.py
+src/metergraph/_repo_config.py
+src/metergraph/_session.py
 src/metergraph/_template.py
 src/metergraph/_track.py
 src/metergraph/_transport.py
@@ -14,7 +16,12 @@ src/metergraph.egg-info/SOURCES.txt
 src/metergraph.egg-info/dependency_links.txt
 src/metergraph.egg-info/requires.txt
 src/metergraph.egg-info/top_level.txt
+tests/test_capture_repo_root.py
 tests/test_edge_cases.py
+tests/test_init_repo_aware.py
 tests/test_real_client_integration.py
+tests/test_repository_aware_ingest.py
 tests/test_sdk.py
-tests/test_seam_reality.py
+tests/test_seam_reality.py
+tests/test_session_manager.py
+tests/test_writer_session.py