debugbundle-python 2.0.1__py3-none-any.whl → 2.1.1__py3-none-any.whl

debugbundle/relay_delivery.py

@@ -4,12 +4,17 @@ import json
 import os
 import re
 import secrets
+import stat
 import threading
 import time
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from typing import Any
 
+from .acknowledgement import decide_acknowledgement
+from .evidence_delivery import EvidenceDelivery
+from .evidence_wire import FEATURES, strip_unsupported
+from .ingestion_wire import MAX_EVENT_BYTES, chunks, event_bytes, fit_event
 from .transport import HttpTransport, coerce_transport_response
 
 LOCAL_EVENTS_DIRECTORY_MODE = 0o700
@@ -38,8 +43,11 @@ def attach_project_token(events: list[dict[str, Any]], project_token: str) -> li
 
 def mark_spool_file_delivered(written_file_path: str) -> None:
     try:
-        with open(f"{written_file_path}{RELAY_SPOOL_DELIVERED_MARKER_SUFFIX}", "w", encoding="utf-8"):
-            pass
+        if not stat.S_ISREG(os.lstat(written_file_path).st_mode):
+            return
+        marker = f"{written_file_path}{RELAY_SPOOL_DELIVERED_MARKER_SUFFIX}"
+        fd = os.open(marker, os.O_CREAT | os.O_EXCL | os.O_WRONLY | OPTIONAL_NOFOLLOW_FLAG, LOCAL_EVENT_FILE_MODE)
+        os.close(fd)
     except OSError:
         # Durable acceptance already happened at the spool write; marker creation is maintenance metadata only.
         return
@@ -79,26 +87,109 @@ class AtomicRelayFileTransport:
 
 
 class RelayForwardTransport:
-    def __init__(self, endpoint: str, transport: Callable[[Mapping[str, object]], object] | None = None) -> None:
+    def __init__(
+        self,
+        endpoint: str,
+        transport: Callable[[Mapping[str, object]], object] | None = None,
+        evidence: EvidenceDelivery | None = None,
+    ) -> None:
         self._transport = transport or HttpTransport(endpoint)
-
-    def send(self, project_token: str, events: list[dict[str, Any]]) -> tuple[bool, bool]:
+        self._evidence = evidence or EvidenceDelivery()
+
+    @staticmethod
+    def prepare_event(event: dict[str, Any], project_token: str) -> dict[str, Any] | None:
+        owned = dict(event, project_token=project_token)
+        if event.get("event_type") == "analytics_event":
+            reduced = owned if event_bytes(owned) <= MAX_EVENT_BYTES else None
+        else:
+            reduced = fit_event(owned)
+        return {key: value for key, value in reduced.items() if key != "project_token"} if reduced else None
+
+    def send(self, project_token: str, events: list[dict[str, Any]], discover: bool = False) -> tuple[bool, bool]:
+        configured, success, _complete = self.send_verified(project_token, events, discover)
+        return configured, success
+
+    def send_verified(
+        self, project_token: str, events: list[dict[str, Any]], discover: bool = False
+    ) -> tuple[bool, bool, bool]:
         if not project_token:
-            return (False, False)
+            return False, False, False
+        deadline = time.monotonic() + 5.0
+        try:
+            complete = True
+            # Start with the neutral intersection, so a previously unknown path
+            # can learn proof from this batch's canonical existing ACK traffic.
+            features = list(FEATURES)
+            for original in chunks(attach_project_token(events, project_token)):
+                if time.monotonic() >= deadline:
+                    return True, False, False
+                batch: list[dict[str, Any]] = []
+                for event in original:
+                    selected = (
+                        strip_unsupported(event, self._evidence.features)
+                        if event.get("event_type") != "analytics_event"
+                        else event
+                    )
+                    if selected is None:
+                        return True, False, False
+                    batch.append(selected)
+                success, canonical = self._send_chunk(project_token, batch, discover, deadline)
+                features = [feature for feature in features if feature in self._evidence.features]
+                self._evidence.features = list(features)
+                if not success or time.monotonic() >= deadline:
+                    return True, False, False
+                complete = complete and canonical
+            return True, True, complete
+        except Exception:
+            return True, False, False
 
