metergraph 0.2.0__tar.gz → 0.2.1__tar.gz

{metergraph-0.2.0 → metergraph-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.2.0
+Version: 0.2.1
 Summary: Fire-and-forget LLM spend capture for Metergraph
 Author: Pioneer Square Labs
 License-Expression: Apache-2.0
@@ -15,6 +15,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: openai>=2.50.0; extra == "dev"
+Requires-Dist: anthropic>=0.40; extra == "dev"
+Requires-Dist: google-genai>=1; extra == "dev"
 
 # metergraph (Python)
 

{metergraph-0.2.0 → metergraph-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metergraph"
-version = "0.2.0"
+version = "0.2.1"
 description = "Fire-and-forget LLM spend capture for Metergraph"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,7 +20,7 @@ Repository = "https://github.com/PioneerSquareLabs/metergraphsdk"
 Issues = "https://github.com/PioneerSquareLabs/metergraphsdk/issues"
 
 [project.optional-dependencies]
-dev = ["pytest>=8"]
+dev = ["pytest>=8", "openai>=2.50.0", "anthropic>=0.40", "google-genai>=1"]
 
 [build-system]
 requires = ["setuptools>=68"]

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph/_capture.py

@@ -1082,61 +1082,85 @@ def _finish_or_stream(
     return result
 
 
-def wrap(client: Any, *, provider: str | None = None) -> Any:
-    """Patch supported resource methods on an OpenAI, Anthropic, or Google client."""
-    if provider is None:
-        if hasattr(getattr(client, "models", None), "generate_content"):
-            provider = "google"
-        elif hasattr(client, "chat") or hasattr(client, "responses"):
-            provider = "openai"
-        else:
-            provider = "anthropic"
-    seams: list[tuple[Any, str, str]] = []
-    if provider == "google":
-        for models in (
-            getattr(client, "models", None),
-            getattr(getattr(client, "aio", None), "models", None),
-        ):
-            if models is not None:
-                seams.extend(
-                    (
-                        (models, "generate_content", "models.generate_content"),
-                        (
-                            models,
-                            "generate_content_stream",
-                            "models.generate_content.stream",
-                        ),
-                    )
-                )
-    chat = getattr(getattr(client, "chat", None), "completions", None)
-    if chat is not None:
-        seams.append((chat, "create", "chat.completions"))
-        seams.append((chat, "parse", "chat.completions.parse"))
-    beta_chat = getattr(getattr(getattr(client, "beta", None), "chat", None), "completions", None)
-    if beta_chat is not None:
-        seams.append((beta_chat, "parse", "chat.completions.parse"))
-    responses = getattr(client, "responses", None)
-    if responses is not None:
-        seams.extend(
-            (
-                (responses, "create", "responses"),
-                (responses, "stream", "responses.stream"),
-            )
-        )
-    messages = getattr(client, "messages", None)
-    if messages is not None:
-        seams.extend(
-            ((messages, "create", "messages"), (messages, "stream", "messages.stream"))
-        )
-    patched = sum(
-        _patch(owner, method, provider, endpoint) for owner, method, endpoint in seams
-    )
+@dataclass(frozen=True)
+class Seam:
+    """A single instrumentable method, addressed by a dotted attribute path
+    from the client root (e.g. "beta.chat.completions")."""
+
+    path: str
+    method: str
+    endpoint: str
+
+
+OPENAI_SEAMS: tuple[Seam, ...] = (
+    Seam("chat.completions", "create", "chat.completions"),
+    Seam("chat.completions", "parse", "chat.completions.parse"),
+    Seam("beta.chat.completions", "parse", "chat.completions.parse"),
+    Seam("responses", "create", "responses"),
+    Seam("responses", "stream", "responses.stream"),
+    Seam("responses", "parse", "responses.parse"),
+    Seam("beta.responses", "create", "responses"),
+    # Note: client.beta.responses has no .parse method (verified against
+    # openai==2.50.0) — do not add one here without re-verifying first.
+)
+
+ANTHROPIC_SEAMS: tuple[Seam, ...] = (
+    Seam("messages", "create", "messages"),
+    Seam("messages", "stream", "messages.stream"),
+)
+
+GOOGLE_SEAMS: tuple[Seam, ...] = (
+    Seam("models", "generate_content", "models.generate_content"),
+    Seam("models", "generate_content_stream", "models.generate_content.stream"),
+    Seam("aio.models", "generate_content", "models.generate_content"),
+    Seam("aio.models", "generate_content_stream", "models.generate_content.stream"),
+)
+
+SEAM_TABLES: dict[str, tuple[Seam, ...]] = {
+    "openai": OPENAI_SEAMS,
+    "anthropic": ANTHROPIC_SEAMS,
+    "google": GOOGLE_SEAMS,
+}
+
+
+def _detect_provider(client: Any) -> str:
+    if hasattr(getattr(client, "models", None), "generate_content"):
+        return "google"
+    if hasattr(client, "chat") or hasattr(client, "responses"):
+        return "openai"
+    return "anthropic"
+
+
+def _resolve(client: Any, path: str) -> Any:
+    obj = client
+    for part in path.split("."):
+        obj = getattr(obj, part, None)
+        if obj is None:
+            return None
+    return obj
+
+
+def _apply_seams(client: Any, provider: str) -> list[str]:
+    patched: list[str] = []
+    for seam in SEAM_TABLES.get(provider, ()):
+        try:
+            owner = _resolve(client, seam.path)
+        except Exception:
+            continue  # a pathological client property must never break wrap()
+        if owner is not None and _patch(owner, seam.method, provider, seam.endpoint):
+            patched.append(f"{seam.path}.{seam.method}")
+    return patched
+
+
+def _apply_batch_extras(client: Any, provider: str) -> int:
+    patched = 0
     if provider == "openai":
         files = getattr(client, "files", None)
         if files is not None:
             patched += int(_patch_openai_batch_content(files, "content"))
             patched += int(_patch_openai_batch_content(files, "retrieve_content"))
     elif provider == "anthropic":
+        messages = getattr(client, "messages", None)
         batch_owners = [getattr(messages, "batches", None)]
         beta_messages = getattr(getattr(client, "beta", None), "messages", None)
         batch_owners.append(getattr(beta_messages, "batches", None))
@@ -1145,6 +1169,33 @@ def wrap(client: Any, *, provider: str | None = None) -> Any:
             for owner in batch_owners
             if owner is not None
         )
-    if not patched:
-        log.warning("Metergraph found no supported methods on %s client", provider)
+    return patched
+
+
+def wrap(client: Any, *, provider: str | None = None) -> Any:
+    """Patch supported resource methods on an OpenAI, Anthropic, or Google client.
+
+    Never raises: an unrecognized client shape, or an exception while probing
+    it, results in an unmodified, uninstrumented client — not a crash.
+    """
+    try:
+        resolved_provider = provider or _detect_provider(client)
+        patched = _apply_seams(client, resolved_provider)
+        patched_count = len(patched) + _apply_batch_extras(client, resolved_provider)
+        if not patched_count:
+            log.warning(
+                "Metergraph found no supported methods on %s client", resolved_provider
+            )
+        else:
+            log.info(
+                "Metergraph patched %d seam(s) on %s client: %s",
+                patched_count,
+                resolved_provider,
+                ", ".join(patched) or "(batch-only)",
+            )
+    except Exception:
+        log.warning(
+            "Metergraph wrap() failed; client is unmodified and uninstrumented",
+            exc_info=True,
+        )
     return client

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph/_config.py

@@ -11,6 +11,8 @@ import urllib.request
 from collections.abc import Mapping
 from typing import Any
 
+from ._failure_log import FailureLogger
+
 
 log = logging.getLogger("metergraph")
 
@@ -75,6 +77,7 @@ class ConfigPoller:
         self._routes: dict[str, dict[str, Any]] = {}
         self._last_success = 0.0
         self._lock = threading.Lock()
+        self._failure_log = FailureLogger()
         self._stop = threading.Event()
         self._thread = threading.Thread(
             target=self._run, name="metergraph-config", daemon=True
@@ -124,8 +127,17 @@ class ConfigPoller:
                     "Metergraph config authentication failed; using default models"
                 )
                 self._stop.set()
+                return False
+            self._failure_log.report(
+                "config_poll_error",
+                f"config poll to {self._url} failed with HTTP {exc.code}",
+            )
             return False
-        except Exception:
+        except Exception as exc:
+            self._failure_log.report(
+                "config_poll_error",
+                f"config poll to {self._url} failed: {type(exc).__name__}: {exc}",
+            )
             return False
 
     def model_for(self, route: str, default: str, session_key: str | None) -> str:

metergraph-0.2.1/src/metergraph/_failure_log.py

@@ -0,0 +1,44 @@
+"""Rate-limited failure logging.
+
+Logs the first occurrence of a failure kind immediately, then suppresses
+repeats within a quiet window and reports how many were suppressed on the
+next log line for that kind. Keeps log volume bounded under sustained
+failure without ever going completely silent.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Callable
+
+
+log = logging.getLogger("metergraph")
+
+
+class FailureLogger:
+    def __init__(
+        self,
+        quiet_seconds: float = 60.0,
+        *,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self._quiet_seconds = quiet_seconds
+        self._clock = clock
+        self._last_logged: dict[str, float] = {}
+        self._suppressed: dict[str, int] = {}
+
+    def report(self, kind: str, message: str, level: int = logging.WARNING) -> None:
+        now = self._clock()
+        last = self._last_logged.get(kind)
+        if last is not None and now - last < self._quiet_seconds:
+            self._suppressed[kind] = self._suppressed.get(kind, 0) + 1
+            return
+        suppressed = self._suppressed.pop(kind, 0)
+        suffix = (
+            f" ({suppressed} more suppressed in the last {self._quiet_seconds:.0f}s)"
+            if suppressed
+            else ""
+        )
+        log.log(level, "metergraph: %s%s", message, suffix)
+        self._last_logged[kind] = now

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph/_transport.py

@@ -13,6 +13,7 @@ import urllib.error
 import urllib.request
 from typing import Any
 
+from ._failure_log import FailureLogger
 from ._version import SDK_VERSION
 
 
@@ -43,6 +44,7 @@ class Writer:
         self._errors = 0
         self._backoff = 1.0
         self._retry_at = 0.0
+        self._failure_log = FailureLogger()
         self._thread = self._new_thread()
         self._thread.start()
         if hasattr(os, "register_at_fork"):
@@ -144,11 +146,31 @@ class Writer:
                 log.warning(
                     "Metergraph authentication failed; capture disabled for this process"
                 )
+            elif exc.code == 413 and len(rows) > 1:
+                midpoint = len(rows) // 2
+                left = self._deliver(rows[:midpoint])
+                right = self._deliver(rows[midpoint:])
+                return left and right
+            elif exc.code in (400, 404, 413, 422):
+                self._dropped += len(rows)
+                self._failure_log.report(
+                    "client_error",
+                    f"ingest rejected batch with HTTP {exc.code} against {self._url}; "
+                    "dropping this batch (payload-specific, not a process-wide failure)",
+                )
             else:
                 self._failed(len(rows))
+                self._failure_log.report(
+                    "server_error",
+                    f"ingest request failed with HTTP {exc.code} against {self._url}",
+                )
             return False
-        except Exception:
+        except Exception as exc:
             self._failed(len(rows))
+            self._failure_log.report(
+                "transport_error",
+                f"ingest request to {self._url} failed: {type(exc).__name__}: {exc}",
+            )
             return False
 
     def _failed(self, count: int) -> None:

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph/_version.py

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

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.2.0
+Version: 0.2.1
 Summary: Fire-and-forget LLM spend capture for Metergraph
 Author: Pioneer Square Labs
 License-Expression: Apache-2.0
@@ -15,6 +15,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: openai>=2.50.0; extra == "dev"
+Requires-Dist: anthropic>=0.40; extra == "dev"
+Requires-Dist: google-genai>=1; extra == "dev"
 
 # metergraph (Python)
 

{metergraph-0.2.0 → metergraph-0.2.1}/src/metergraph.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ src/metergraph/__init__.py
 src/metergraph/_capture.py
 src/metergraph/_config.py
 src/metergraph/_context.py
+src/metergraph/_failure_log.py
 src/metergraph/_template.py
 src/metergraph/_track.py
 src/metergraph/_transport.py
@@ -13,4 +14,6 @@ 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_sdk.py
+tests/test_real_client_integration.py
+tests/test_sdk.py
+tests/test_seam_reality.py

metergraph-0.2.1/src/metergraph.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+pytest>=8
+openai>=2.50.0
+anthropic>=0.40
+google-genai>=1

metergraph-0.2.1/tests/test_real_client_integration.py

@@ -0,0 +1,226 @@
+"""Wrap the real, unmodified provider SDK clients and drive a call through
+their actual request-building/response-parsing code — with the network
+replaced by a mocked transport, not the SDK itself.
+
+test_seam_reality.py proves a seam *exists* on the real client. The
+behavioral tests in test_sdk.py prove wrap() *works*, but only against a
+hand-built fake that mimics the real client's shape. Neither proves that
+wrapping the real client and calling a real method actually produces a
+captured row — which is exactly the gap that let the original
+chat.completions.parse capture bug ship unnoticed. These tests close it,
+without needing live API keys or network access.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+
+import httpx
+import metergraph
+from anthropic import AsyncAnthropic
+from google import genai
+from metergraph import _capture
+from metergraph._capture import Options, Runtime
+from openai import AsyncOpenAI
+from pydantic import BaseModel
+
+
+class Rows:
+    def __init__(self):
+        self.rows = []
+
+    def enqueue(self, row):
+        self.rows.append(row)
+        return True
+
+
+class Answer(BaseModel):
+    text: str
+
+
+def test_wrap_captures_openai_parse_through_a_real_client(tmp_path):
+    """.parse() is the exact seam the original production bug missed."""
+    rows = Rows()
+    _capture.set_runtime(Runtime(rows, Options(app_root=str(tmp_path))))
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "id": "chatcmpl-test",
+                "object": "chat.completion",
+                "created": 0,
+                "model": "gpt-4o-mini",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": json.dumps({"text": "hi"}),
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7},
+            },
+        )
+
+    client = AsyncOpenAI(
+        api_key="test",
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+    )
+    metergraph.wrap(client, provider="openai")
+
+    async def run():
+        with metergraph.route("real-client-test"):
+            return await client.chat.completions.parse(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": "hi"}],
+                response_format=Answer,
+            )
+
+    response = asyncio.run(run())
+
+    assert response.choices[0].message.parsed == Answer(text="hi")
+    assert len(rows.rows) == 1
+    row = rows.rows[0]
+    assert row["endpoint"] == "chat.completions.parse"
+    assert row["provider"] == "openai"
+    assert row["model"] == "gpt-4o-mini"
+    assert row["input_tokens"] == 5
+    assert row["output_tokens"] == 2
+    _capture.set_runtime(None)
+
+
+def test_wrap_captures_openai_create_through_a_real_client(tmp_path):
+    rows = Rows()
+    _capture.set_runtime(Runtime(rows, Options(app_root=str(tmp_path))))
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "id": "chatcmpl-test2",
+                "object": "chat.completion",
+                "created": 0,
+                "model": "gpt-4o-mini",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": "hi"},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 4, "completion_tokens": 1, "total_tokens": 5},
+            },
+        )
+
+    client = AsyncOpenAI(
+        api_key="test",
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+    )
+    metergraph.wrap(client, provider="openai")
+
+    async def run():
+        return await client.chat.completions.create(
+            model="gpt-4o-mini", messages=[{"role": "user", "content": "hi"}]
+        )
+
+    response = asyncio.run(run())
+
+    assert response.choices[0].message.content == "hi"
+    assert len(rows.rows) == 1
+    assert rows.rows[0]["endpoint"] == "chat.completions"
+    _capture.set_runtime(None)
+
+
+def test_wrap_captures_anthropic_messages_create_through_a_real_client(tmp_path):
+    rows = Rows()
+    _capture.set_runtime(Runtime(rows, Options(app_root=str(tmp_path))))
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "id": "msg_test",
+                "type": "message",
+                "role": "assistant",
+                "model": "claude-haiku-4-5-20251001",
+                "content": [{"type": "text", "text": "hi"}],
+                "stop_reason": "end_turn",
+                "usage": {"input_tokens": 5, "output_tokens": 2},
+            },
+        )
+
+    client = AsyncAnthropic(
+        api_key="test",
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+    )
+    metergraph.wrap(client, provider="anthropic")
+
+    async def run():
+        return await client.messages.create(
+            model="claude-haiku-4-5-20251001",
+            max_tokens=10,
+            messages=[{"role": "user", "content": "hi"}],
+        )
+
+    response = asyncio.run(run())
+
+    assert response.content[0].text == "hi"
+    assert len(rows.rows) == 1
+    row = rows.rows[0]
+    assert row["endpoint"] == "messages"
+    assert row["provider"] == "anthropic"
+    assert row["input_tokens"] == 5
+    assert row["output_tokens"] == 2
+    _capture.set_runtime(None)
+
+
+def test_wrap_captures_google_generate_content_through_a_real_client(tmp_path):
+    """genai.Client has no constructor hook for a custom transport, so the
+    mocked httpx client is swapped in on the internal _api_client after
+    construction — everything from there on (request building, response
+    parsing) is the real SDK's own code."""
+    rows = Rows()
+    _capture.set_runtime(Runtime(rows, Options(app_root=str(tmp_path))))
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "candidates": [
+                    {
+                        "content": {"parts": [{"text": "hi"}], "role": "model"},
+                        "finishReason": "STOP",
+                    }
+                ],
+                "usageMetadata": {
+                    "promptTokenCount": 5,
+                    "candidatesTokenCount": 2,
+                    "totalTokenCount": 7,
+                },
+                "modelVersion": "gemini-2.5-flash",
+            },
+        )
+
+    client = genai.Client(api_key="test")
+    client._api_client._async_httpx_client = httpx.AsyncClient(
+        transport=httpx.MockTransport(handler)
+    )
+    metergraph.wrap(client, provider="google")
+
+    async def run():
+        return await client.aio.models.generate_content(
+            model="gemini-2.5-flash", contents="hi"
+        )
+
+    response = asyncio.run(run())
+
+    assert response.text == "hi"
+    assert len(rows.rows) == 1
+    row = rows.rows[0]
+    assert row["endpoint"] == "models.generate_content"
+    assert row["provider"] == "google"
+    _capture.set_runtime(None)

