debugbundle-python 2.0.0__tar.gz → 2.0.1__tar.gz

{debugbundle_python-2.0.0/src/debugbundle_python.egg-info → debugbundle_python-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 2.0.0
+Version: 2.0.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -357,3 +357,9 @@ CI validates Ruff, mypy, pytest, package build, event schema fixtures, and cover
 ## License
 
 Apache-2.0. See `LICENSE`.
+
+## Delivery acknowledgement and retry limits
+
+The built-in HTTP transport requires the canonical ingestion acknowledgement (`accepted`, `rejected`, and `errors`). Empty responses, unrelated JSON, malformed counts, or invalid rejection indices retain the full batch with backoff. Valid acknowledgements remove accepted and terminally rejected events and retry only the indexed retryable rejections; an all-rejected batch does not advance `lastEventAt`.
+
+File transports and explicitly supplied custom/legacy transports retain their documented bodyless success fallback. A custom transport that returns acknowledgement fields must return the complete canonical shape. Retry hints (delay seconds or HTTP dates) are bounded to five minutes and measured from response receipt, including partial/protocol acknowledgements and retryable server failures. Without a server hint, existing retry timing is preserved. Failures remain contained within the SDK's existing delivery path.

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/README.md

@@ -316,3 +316,9 @@ CI validates Ruff, mypy, pytest, package build, event schema fixtures, and cover
 ## License
 
 Apache-2.0. See `LICENSE`.
+
+## Delivery acknowledgement and retry limits
+
+The built-in HTTP transport requires the canonical ingestion acknowledgement (`accepted`, `rejected`, and `errors`). Empty responses, unrelated JSON, malformed counts, or invalid rejection indices retain the full batch with backoff. Valid acknowledgements remove accepted and terminally rejected events and retry only the indexed retryable rejections; an all-rejected batch does not advance `lastEventAt`.
+
+File transports and explicitly supplied custom/legacy transports retain their documented bodyless success fallback. A custom transport that returns acknowledgement fields must return the complete canonical shape. Retry hints (delay seconds or HTTP dates) are bounded to five minutes and measured from response receipt, including partial/protocol acknowledgements and retryable server failures. Without a server hint, existing retry timing is preserved. Failures remain contained within the SDK's existing delivery path.

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "debugbundle-python"
-version = "2.0.0"
+version = "2.0.1"
 description = "DebugBundle SDK for Python"
 readme = "README.md"
 requires-python = ">=3.10"

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/src/debugbundle/acknowledgement.py

@@ -19,8 +19,10 @@ class AcknowledgementDecision:
     reason: str | None = None
 
 
-def decide_acknowledgement(body: object | None, batch_length: int) -> AcknowledgementDecision:
+def decide_acknowledgement(body: object | None, batch_length: int, required: bool = False) -> AcknowledgementDecision:
     if not isinstance(body, dict) or not any(key in body for key in ("accepted", "rejected", "errors")):
+        if required:
+            return AcknowledgementDecision(kind="protocol_failure", reason="missing_acknowledgement")
         return AcknowledgementDecision(kind="legacy")
 
     accepted = body.get("accepted")

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/src/debugbundle/core.py

@@ -61,7 +61,7 @@ from .redaction import (
 )
 from .request_capture_policy import should_capture_request_event
 from .suppression import EventSuppressionTracker
-from .transport import HttpTransport, Transport, coerce_transport_response
+from .transport import HttpTransport, Transport, bounded_retry_after_ms, coerce_transport_response
 from .trigger_token import resolve_request_trigger_directives
 
 DEFAULT_BATCH_SIZE = 25
@@ -499,11 +499,13 @@ class DebugBundleSdk:
                     return
 
                 if 200 <= response.status_code < 300:
-                    acknowledgement = decide_acknowledgement(response.body, len(batch))
+                    acknowledgement = decide_acknowledgement(
+                        response.body, len(batch), isinstance(transport, HttpTransport)
+                    )
                     if acknowledgement.kind == "protocol_failure":
                         self._consecutive_failures += 1
-                        retry_after_ms = response.retry_after_ms if response.retry_after_ms is not None else 1_000
-                        self._retry_after = now + (retry_after_ms / 1000)
+                        retry_after_ms = bounded_retry_after_ms(response.retry_after_ms)
+                        self._retry_after = self._time_provider() + (retry_after_ms / 1000)
                         self._emit_diagnostic(
                             "ingestion_acknowledgement_invalid",
                             "sdk-python retained a batch after an invalid ingestion acknowledgement",
@@ -535,8 +537,8 @@ class DebugBundleSdk:
                         self._last_event_at = self._time_provider() * 1000
                     if acknowledgement.retryable_indices:
                         self._consecutive_failures += 1
-                        retry_after_ms = response.retry_after_ms if response.retry_after_ms is not None else 1_000
-                        self._retry_after = now + (retry_after_ms / 1000)
+                        retry_after_ms = bounded_retry_after_ms(response.retry_after_ms)
+                        self._retry_after = self._time_provider() + (retry_after_ms / 1000)
                         self._schedule_flush_locked(delay=retry_after_ms / 1000)
                         return
                     self._retry_after = 0.0
@@ -544,9 +546,9 @@ class DebugBundleSdk:
                     return
 
                 self._consecutive_failures += 1
-                if response.status_code == 429:
-                    retry_after_ms = response.retry_after_ms if response.retry_after_ms is not None else 1_000
-                    self._retry_after = now + (retry_after_ms / 1000)
+                if response.status_code == 429 or (response.status_code >= 500 and response.retry_after_ms is not None):
+                    retry_after_ms = bounded_retry_after_ms(response.retry_after_ms)
+                    self._retry_after = self._time_provider() + (retry_after_ms / 1000)
                     self._schedule_flush_locked(delay=retry_after_ms / 1000)
                     return
                 if 400 <= response.status_code < 500:

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/src/debugbundle/event_support.py

@@ -264,7 +264,7 @@ def sdk_version() -> str:
     try:
         return metadata.version("debugbundle-python")
     except metadata.PackageNotFoundError:
-        return "2.0.0"
+        return "2.0.1"
 
 
 def sdk_config_endpoint(events_endpoint: str) -> str:

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/src/debugbundle/transport.py

@@ -1,11 +1,40 @@
 from __future__ import annotations
 
+import math
+import time
 from collections.abc import Mapping
 from dataclasses import dataclass
+from email.utils import parsedate_to_datetime
 from typing import Any, Protocol
 
 import httpx
 
+MAX_RETRY_AFTER_MS = 300_000
+
+
+def bounded_retry_after_ms(value: object, default: int = 1_000) -> int:
+    # Clamp before conversion so arbitrarily large integer hints cannot overflow a float deadline.
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return default
+    if isinstance(value, float) and not math.isfinite(value):
+        return default
+    return int(min(MAX_RETRY_AFTER_MS, max(0, value)))
+
+
+def _parse_retry_after(value: str | None) -> int | None:
+    if value is None:
+        return None
+    try:
+        seconds = float(value)
+    except ValueError:
+        try:
+            seconds = parsedate_to_datetime(value).timestamp() - time.time()
+        except (ValueError, TypeError, OverflowError):
+            return None
+    if not math.isfinite(seconds):
+        return None
+    return bounded_retry_after_ms(min(300, max(0, seconds)) * 1_000)
+
 
 @dataclass
 class TransportResponse:
@@ -34,13 +63,7 @@ class HttpTransport:
             json={"events": request["events"]},
             headers=headers,
         )
-        retry_after_header = response.headers.get("retry-after")
-        retry_after_ms = None
-        if retry_after_header is not None:
-            try:
-                retry_after_ms = int(float(retry_after_header) * 1000)
-            except ValueError:
-                retry_after_ms = None
+        retry_after_ms = _parse_retry_after(response.headers.get("retry-after"))
 
         try:
             body: object | None = response.json()

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1/src/debugbundle_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 2.0.0
+Version: 2.0.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -357,3 +357,9 @@ CI validates Ruff, mypy, pytest, package build, event schema fixtures, and cover
 ## License
 
 Apache-2.0. See `LICENSE`.
+
+## Delivery acknowledgement and retry limits
+
+The built-in HTTP transport requires the canonical ingestion acknowledgement (`accepted`, `rejected`, and `errors`). Empty responses, unrelated JSON, malformed counts, or invalid rejection indices retain the full batch with backoff. Valid acknowledgements remove accepted and terminally rejected events and retry only the indexed retryable rejections; an all-rejected batch does not advance `lastEventAt`.
+
+File transports and explicitly supplied custom/legacy transports retain their documented bodyless success fallback. A custom transport that returns acknowledgement fields must return the complete canonical shape. Retry hints (delay seconds or HTTP dates) are bounded to five minutes and measured from response receipt, including partial/protocol acknowledgements and retryable server failures. Without a server hint, existing retry timing is preserved. Failures remain contained within the SDK's existing delivery path.

{debugbundle_python-2.0.0 → debugbundle_python-2.0.1}/src/debugbundle_python.egg-info/SOURCES.txt

@@ -55,4 +55,5 @@ tests/test_sdk.py
 tests/test_smoke_script.py
 tests/test_structlog_filtering.py
 tests/test_suppression.py
+tests/test_transport_reliability.py
 tests/test_trigger_token.py

debugbundle_python-2.0.1/tests/test_transport_reliability.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
+from types import SimpleNamespace
+
+import httpx
+import pytest
+
+from debugbundle.core import DebugBundleSdk
+from debugbundle.transport import HttpTransport, TransportResponse
+
+
+@pytest.mark.parametrize("hint", [float("nan"), float("inf"), "1e100", True])
+def test_invalid_custom_retry_hint_uses_safe_backoff_without_losing_events(hint: object) -> None:
+    now = 1_700_000_000.0
+    sdk = DebugBundleSdk(
+        transport=lambda _: SimpleNamespace(status_code=429, retry_after_ms=hint), time_provider=lambda: now
+    )
+    sdk.init(project_token="dbundle_proj_test", batch_size=100, flush_interval=3600)
+    try:
+        sdk.capture_message("retain", level="error")
+        sdk.flush()
+        assert sdk._retry_after == now + 1
+        assert len(sdk._buffer) == 1
+        assert sdk.last_event_at is None
+    finally:
+        sdk.dispose()
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "",
+        '{"accepted":null,"rejected":2,"errors":[{"index":0,"reason":"rate_limited"},{"index":1,"reason":"rate_limited"}]}',
+        '{"accepted":2,"rejected":0,"errors":null}',
+        '{"accepted":1,"rejected":1,"errors":[{"index":4294967296,"reason":"rate_limited"}]}',
+        '{"accepted":1,"rejected":1,"errors":{"one":{"index":1,"reason":"rate_limited"}}}',
+        "<html>proxy</html>",
+        "{}",
+        "[]",
+        "null",
+        '{"accepted":1,"rejected":0,"errors":[]}',
+        '{"accepted":0,"rejected":2,"errors":[{"index":0,"reason":"rate_limited"},{"index":0,"reason":"rate_limited"}]}',
+        '{"accepted":1,"rejected":1,"errors":[{"index":2,"reason":"rate_limited"}]}',
+    ],
+)
+def test_builtin_http_retains_unacknowledged_batch_and_recovers(body: str) -> None:
+    batches: list[object] = []
+
+    def respond(request: httpx.Request) -> httpx.Response:
+        import json
+
+        batches.append(json.loads(request.content)["events"])
+        return httpx.Response(
+            202,
+            text=body if len(batches) == 1 else '{"accepted":2,"rejected":0,"errors":[]}',
+            headers={"Retry-After": "300"},
+        )
+
+    transport = HttpTransport("https://example.invalid/events")
+    transport._client.close()
+    transport._client = httpx.Client(transport=httpx.MockTransport(respond))
+    now = [1_700_000_000.0]
+    sdk = DebugBundleSdk(transport=transport, time_provider=lambda: now[0])
+    sdk.init(project_token="dbundle_proj_test", batch_size=100, flush_interval=3600)
+    try:
+        sdk.capture_message("first", level="error")
+        sdk.capture_message("second", level="error")
+        sdk.flush()
+        assert sdk.last_event_at is None
+        assert len(sdk._buffer) == 2
+        sdk.flush()
+        assert len(batches) == 1
+        now[0] += 301
+        sdk.flush()
+        assert len(batches) == 2 and batches[0] == batches[1]
+        assert sdk.last_event_at is not None
+    finally:
+        sdk.dispose()
+        transport.close()
+
+
+@pytest.mark.parametrize(
+    "header,expected",
+    [
+        ("0.25", 250),
+        ("999999", 300_000),
+        ("1e300", 300_000),
+        ("-1", 0),
+        ("NaN", None),
+        ("Infinity", None),
+        ("nope", None),
+        (format_datetime(datetime.now(timezone.utc) + timedelta(days=1), usegmt=True), 300_000),
+        ("Sun, 06 Nov 1994 08:49:37 GMT", 0),
+    ],
+)
+def test_http_retry_after_is_bounded(header: str, expected: int | None) -> None:
+    transport = HttpTransport("https://example.invalid/events")
+    transport._client.close()
+    transport._client = httpx.Client(
+        transport=httpx.MockTransport(lambda _: httpx.Response(429, headers={"Retry-After": header}))
+    )
+    try:
+        assert transport({"project_token": "dbundle_proj_test", "events": []}).retry_after_ms == expected
+    finally:
+        transport.close()
+
+
+@pytest.mark.parametrize(
+    "body,status",
+    [
+        (None, 429),
+        (None, 503),
+        ({}, 202),
+        ({"accepted": 0, "rejected": 1, "errors": [{"index": 0, "reason": "rate_limited"}]}, 202),
+    ],
+)
+def test_custom_retry_hint_cannot_suppress_delivery_beyond_five_minutes(body: object, status: int) -> None:
+    calls: list[object] = []
+    now = [1_700_000_000.0]
+
+    def send(request: object) -> TransportResponse:
+        calls.append(request)
+        now[0] += 10  # The delay starts when the response arrives, not when sending began.
+        return TransportResponse(status, 10**100, body)
+
+    # An empty custom ACK is explicitly legacy-compatible; use malformed counts for protocol failure.
+    if body == {}:
+        body = {"accepted": 2, "rejected": 0, "errors": []}
+    sdk = DebugBundleSdk(transport=send, time_provider=lambda: now[0])
+    sdk.init(project_token="dbundle_proj_test", batch_size=100, flush_interval=3600)
+    try:
+        sdk.capture_message("retry", level="error")
+        sdk.flush()
+        assert sdk._retry_after == now[0] + 300
+        now[0] += 299
+        sdk.flush()
+        assert len(calls) == 1
+        now[0] += 2
+        sdk.flush()
+        assert len(calls) == 2
+    finally:
+        sdk.dispose()