+    def _send_chunk(
+        self, project_token: str, events: list[dict[str, Any]], discover: bool, deadline: float
+    ) -> tuple[bool, bool]:
         try:
-            response = coerce_transport_response(
-                self._transport(
-                    {
-                        "project_token": project_token,
-                        "events": attach_project_token(events, project_token),
-                    }
+
+            def send(batch: list[dict[str, Any]]):
+                if time.monotonic() >= deadline:
+                    raise TimeoutError("relay forwarding deadline exhausted")
+                request = {"project_token": project_token, "events": batch}
+                response = (
+                    self._transport.send_until(request, deadline)
+                    if isinstance(self._transport, HttpTransport)
+                    else self._transport(request)
                 )
-            )
+                return coerce_transport_response(response)
+
+            response = send(events)
+            if not 200 <= response.status_code < 300:
+                return False, False
+            required = discover or isinstance(self._transport, HttpTransport)
+            ack = decide_acknowledgement(response.body, len(events), required)
+            lost = self._evidence.observe(response.body, required, ack.kind == "acknowledged")
+            if ack.kind == "legacy":
+                return True, False
+            if ack.kind != "acknowledged":
+                return False, False
+            if ack.accepted == len(events):
+                return True, True
+            retries = []
+            if lost:
+                for index, reason in ack.terminal_errors:
+                    original = events[index]
+                    if reason == "invalid_event" and original.get("event_type") == "frontend_exception":
+                        reduced = strip_unsupported(original, self._evidence.features)
+                        if reduced is not None and reduced != original:
+                            retries.append(reduced)
+            if not retries:
+                return False, False
+            response = send(retries)
+            if not 200 <= response.status_code < 300:
+                return False, False
+            retry_ack = decide_acknowledgement(response.body, len(retries), True)
+            self._evidence.observe(response.body, required, retry_ack.kind == "acknowledged")
+            complete = retry_ack.kind == "acknowledged" and ack.accepted + retry_ack.accepted == len(events)
+            return complete, complete
         except Exception:
-            return (True, False)
-
-        return (True, 200 <= response.status_code < 300)
+            return False, False
 
 
 def _sanitize_service_name(service_name: str) -> str:
@@ -135,4 +226,4 @@ def _cleanup_temp_files(events_dir: str) -> None:
             except OSError:
                 continue
     except OSError:
-        return
+        return

debugbundle/remote_config_client.py

@@ -0,0 +1,81 @@
+"""Owned SDK boundary extracted without changing capture/delivery semantics."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .config import MINIMAL_CAPTURE_POLICY, parse_remote_config
+from .event_support import sdk_config_endpoint, serialize_error
+from .evidence_http import evidence_url
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def refresh_remote_config(sdk: DebugBundleSdk, initial: bool = False) -> None:
+    with sdk._lock:
+        if not sdk._enabled or sdk._fetch_impl is None:
+            return
+        request_headers: dict[str, str] = {"authorization": f"Bearer {sdk._project_token}"}
+        if sdk._remote_config_etag is not None:
+            request_headers["if-none-match"] = sdk._remote_config_etag
+        fetch = sdk._fetch_impl
+        endpoint = evidence_url(sdk_config_endpoint(sdk._endpoint))
+        poll_interval = sdk._configured_probes_poll_interval_ms
+        generation = sdk._generation
+
+    try:
+        response = fetch(endpoint, {"method": "GET", "headers": request_headers})
+        status_code = getattr(response, "status_code", None)
+        if status_code == 304:
+            snapshot = None
+        elif status_code == 200:
+            payload = response.json()
+            snapshot = parse_remote_config(
+                payload,
+                poll_interval,
+                int(sdk._time_provider() * 1000),
+            )
+        else:
+            raise RuntimeError(f"unexpected config status {status_code}")
+        headers = response.headers or {}
+        etag = headers.get("etag")
+        failure: BaseException | None = None
+    except BaseException as error:
+        status_code = None
+        snapshot = None
+        etag = None
+        failure = error
+
+    with sdk._lock:
+        if generation != sdk._generation or not sdk._enabled:
+            return
+        if failure is None and status_code == 304:
+            sdk._schedule_next_remote_config_refresh()
+            return
+        if failure is None:
+            sdk._evidence.observe(payload, True, snapshot is not None)
+            if snapshot is None:
+                sdk._emit_diagnostic(
+                    "remote_probe_config_invalid",
+                    "sdk-python received an invalid remote probe config payload",
+                )
+                if initial:
+                    sdk._capture_policy = MINIMAL_CAPTURE_POLICY
+                sdk._schedule_next_remote_config_refresh(use_fallback=True)
+                return
+
+            sdk._remote_config_snapshot = snapshot
+            sdk._capture_policy = snapshot.capture_policy
+            if isinstance(etag, str) and len(etag) > 0:
+                sdk._remote_config_etag = etag
+            sdk._schedule_next_remote_config_refresh()
+        else:
+            sdk._emit_diagnostic(
+                "remote_probe_config_failed",
+                "sdk-python failed to refresh remote probe config",
+                metadata={"error": serialize_error(failure) if isinstance(failure, Exception) else "fetch_failed"},
+            )
+            if initial:
+                sdk._capture_policy = MINIMAL_CAPTURE_POLICY
+            sdk._schedule_next_remote_config_refresh(use_fallback=True)

debugbundle/scope_ownership.py

@@ -0,0 +1,99 @@
+"""Revoke copied ContextVar values when their request/project owner ends."""
+
+from __future__ import annotations
+
+from contextvars import Token
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+from .config import RemoteProbeDirective
+from .operation_context import Operation
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+@dataclass
+class Lease:
+    generation: int
+    parent: Lease | None = None
+    active: bool = True
+    token_id: int = 0
+    operation: Token[Operation | None] | None = None
+
+
+class ScopedContext(dict[str, object]):
+    lease: Lease
+
+
+class ScopedDirectives(list[RemoteProbeDirective]):
+    lease: Lease
+
+
+def alive(value: object, generation: int) -> bool:
+    if type(value) is not ScopedContext and type(value) is not ScopedDirectives:
+        return False
+    lease: Lease | None = value.lease
+    for _ in range(16):
+        if lease is None:
+            return True
+        if not lease.active or lease.generation != generation:
+            return False
+        lease = lease.parent
+    return False
+
+
+def context_value(sdk: DebugBundleSdk) -> dict[str, object]:
+    value = sdk._scoped_context.get()
+    return value if alive(value, sdk._generation) and value is not None else {}
+
+
+def bind_context(sdk: DebugBundleSdk, protected: dict[str, object]) -> Token[dict[str, object] | None]:
+    parent = sdk._scoped_context.get()
+    value = ScopedContext(protected)
+    value.lease = Lease(
+        sdk._generation, parent.lease if type(parent) is ScopedContext and alive(parent, sdk._generation) else None
+    )
+    token = sdk._scoped_context.set(value)
+    value.lease.token_id = id(token)
+    return token
+
+
+def bind_directives(
+    sdk: DebugBundleSdk, directives: list[RemoteProbeDirective]
+) -> Token[list[RemoteProbeDirective] | None]:
+    parent = sdk._request_trigger_directives.get()
+    value = ScopedDirectives(directives)
+    value.lease = Lease(
+        sdk._generation,
+        parent.lease if type(parent) is ScopedDirectives and alive(parent, sdk._generation) else None,
+        operation=sdk._operations.begin({"kind": "request"}),
+    )
+    token = sdk._request_trigger_directives.set(value)
+    value.lease.token_id = id(token)
+    return token
+
+
+def release(
+    sdk: DebugBundleSdk,
+    token: Token[dict[str, object] | None] | Token[list[RemoteProbeDirective] | None],
+    *,
+    directives: bool = False,
+) -> None:
+    variable = sdk._request_trigger_directives if directives else sdk._scoped_context
+    value = variable.get()
+    lease = value.lease if type(value) is ScopedContext or type(value) is ScopedDirectives else None
+    current_lease = lease
+    for _ in range(16):
+        if lease is None:
+            return
+        if lease.token_id == id(token):
+            if lease is current_lease:
+                # Preserve native Token context checks; old completion never clears
+                # the currently active newer owner.
+                cast(Any, variable).reset(token)
+            lease.active = False
+            if directives:
+                sdk._operations.end(lease.operation)
+            return
+        lease = lease.parent

debugbundle/structlog_integration.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import copy
 import inspect
 import logging
+import sys
 from contextvars import ContextVar
 from typing import Any
 
@@ -19,6 +20,17 @@ def _capture(sdk: Any, active: list[bool], name: str, record: dict[str, Any]) ->
         context = dict(record)
         message = str(context.pop("event", ""))
         level = {"warn": "warning", "exception": "error", "fatal": "critical"}.get(name, name)
+        info = context.get("exc_info")
+        if info is True:
+            info = sys.exc_info()
+        error = info[1] if type(info) is tuple and len(info) == 3 else info
+        if level in {"error", "critical"} and isinstance(error, BaseException) and hasattr(sdk, "capture_exception"):
+            eligible = getattr(sdk, "_log_level_eligible", None)
+            if callable(eligible) and not eligible(level):
+                return
+            context.pop("exc_info", None)
+            sdk.capture_exception(error, {**context, "logger_name": "structlog", "log_message": message})
+            return
         sdk.capture_log(message, level=level, context=context or None)
     except Exception:
         # A logger adapter must not throw into the application's logging path.
@@ -61,8 +73,10 @@ class StructlogLoggerProxy:
         if not callable(attribute):
             return attribute
         if name in _BIND_METHODS:
+
             def bind(*args: Any, **kwargs: Any) -> StructlogLoggerProxy:
                 return StructlogLoggerProxy(attribute(*args, **kwargs), self._sdk, self._active)
+
             return bind
         method_name = name[1:] if name.startswith("a") else name
         if method_name not in _LOG_METHODS:
@@ -84,6 +98,7 @@ class StructlogLoggerProxy:
                 if args:
                     record["event"] = args[1] if method_name == "log" and len(args) > 1 else args[0]
                 processors = list(bound._processors)
+                native_info = kwargs.get("exc_info", sys.exc_info() if method_name == "exception" else None)
                 if processors:
                     last = processors[-1]
 
@@ -96,6 +111,8 @@ class StructlogLoggerProxy:
                         if isinstance(snapshot, dict):
                             record.clear()
                             record.update(snapshot)
+                            if native_info is not None:
+                                record["exc_info"] = native_info
                         return result
 
                     processors[-1] = observe
@@ -107,12 +124,15 @@ class StructlogLoggerProxy:
                 return attribute
 
         if inspect.iscoroutinefunction(attribute):
+
             async def async_log(*args: Any, **kwargs: Any) -> Any:
                 return await prepare(args, kwargs)(*args, **kwargs)
+
             return async_log
 
         def log(*args: Any, **kwargs: Any) -> Any:
             return prepare(args, kwargs)(*args, **kwargs)
+
         return log
 
     def _ensure_stdlib_handler(self, sink: Any) -> None:
@@ -136,4 +156,5 @@ class StructlogLoggerProxy:
             record = {**kwargs, **{f"arg_{i}": value for i, value in enumerate(args)}, "event": event or ""}
             _capture(self._sdk, self._active, name, record)
             return result
+
         return log

debugbundle/transport.py

@@ -9,6 +9,9 @@ from typing import Any, Protocol
 
 import httpx
 
+from .evidence_http import bounded_response_json, evidence_url
+from .ingestion_wire import MAX_BODY_BYTES, encode_body
+
 MAX_RETRY_AFTER_MS = 300_000
 
 
@@ -44,8 +47,7 @@ class TransportResponse:
 
 
 class Transport(Protocol):
-    def __call__(self, request: Mapping[str, object]) -> TransportResponse:
-        ...
+    def __call__(self, request: Mapping[str, object]) -> TransportResponse: ...
 
 
 class HttpTransport:
@@ -54,22 +56,26 @@ class HttpTransport:
         self._client = httpx.Client(timeout=5.0)
 
     def __call__(self, request: Mapping[str, object]) -> TransportResponse:
+        return self.send_until(request, time.monotonic() + 5.0)
+
+    def send_until(self, request: Mapping[str, object], deadline: float) -> TransportResponse:
+        remaining = min(5.0, deadline - time.monotonic())
+        if remaining <= 0:
+            raise TimeoutError("ingestion deadline exhausted")
+        body_bytes = encode_body(request["events"])
+        if len(body_bytes) > MAX_BODY_BYTES:
+            raise ValueError("ingestion request exceeds byte limit")
         headers = {
             "authorization": f"Bearer {request['project_token']}",
             "content-type": "application/json",
+            "accept-encoding": "identity",
         }
-        response = self._client.post(
-            self._endpoint,
-            json={"events": request["events"]},
-            headers=headers,
-        )
-        retry_after_ms = _parse_retry_after(response.headers.get("retry-after"))
-
-        try:
-            body: object | None = response.json()
-        except (ValueError, TypeError):
-            body = None
-        return TransportResponse(status_code=response.status_code, retry_after_ms=retry_after_ms, body=body)
+        with self._client.stream(
+            "POST", evidence_url(self._endpoint), content=body_bytes, headers=headers, timeout=remaining
+        ) as response:
+            retry_after_ms = _parse_retry_after(response.headers.get("retry-after"))
+            body = bounded_response_json(response, deadline)
+            return TransportResponse(status_code=response.status_code, retry_after_ms=retry_after_ms, body=body)
 
     def close(self) -> None:
         self._client.close()

{debugbundle_python-2.0.1.dist-info → debugbundle_python-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 2.0.1
+Version: 2.1.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -41,8 +41,18 @@ Dynamic: license-file
 
 # debugbundle-python
 
+Patch 2.1.1 corrects native logger exception evidence and capture safety while preserving public APIs and event schemas. Upgrade the DebugBundle distribution to adopt the correction.
+
 Python SDK for DebugBundle.
 
+After `make install-docker`, `make evidence-performance` compares identical
+exception/recovery calls with evidence disabled and enabled, including a full
+warning queue, with networking disabled. It reports capture timing separately from
+Python `tracemalloc` peak/live allocation measurements, verifies native causes and
+original-error priority, and checks existing retention ceilings. Setup and cleanup
+are excluded; traced allocations are Python-managed memory, not cumulative churn
+or total process RSS.
+
 ![PyPI](https://img.shields.io/pypi/v/debugbundle-python?label=pypi)
 ![CI](https://img.shields.io/github/actions/workflow/status/debugbundle/debugbundle-python/ci.yml?branch=main&label=ci)
 ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
@@ -51,6 +61,93 @@ Use this package to capture Python backend exceptions, request metadata, structu
 
 Requires Python 3.10 or newer.
 
+## Evidence in 2.1.0
+
+Version 2.1.0 adds `capture_exception_evidence=True` and
+`capture_recovery_observations=False` installation options. Collection requires
+verified delivery/reader support, discovered on existing config/ACK traffic with
+`debugbundle_evidence=1`. No capture call performs discovery or adds polling.
+`evidence_capabilities` is an optional descriptor pin asserting the **entire**
+path, including local readers, relays and wrappers; later discovery can revoke it.
+Without proof, exception events retain their legacy shape. These additions require upgrading from 2.0.1 to 2.1.0.
+
+Native cause, implicit context and Python 3.11+ exception-group evidence excludes
+locals, source excerpts, arbitrary renderers and application properties. Python
+3.10 has no native exception groups. Graphs retain at most eight nodes, depth
+four, five children and 32 frames per node; all optional exception additions fit
+32 KiB. Uncaught native capture bypasses `before_send` and uses two nodes, eight
+frames and a 4-KiB total including execution/reference metadata. The original
+sanitised stack remains separate.
+
+`with sdk.operation_context({"kind": "job", "name": "invoice.calculate",
+"limit_ms": 5000}):` supplies a fresh operation scope and monotonic elapsed time
+to synchronous or asynchronous work inside the block. Kinds are `request`,
+`command`, `job` and `unknown`. The limit is a known configured limit, not time
+remaining. Framework requests use their existing begin/end lifecycle. Completed
+owners revoke copied async context; reinitialisation/fork discard prior ownership.
+Application results and exceptions pass through the context manager unchanged.
+
+The existing background sender remains best-effort at immediate process exit.
+The uncaught hook collects bounded native evidence without waiting for transport;
+applications needing a delivery attempt use explicit `flush()` in a controlled
+shutdown window. This release does not add default crash-file persistence or
+synchronous capture transport.
+
+Pass a fresh UUID v4 `failure_ref` in exception/log/request context. A valid
+`evidence_scope` can specify a fresh page or operation UUID; an active operation
+provides the default. `capture_recovery({"failure_ref": failure_ref,
+"attempt_id": attempt_id, "state": "attempt_completed"})` records an explicit
+application observation. Optional fields are `evidence_scope`, technical
+`operation`, `status_code`, `duration_ms` and primitive `correlation` metadata.
+Page scopes require a nonblank session ID, including the valid string `"0"`.
+Only explicit `recovery_observed` claims semantic recovery; HTTP 200 and
+`attempt_completed` leave it unknown. The other states are `attempt_started`,
+`attempt_failed` and `failure_persisted`.
+
+Standalone recovery requires its local opt-in, `recovery_v1` support and server
+`capture_diagnostic_context`; minimal policy disables it. Privacy, sampling,
+resulting hook-event policy and queue limits still apply. Fifty failure windows,
+five attempts and twenty observations per failure share 64 KiB of tracker and
+pending-payload ownership, retained until ACK/drop even offline. Canonical hooks
+may change any allowed identity/type field; ownership follows the replacement.
+The complete closed envelope is checked against the vendored accepting Draft 7
+schema, followed by evidence semantics and mandatory privacy. Only native JSON
+containers/scalars are copied; custom serializers and container subclasses are
+never invoked by hook validation. Invalid or throwing hooks keep the protected
+original. Exhausted validation or an unfit valid replacement is withheld, so an
+application redaction cannot be undone by a budget fallback.
+
+Native HTTP requests select an ordered prefix by the actual compact UTF-8 JSON
+serializer and remain within the receiving 256-KiB limit. Unsent finalized tails
+stay charged and continue through the existing sender without repeating their
+hooks. Optional SDK evidence is reduced before withholding an unfit primary;
+explicit custom/local transports retain their established budgets. Browser
+relays measure after server identity/token expansion, split downstream requests
+and keep incomplete spools. A legacy custom success remains accepted but cannot
+mark a durable spool delivered; that requires complete canonical acknowledgements.
+Relay chunks share a five-second monotonic forwarding deadline, and spool markers
+are created exclusively with private permissions without following symlinks.
+
+Native HTTP ACK reads stop at 256 KiB and close the response. Requests ask for
+identity encoding; unexpected compressed ACKs are withheld. The five-second
+deadline is checked between streamed reads; HTTPX's synchronous per-read/connect/
+write timeouts remain advisory and an in-progress native read can overrun that
+deadline. Explicit custom transports/config fetchers retain their own timeout,
+allocation and cancellation responsibilities. No additional timer thread or
+inline capture transport is introduced.
+
+Browser relays and Django/Flask/FastAPI relay factories accept the same optional
+`evidence_capabilities` pin. They preserve closed DTOs, protected application
+context and server-owned credentials, and advertise only verified downstream
+support. Opted-in replies keep string `errors` and add indexed `evidence_errors`;
+partial batches return 202, while legacy partial responses retain 400. A durable
+spool accepts locally but is marked delivered only after a valid complete ACK.
+Malformed ACKs cannot grant proof. Only negotiated `invalid_event` rejection of
+an original exception can retry its stripped legacy form once; standalone
+context, policy and authentication rejections do not use this fallback.
+Framework relay adapters read at most the configured body limit plus one byte
+before parsing, and preserve the negotiation query/header through the handler.
+
 Version 2.0.0 protects capture callers with bounded, priority-aware background delivery. Review the [2.0 migration guide](MIGRATION-2.0.md) before upgrading from 1.x.
 
 ## Automatic capture and application filtering
@@ -363,3 +460,22 @@ Apache-2.0. See `LICENSE`.
 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.
+
+## Probe checkpoint guidance
+
+Application instrumentation supplies probe labels and bounded data. Deploy a new
+checkpoint before activating it. Remote activation affects future matching calls
+when policy permits; it does not inject code or recover unretained measurements.
+Built-in runtime/error/device collectors keep their documented SDK settings.
+
+Use fixed labels and allowlisted technical states: `media.preview.checkpoint`
+(stage/input kind/attempt), `auth.session.checkpoint` (observed session presence
+and result), `job.dependency.checkpoint` (named dependency/attempt/result), or
+`cache.preview.checkpoint` (hit/miss/coarse age bucket). Omit customer identifiers,
+tokens/cookies, cache keys, URLs and raw payloads. HTTP 200 or attempt completion
+alone does not establish semantic recovery.
+
+Empty probe data means no matching retained observation for the selected sample
+window. It does not confirm activation delivery to every SDK or execution of a
+label. Check the deployed SDK/wrapper version, instrumentation, scope, expiry,
+policy, sampling and delivery receipts. See the [probe recipes](https://debugbundle.com/docs/probes#bounded-checkpoint-recipes).

debugbundle_python-2.1.1.dist-info/RECORD

@@ -0,0 +1,52 @@
+debugbundle/__init__.py,sha256=OFqqIibB3YlNeuTSynunM_XZ0cuts3Xoh15yNYDVEFs,5685
+debugbundle/acknowledgement.py,sha256=2miOWbuIfElrbkktJHEuL7a2-IqKYUZCpO1UjSaouYw,2461
+debugbundle/before_send.py,sha256=VpE056j_GRtJhhF9er-aLvR665fagPkvUlyXIJxrgbE,2124
+debugbundle/canonical_event.py,sha256=qMwKCMsF-rHnYMnNVB2obDe66ykTXlM5S6chHSJODBI,8054
+debugbundle/capture_hooks.py,sha256=tPZf-EdkI0hintjcFvaxw6KBPXFsMuusrNIqZVYkc_E,2279
+debugbundle/config.py,sha256=3ZOYk35dEnZMqJOI_hvTGOzC17seVPUGxjnX05J15Do,9571
+debugbundle/core.py,sha256=_oLk0FwW9vj1bxHDvW6cs47i0q6v4cjCsuA7k6N3Gr8,28285
+debugbundle/delivery_hooks.py,sha256=hIXmFcKbHDw-3004Mc-pyz4iZGZNR-ZDiBw2xYKCTn4,3455
+debugbundle/diagnostic_budget.py,sha256=dEfse2fqwYgR7IL6FASjqZ8cnq9lLlcwnLJ38utN0G0,7032
+debugbundle/event-envelope.schema.json,sha256=QSAmE8Be_e91T_4_bDrBScdctEXABHpcsjMqyxZKeSI,148624
+debugbundle/event_support.py,sha256=keOpma92Hxer2mOD9ELw-w5MRFYNOsj5A9C9goLdkDE,9046
+debugbundle/evidence_delivery.py,sha256=cadrVo0lq5hNBLhl5woJof_HjAlrqrSgYjvBGfoUWVY,4781
+debugbundle/evidence_http.py,sha256=k490I2Mh9L62A37Le1pnACb-9jVKIMFjsp9u0mYMhuA,1769
+debugbundle/evidence_json.py,sha256=hAiENRzJBKUV-IujHDmK4qEEDtBkb8ZsBo9vyBmGwEo,2349
+debugbundle/evidence_wire.py,sha256=nUY9SiiKoP9LhE31y6q_vyPE5_JieI-ZFDRYL_DX0dQ,16259
+debugbundle/exception_capture.py,sha256=spw8iFQMC5x9Z5jf8zzjDG1BM65W6_WtW72cQUadEkU,4103
+debugbundle/exception_evidence.py,sha256=cclp6aIuuqCM6HHKl4nHezZeswsQQhFZQn2s9fNtSVc,7517
+debugbundle/exception_identity.py,sha256=i7Mb2AFOHlc-NO2eXpjjvpL7QKpeBsoyGAGb7RTXhU8,1781
+debugbundle/exception_snapshot.py,sha256=Q3yX-rPuwyiP5tiyMCHnUE2r5Y5lne7bLb8s8abXtDw,2863
+debugbundle/flush_aggregates.py,sha256=ukHsIUykeGp4YJsesA_9NCUMarg_BAXVuzO4bqJKH3Y,1464
+debugbundle/flush_delivery.py,sha256=0gtluLskyKFWaKMPQSfd16tV256_rCvQrfV5muQOXdw,9009
+debugbundle/ingestion_wire.py,sha256=SGyzAw4uGr9YRsB5hClVXb7il_nn3z0rm0Ofziw51qo,2537
+debugbundle/logger_integrations.py,sha256=sxrw76zaM1sqMspEODSOukySwBdbEPNhsd3xdSsGD5g,4321
+debugbundle/operation_context.py,sha256=oeY0W5su8VG1kWa4L8XrJZcNiAUZsGspjC5y-WGMXJQ,3783
+debugbundle/probe_capture.py,sha256=c1a-ZKHyNeu6CMS5zgi8_wIfpLs5-pe12GEXNMpMTVM,3969
+debugbundle/process_support.py,sha256=rKV_afnK-_tEcPO9Fzv2xvjN5Xt1sGwrZoF9yCsQ6_w,2273
+debugbundle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugbundle/queue_admission.py,sha256=NtXwpB8lZIu0sbtxJUNHXQp_AcgVNDnavEM80rz3raY,2970
+debugbundle/recovery_capture.py,sha256=IOCarb9vmJ3ylwoYnD7GFTRwbra17dx7JCvuCA1isNY,1663
+debugbundle/redaction.py,sha256=mxJgtILpVDUaj8LAhzswfaX1M4Ppyx87lfkhFqbMR8M,9663
+debugbundle/relay.py,sha256=FVEvwrmMxdEDkTk3WDoNHFD0-_2w1OiYYHWAwQFVu9c,17664
+debugbundle/relay_delivery.py,sha256=2EowBh_s5aF6ruPs1PjOXFAZ7IULRe5SBBg8v-bDf9o,9355
+debugbundle/remote_config_client.py,sha256=WrAq-YzixEomJ98pTB05qo2ImfJKayc-HSYRYO1VJg0,3206
+debugbundle/request_capture_policy.py,sha256=fl1EilWAnBQCdGTafRpY0tMlYUoSJK_7hZyJmPHLkeI,1583
+debugbundle/scope_ownership.py,sha256=uB3dpG9blEwFcUbQNAu0jjHoxJlRoliRx7bx8F1YNVE,3141
+debugbundle/structlog_integration.py,sha256=Y9yRikGH3ym_J2FBuxHl_pIVkpdfkaZ6Wh69PQHeLK8,6914
+debugbundle/suppression.py,sha256=V_JvDvcV7tN3EHkfpEJGK1WB2G4nR3GhXvaKd400iFQ,4418
+debugbundle/transport.py,sha256=-MkMFf2rjPrDEGLVe-LHewFtkvVlA40X7XDaHKxVeqE,3343
+debugbundle/trigger_token.py,sha256=YUwIWnnxu1klAVaB8Ltgk_PwWW_PPjq9rzmEbWXeFeM,4455
+debugbundle/integrations/__init__.py,sha256=Jr87ImWXzUXOuFP4WlGleK14VARajSSdGZN_nHt5emw,1161
+debugbundle/integrations/common.py,sha256=iiwf5wDlpujFuWfbO-ziFTn4MtiHBXSIZNXtamhCavg,2014
+debugbundle/integrations/django.py,sha256=vDQGc0ObcHCe4NQbC0ijcXUM-y9GzOVBjDtcHzxyrxw,1828
+debugbundle/integrations/fastapi.py,sha256=-054Z6MogkZIqKR8DHR4jm2nNC5yyZ5vtanpw6g-voE,3414
+debugbundle/integrations/flask.py,sha256=cgyHbsAH96gpNPf_5IGJYzp2va28JdDgXROBsF-Fbyo,2390
+debugbundle/integrations/relay_django.py,sha256=KCo9-5eumVZZKEmzZemL4srCRN7inMB5aeOSUqeEEXE,2378
+debugbundle/integrations/relay_fastapi.py,sha256=oVL5m8SFsbcbxzmDVefGsBk75Ha2DOSymJwDPmHOI-o,2551
+debugbundle/integrations/relay_flask.py,sha256=GPiXNR3feH-KU5GJ8tguOvt0Rr9b776GY8O2SjiLwQs,2169
+debugbundle_python-2.1.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+debugbundle_python-2.1.1.dist-info/METADATA,sha256=TqEiBy0ZO9NdlwuRnCmLq4wYuFlV7hAPYyFNryu6dR0,23904
+debugbundle_python-2.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+debugbundle_python-2.1.1.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
+debugbundle_python-2.1.1.dist-info/RECORD,,