{metergraph-0.2.0 → metergraph-0.2.1}/tests/test_sdk.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import gzip
 import json
+import logging
 import os
 import threading
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
@@ -12,7 +13,8 @@ from types import SimpleNamespace
 import metergraph
 from metergraph import _capture
 from metergraph._capture import Options, Runtime
-from metergraph._config import choose_model
+from metergraph._config import ConfigPoller, choose_model
+from metergraph._failure_log import FailureLogger
 from metergraph._template import template_hash
 from metergraph._transport import Writer
 
@@ -35,6 +37,18 @@ def test_hosted_default_is_https():
     assert metergraph.DEFAULT_INGEST_URL == "https://d2xus7mp8zdv6t.cloudfront.net"
 
 
+def test_python_seam_endpoints_match_shared_fixture():
+    fixture_path = Path(__file__).parent / "fixtures" / "seam_endpoints.json"
+    expected = json.loads(fixture_path.read_text())
+    actual = {
+        "openai": sorted({seam.endpoint for seam in _capture.OPENAI_SEAMS}),
+        "anthropic": sorted({seam.endpoint for seam in _capture.ANTHROPIC_SEAMS}),
+        "google": sorted({seam.endpoint for seam in _capture.GOOGLE_SEAMS}),
+    }
+    for provider, endpoints in expected.items():
+        assert actual[provider] == sorted(endpoints), provider
+
+
 def response(text="done"):
     usage = SimpleNamespace(
         prompt_tokens=12,
@@ -144,6 +158,90 @@ def test_wrap_patches_create_and_parse_on_both_chat_and_beta_chat(tmp_path):
     _capture.set_runtime(None)
 
 
+def test_wrap_patches_responses_parse_and_beta_responses_create(tmp_path):
+    rows = Rows()
+    _capture.set_runtime(
+        Runtime(rows, Options(app_root=str(Path(__file__).parents[1])))
+    )
+
+    class Responses:
+        def create(self, **kwargs):
+            return response()
+
+        def parse(self, **kwargs):
+            return response()
+
+    class BetaResponses:
+        # client.beta.responses has .create but, as of openai>=1.x, no .parse —
+        # verified directly against the installed SDK; do not add a .parse here.
+        def create(self, **kwargs):
+            return response()
+
+    client = SimpleNamespace(
+        responses=Responses(),
+        beta=SimpleNamespace(responses=BetaResponses()),
+    )
+    metergraph.wrap(client, provider="openai")
+
+    client.responses.create(model="gpt-test")
+    client.responses.parse(model="gpt-test")
+    client.beta.responses.create(model="gpt-test")
+
+    assert [row["endpoint"] for row in rows.rows] == [
+        "responses",
+        "responses.parse",
+        "responses",
+    ]
+    _capture.set_runtime(None)
+
+
+def test_wrap_skips_missing_nested_attribute_without_raising():
+    client = SimpleNamespace(beta=SimpleNamespace())  # beta.responses does not exist
+    result = metergraph.wrap(client, provider="openai")
+    assert result is client
+
+
+def test_wrap_skips_one_broken_seam_without_affecting_others(tmp_path):
+    rows = Rows()
+    _capture.set_runtime(
+        Runtime(rows, Options(app_root=str(Path(__file__).parents[1])))
+    )
+
+    class Completions:
+        def create(self, **kwargs):
+            return response()
+
+    class Chat:
+        completions = Completions()
+
+    class Client:
+        chat = Chat()
+
+        @property
+        def responses(self):
+            raise RuntimeError("boom: not ready yet")
+
+    client = Client()
+    metergraph.wrap(client, provider="openai")
+    client.chat.completions.create(model="gpt-test")
+
+    assert [row["endpoint"] for row in rows.rows] == ["chat.completions"]
+    _capture.set_runtime(None)
+
+
+def test_wrap_never_raises_even_if_client_attribute_access_raises(caplog):
+    class Explosive:
+        @property
+        def responses(self):
+            raise RuntimeError("boom: not ready yet")
+
+    client = Explosive()
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        result = metergraph.wrap(client)  # no provider override: exercises auto-detection
+    assert result is client
+    assert any("wrap() failed" in r.getMessage() for r in caplog.records)
+
+
 def gemini_response(text="gemini done"):
     return SimpleNamespace(
         text=text,
@@ -757,6 +855,31 @@ def test_canary_assignment_is_sticky_and_fail_open():
     assert choose_model("route-a", "fallback", "session-1", None) == "fallback"
 
 
+def test_config_poller_logs_generic_failures_via_failure_logger(caplog):
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            self.send_response(500)
+            self.end_headers()
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    poller = ConfigPoller(
+        "mg_test", f"http://127.0.0.1:{server.server_port}",
+        poll_seconds=60, hard_ttl_seconds=120,
+    )
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        ok = poller.poll_once()
+    poller.stop()
+    server.shutdown()
+
+    assert ok is False
+    assert any("config poll to" in r.getMessage() for r in caplog.records)
+
+
 def test_record_outcome_uses_the_async_content_free_channel(monkeypatch):
     rows = Rows()
     monkeypatch.setattr(metergraph, "_writer", rows)
@@ -858,3 +981,173 @@ def test_writer_splits_wire_batches_at_512_kib():
     assert len(wire_lengths) > 1
     assert max(wire_lengths) <= 512 * 1024
     assert sorted(row["index"] for row in delivered_rows) == list(range(6))
+
+
+def test_failure_logger_logs_first_occurrence_and_suppresses_repeats(caplog):
+    now = [0.0]
+    logger = FailureLogger(quiet_seconds=60.0, clock=lambda: now[0])
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        logger.report("transport_error", "boom 1")
+        now[0] = 10.0
+        logger.report("transport_error", "boom 2")
+        now[0] = 20.0
+        logger.report("transport_error", "boom 3")
+    messages = [r.getMessage() for r in caplog.records]
+    assert len(messages) == 1
+    assert "boom 1" in messages[0]
+
+
+def test_failure_logger_reports_suppressed_count_after_quiet_window(caplog):
+    now = [0.0]
+    logger = FailureLogger(quiet_seconds=60.0, clock=lambda: now[0])
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        logger.report("transport_error", "boom 1")
+        now[0] = 10.0
+        logger.report("transport_error", "boom 2")  # suppressed
+        now[0] = 70.0
+        logger.report("transport_error", "boom 3")
+    messages = [r.getMessage() for r in caplog.records]
+    assert len(messages) == 2
+    assert "1 more suppressed" in messages[1]
+    assert "boom 3" in messages[1]
+
+
+def test_failure_logger_tracks_kinds_independently(caplog):
+    now = [0.0]
+    logger = FailureLogger(quiet_seconds=60.0, clock=lambda: now[0])
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        logger.report("transport_error", "t1")
+        logger.report("client_error", "c1")
+    assert len(caplog.records) == 2
+
+
+def test_failure_logger_bounds_log_volume_under_sustained_failure(caplog):
+    now = [0.0]
+    logger = FailureLogger(quiet_seconds=60.0, clock=lambda: now[0])
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        for _ in range(1000):
+            logger.report("transport_error", "boom")
+    assert len(caplog.records) == 1
+
+
+def test_writer_auth_failure_is_fatal_and_logged_once(caplog):
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            self.rfile.read(int(self.headers["Content-Length"]))
+            self.send_response(401)
+            self.end_headers()
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    writer = Writer("mg_test", f"http://127.0.0.1:{server.server_port}", flush_seconds=5)
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        writer.enqueue({"payload": "one"})
+        writer.flush(2)
+        writer.enqueue({"payload": "two"})
+        writer.flush(2)
+    writer.shutdown()
+    server.shutdown()
+
+    auth_warnings = [r for r in caplog.records if "authentication failed" in r.getMessage()]
+    assert len(auth_warnings) == 1
+    assert writer.dropped >= 1
+
+
+def test_writer_permanent_client_error_drops_batch_but_writer_stays_alive(caplog):
+    attempts = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            attempts.append(1)
+            self.rfile.read(int(self.headers["Content-Length"]))
+            self.send_response(400)
+            self.end_headers()
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    writer = Writer("mg_test", f"http://127.0.0.1:{server.server_port}", flush_seconds=5)
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        writer.enqueue({"payload": "one"})
+        writer.flush(2)
+        writer.enqueue({"payload": "two"})
+        writer.flush(2)
+    writer.shutdown()
+    server.shutdown()
+
+    # A 400 is specific to the rejected batch, not the whole connection: the
+    # writer must still attempt the second, unrelated batch.
+    assert len(attempts) == 2
+    assert writer._fatal is False
+    assert writer.dropped >= 2
+    assert any("HTTP 400" in r.getMessage() for r in caplog.records)
+
+
+def test_writer_413_splits_oversized_batch_and_delivers_the_pieces():
+    received_batches = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            body = self.rfile.read(int(self.headers["Content-Length"]))
+            if self.headers.get("Content-Encoding") == "gzip":
+                body = gzip.decompress(body)
+            rows = json.loads(body)["rows"]
+            received_batches.append(len(rows))
+            if len(rows) > 1:
+                self.send_response(413)
+            else:
+                self.send_response(202)
+            self.end_headers()
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    writer = Writer("mg_test", f"http://127.0.0.1:{server.server_port}", flush_seconds=5)
+    for i in range(4):
+        writer.enqueue({"index": i})
+    assert writer.flush(10)
+    writer.shutdown()
+    server.shutdown()
+
+    assert any(size > 1 for size in received_batches)  # a multi-row batch hit 413 at least once
+    assert received_batches.count(1) == 4  # every row was eventually delivered as its own batch
+    assert writer.dropped == 0
+    assert writer._fatal is False
+
+
+def test_writer_server_error_retries_and_is_not_fatal(caplog):
+    attempts = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            self.rfile.read(int(self.headers["Content-Length"]))
+            attempts.append(1)
+            self.send_response(500)
+            self.end_headers()
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    writer = Writer("mg_test", f"http://127.0.0.1:{server.server_port}", flush_seconds=5)
+    with caplog.at_level(logging.WARNING, logger="metergraph"):
+        writer.enqueue({"payload": "one"})
+        writer.flush(2)
+    writer.shutdown()
+    server.shutdown()
+
+    assert len(attempts) == 1
+    assert writer._fatal is False
+    assert any("HTTP 500" in r.getMessage() for r in caplog.records)

metergraph-0.2.1/tests/test_seam_reality.py

@@ -0,0 +1,35 @@
+"""Assert every seam-table entry resolves against the real, installed
+provider SDKs — not just against hand-built fakes, which can only ever
+verify the code against what its author believed the SDK looked like."""
+
+from __future__ import annotations
+
+from anthropic import Anthropic
+from google import genai
+from openai import OpenAI
+
+from metergraph._capture import ANTHROPIC_SEAMS, GOOGLE_SEAMS, OPENAI_SEAMS, _resolve
+
+
+def _missing_seams(client, seams) -> list[str]:
+    missing = []
+    for seam in seams:
+        owner = _resolve(client, seam.path)
+        if owner is None or not callable(getattr(owner, seam.method, None)):
+            missing.append(f"{seam.path}.{seam.method}")
+    return missing
+
+
+def test_openai_seams_exist_on_the_real_sdk():
+    client = OpenAI(api_key="test")
+    assert _missing_seams(client, OPENAI_SEAMS) == []
+
+
+def test_anthropic_seams_exist_on_the_real_sdk():
+    client = Anthropic(api_key="test")
+    assert _missing_seams(client, ANTHROPIC_SEAMS) == []
+
+
+def test_google_seams_exist_on_the_real_sdk():
+    client = genai.Client(api_key="test")
+    assert _missing_seams(client, GOOGLE_SEAMS) == []

metergraph-0.2.0/src/metergraph.egg-info/requires.txt

@@ -1,3 +0,0 @@
-
-[dev]
-pytest>=8