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

debugbundle/delivery_hooks.py

@@ -0,0 +1,62 @@
+"""Finalize one reserved event at a time without retaining uncharged hook output."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from .request_capture_policy import should_capture_request_event
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def replacement_allowed(sdk: DebugBundleSdk, event: dict[str, object]) -> bool:
+    payload = cast(dict[str, object], event["payload"])
+    if event["event_type"] == "log_event":
+        return sdk._log_level_eligible(cast(str, payload["level"]))
+    if event["event_type"] == "request_event":
+        return should_capture_request_event(sdk._capture_policy, payload, payload)
+    if event["event_type"] == "probe_event":
+        return sdk._capture_policy.capture_probe_events == "standalone_when_activated"
+    return True
+
+
+def finalize_batch(
+    sdk: DebugBundleSdk,
+    batch: list[dict[str, object]],
+    generation: int,
+    max_bytes: int,
+) -> list[dict[str, object]] | None:
+    retained_index = 0
+    for snapshot_index, original in enumerate(batch):
+        try:
+            replacement = sdk._apply_before_send_event(original)
+            replacement_bytes = sdk._event_bytes(replacement) if replacement is not None else 0
+        except BaseException:
+            # Hook exceptions/invalid returns already use the protected original
+            # inside apply_before_send. Other failures must withhold telemetry.
+            replacement, replacement_bytes = None, 0
+        with sdk._lock:
+            if generation != sdk._generation:
+                return None
+            original_bytes = sdk._buffer_sizes[id(original)]
+            allowed = replacement is not None and replacement_allowed(sdk, replacement)
+            fits = sdk._buffer_bytes - original_bytes + replacement_bytes <= max_bytes
+            if allowed and fits:
+                assert replacement is not None
+                sdk._buffer[retained_index] = replacement
+                sdk._buffer_sizes.pop(id(original))
+                sdk._buffer_sizes[id(replacement)] = replacement_bytes
+                sdk._buffer_bytes += replacement_bytes - original_bytes
+                retained_index += 1
+                batch[snapshot_index] = replacement
+            else:
+                if allowed and not fits:
+                    sdk._pressure_drops += 1
+                sdk._buffer.pop(retained_index)
+                sdk._buffer_sizes.pop(id(original))
+                sdk._buffer_bytes -= original_bytes
+                sdk._inflight_count -= 1
+                # Release the snapshot reference before another callback can wait.
+                batch[snapshot_index] = {}
+    return [event for event in batch if event]

debugbundle/event_support.py

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

debugbundle/exception_snapshot.py

@@ -0,0 +1,74 @@
+"""Bounded exception details without invoking application-defined string renderers or source reads."""
+
+from __future__ import annotations
+
+MAX_CAUSES = 8
+MAX_FRAMES = 64
+MAX_STACK_CHARS = 16 * 1024
+
+
+def exception_details(error: BaseException) -> tuple[str, str, str]:
+    name = _exception_name(error)
+    message = _safe_message(error)
+    lines: list[str] = []
+    visited: set[int] = set()
+    current: BaseException | None = error
+    frames_seen = 0
+
+    while current is not None and len(visited) < MAX_CAUSES and id(current) not in visited:
+        visited.add(id(current))
+        current_name = _exception_name(current)
+        lines.append(f"{current_name}: {_safe_message(current)}")
+        try:
+            tb = BaseException.__dict__["__traceback__"].__get__(current)
+        except BaseException:
+            tb = None
+        while tb is not None and frames_seen < MAX_FRAMES:
+            try:
+                code = tb.tb_frame.f_code
+                filename = code.co_filename[:256]
+                function = code.co_name[:128]
+                line = tb.tb_lineno
+                tb = tb.tb_next
+            except BaseException:
+                break
+            lines.append(f"  File {filename}, line {line}, in {function}")
+            frames_seen += 1
+        if frames_seen >= MAX_FRAMES:
+            lines.append("  ... additional frames omitted")
+            break
+        try:
+            next_error = BaseException.__dict__["__cause__"].__get__(current)
+            if next_error is None and not BaseException.__dict__["__suppress_context__"].__get__(current):
+                next_error = BaseException.__dict__["__context__"].__get__(current)
+        except BaseException:
+            next_error = None
+        current = next_error
+        if current is not None:
+            lines.append("Caused by:")
+
+    return name, message, "\n".join(lines)[:MAX_STACK_CHARS]
+
+
+def _exception_name(error: BaseException) -> str:
+    # Invoke built-in descriptors directly: subclass properties, __getattribute__,
+    # metaclass accessors, and truthiness must never execute on capture callers.
+    return str(type.__dict__["__name__"].__get__(type(error)))[:256]
+
+
+def _safe_message(error: BaseException) -> str:
+    try:
+        args = BaseException.__dict__["args"].__get__(error)
+        if not isinstance(args, tuple):
+            return "[message unavailable]"
+        parts: list[str] = []
+        for value in args[:4]:
+            if issubclass(type(value), str):
+                parts.append(str.__getitem__(value, slice(0, 1024)))
+            elif type(value) in (int, float, bool):
+                parts.append(str(value))
+            else:
+                parts.append("[unsupported argument]")
+        return ", ".join(parts)[:4096]
+    except BaseException:
+        return "[message unavailable]"

debugbundle/flush_aggregates.py

@@ -0,0 +1,37 @@
+"""Prepare bounded SDK summaries away from the capture admission lock."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def prepare_flush_aggregates(
+    sdk: DebugBundleSdk,
+    suppression: list[dict[str, object]],
+    pressure_count: int,
+) -> tuple[list[tuple[dict[str, object], int]], tuple[dict[str, object], int] | None]:
+    prepared: list[tuple[dict[str, object], int]] = []
+    for aggregate in suppression:
+        event_type = aggregate.get("event_type")
+        payload = aggregate.get("payload")
+        if not isinstance(event_type, str) or not isinstance(payload, dict):
+            continue
+        aggregate.update(sdk._base_event(event_type, cast(dict[str, object], payload)))
+        protected = sdk._protect_event(aggregate)
+        if protected is not None:
+            prepared.append((protected, sdk._event_bytes(protected)))
+
+    pressure: tuple[dict[str, object], int] | None = None
+    if pressure_count:
+        event = sdk._base_event("log_event", {
+            "message": f"{pressure_count} SDK events suppressed due to queue pressure",
+            "level": "warning",
+            "attributes": {"suppressed_count": pressure_count, "reason": "queue_pressure"},
+        })
+        protected = sdk._protect_event(event)
+        if protected is not None:
+            pressure = (protected, sdk._event_bytes(protected))
+    return prepared, pressure

debugbundle/probe_capture.py

@@ -0,0 +1,101 @@
+"""Probe capture with short admission/commit locks and no application callback under them."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
+
+from .capture_hooks import try_capture_lock
+from .event_support import iso_now
+from .process_support import ensure_current_process
+from .redaction import sanitize_telemetry
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+@dataclass
+class ProbeEntry:
+    label: str
+    data: dict[str, object]
+    timestamp: str
+
+
+def capture_probe(
+    sdk: DebugBundleSdk,
+    label: str,
+    data: object | Callable[[], object],
+    opts: Mapping[str, object] | None,
+) -> None:
+    try:
+        ensure_current_process(sdk)
+        options = dict(opts or {})
+        now_ms = int(sdk._time_provider() * 1000)
+        if not try_capture_lock(sdk):
+            sdk._pressure_drops += 1
+            return
+        try:
+            if not sdk._enabled:
+                return
+            heavy = options.get("heavy") is True
+            directives = sdk._find_matching_probe_directives(label, now_ms)
+            if heavy and not directives:
+                return
+            if label not in sdk._probe_buffers and len(sdk._probe_buffers) >= sdk._max_probe_labels:
+                return
+            redact_fields = set(sdk._redact_fields)
+            generation = sdk._generation
+        finally:
+            sdk._lock.release()
+
+        # A host supplier, mapping iterator, privacy walk, clock, or serializer may
+        # be slow or hostile. None may hold the capture lock or block exceptions.
+        protected_label = sanitize_telemetry(label, redact_fields)
+        value = data() if callable(data) else data
+        if not isinstance(value, Mapping):
+            value = {"value": value}
+        protected_value = sanitize_telemetry(dict(value), redact_fields)
+        if not isinstance(protected_label, str) or not isinstance(protected_value, dict):
+            return
+        label = protected_label
+        redacted_value = cast(dict[str, object], protected_value)
+        entry = None if heavy else ProbeEntry(label, redacted_value, iso_now(sdk._time_provider))
+
+        prepared: list[tuple[str, dict[str, object], int]] = []
+        for directive in directives:
+            payload: dict[str, object] = {
+                "label": label,
+                "activation_id": directive.id,
+                "probe_label_pattern": directive.label_pattern,
+                "data": dict(redacted_value),
+            }
+            event = sdk._protect_event(sdk._base_event("probe_event", payload))
+            if event is not None:
+                prepared.append((directive.id, event, sdk._event_bytes(event)))
+
+        refreshed_now_ms = int(sdk._time_provider() * 1000)
+        if not try_capture_lock(sdk):
+            sdk._pressure_drops += 1
+            return
+        try:
+            if not sdk._enabled or generation != sdk._generation:
+                return
+            if label not in sdk._probe_buffers and len(sdk._probe_buffers) >= sdk._max_probe_labels:
+                return
+            active_ids = {directive.id for directive in sdk._find_matching_probe_directives(label, refreshed_now_ms)}
+            if heavy and not active_ids:
+                return
+            if entry is not None:
+                bucket = sdk._probe_buffers.setdefault(label, deque(maxlen=sdk._max_probe_entries_per_label))
+                bucket.append(entry)
+            if sdk._capture_policy.capture_probe_events == "standalone_when_activated":
+                for directive_id, event, event_bytes in prepared:
+                    if directive_id in active_ids:
+                        sdk._offer_protected_event(event, event_bytes)
+        finally:
+            sdk._lock.release()
+    except BaseException:
+        # Probe callbacks and SDK failures must remain observational.
+        return

debugbundle/process_support.py

@@ -0,0 +1,59 @@
+"""Discard pre-fork SDK ownership without touching inherited thread locks."""
+
+from __future__ import annotations
+
+import os
+import threading
+from contextvars import ContextVar
+from typing import TYPE_CHECKING
+
+from .suppression import EventSuppressionTracker
+from .transport import HttpTransport
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def ensure_current_process(sdk: DebugBundleSdk) -> None:
+    pid = os.getpid()
+    if sdk._pid == pid:
+        return
+
+    # The parent may have forked while another thread owned its lock. Never
+    # acquire, cancel, close, or join any inherited thread-owned object here.
+    sdk._lock = threading.RLock()
+    sdk._timer = None
+    sdk._remote_config_timer = None
+    sdk._initial_config_ready = threading.Event()
+    sdk._initial_config_ready.set()
+    sdk._generation += 1
+    sdk._sending = False
+    sdk._inflight_count = 0
+    sdk._timer_due_at = 0.0
+    sdk._buffer = []
+    sdk._buffer_sizes = {}
+    sdk._buffer_bytes = 0
+    sdk._pending_low_priority = 0
+    sdk._context = {}
+    sdk._scoped_context = ContextVar("debugbundle_scoped_context", default=None)
+    sdk._request_trigger_directives = ContextVar("debugbundle_request_trigger_directives", default=None)
+    sdk._probe_buffers = {}
+    sdk._suppression = EventSuppressionTracker()
+    sdk._pressure_drops = 0
+    sdk._last_pressure_report_at = 0.0
+    sdk._retry_after = 0.0
+    sdk._last_event_at = None
+    sdk._consecutive_failures = 0
+    sdk._remote_config_etag = None
+    sdk._remote_config_snapshot = None
+
+    # Retain the parent's effective policy until the child explicitly reinitializes;
+    # resetting to a default here could widen capture after a restricted policy.
+    if sdk._http_transport is not None:
+        sdk._http_transport = None
+        try:
+            sdk._http_transport = HttpTransport(sdk._endpoint)
+        except Exception:
+            pass
+        sdk._transport = sdk._http_transport
+    sdk._pid = pid

debugbundle/queue_admission.py

@@ -0,0 +1,39 @@
+"""Constant-time overload admission and pending-event priority helpers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def high_priority_event(event: dict[str, object]) -> bool:
+    if event.get("event_type") == "backend_exception":
+        return True
+    payload = event.get("payload")
+    return isinstance(payload, dict) and (
+        payload.get("level") in ("error", "critical")
+        or (event.get("event_type") == "request_event" and type(payload.get("response_status")) is int
+            and payload["response_status"] >= 500)
+    )
+
+
+def may_prepare_event(sdk: DebugBundleSdk, high_priority: bool, max_events: int, max_bytes: int) -> bool:
+    if len(sdk._buffer) < max_events and sdk._buffer_bytes < max_bytes:
+        return True
+    if high_priority and sdk._pending_low_priority > 0:
+        return True
+    sdk._pressure_drops = min(2**63 - 1, sdk._pressure_drops + 1)
+    return False
+
+
+def evict_low_priority(sdk: DebugBundleSdk) -> bool:
+    for index in range(sdk._inflight_count, len(sdk._buffer)):
+        if not high_priority_event(sdk._buffer[index]):
+            evicted = sdk._buffer.pop(index)
+            sdk._buffer_bytes -= sdk._buffer_sizes.pop(id(evicted))
+            sdk._pending_low_priority -= 1
+            sdk._pressure_drops = min(2**63 - 1, sdk._pressure_drops + 1)
+            return True
+    return False

debugbundle/request_capture_policy.py

@@ -0,0 +1,45 @@
+"""Metadata-only request admission before request payload construction."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .config import CapturePolicy
+from .event_support import is_immediate_request_incident_status
+
+
+def should_capture_request_event(
+    policy: CapturePolicy,
+    request: Mapping[str, object] | None,
+    response: Mapping[str, object] | None,
+) -> bool:
+    status_code = None
+    if response is not None:
+        candidate = response.get("status_code") or response.get("response_status")
+        if isinstance(candidate, int):
+            status_code = candidate
+    request_path = None
+    http_method = None
+    if request is not None:
+        path_candidate = request.get("path") or request.get("url")
+        method_candidate = request.get("method")
+        request_path = path_candidate if isinstance(path_candidate, str) else None
+        http_method = method_candidate if isinstance(method_candidate, str) else None
+    if is_immediate_request_incident_status(
+        status_code,
+        policy.preset,
+        policy.immediate_client_error_statuses,
+        request_path,
+        http_method,
+        policy.immediate_client_error_path_rules,
+    ):
+        return True
+    if policy.capture_request_events == "off":
+        return False
+    if policy.capture_request_events == "all":
+        return True
+    if response is None or status_code is None:
+        return policy.capture_request_events == "filtered"
+    if policy.capture_request_events == "failures_only":
+        return status_code >= 500
+    return False

debugbundle/suppression.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import OrderedDict
 from dataclasses import dataclass
 from hashlib import sha256
 
@@ -9,6 +10,7 @@ LOOP_THRESHOLD = 10
 LOOP_RESET_AFTER_SECONDS = 60.0
 LOOP_CHECKPOINT_SECONDS = 30.0
 MAX_NORMAL_EVENTS_PER_WINDOW = 3
+MAX_TRACKED_FINGERPRINTS = 2_048
 
 
 @dataclass
@@ -27,25 +29,30 @@ class SuppressionState:
 
 class EventSuppressionTracker:
     def __init__(self) -> None:
-        self._states: dict[str, SuppressionState] = {}
+        self._states: OrderedDict[str, SuppressionState] = OrderedDict()
 
     def should_capture(self, key: str, now: float) -> bool:
-        state = self._states.get(key)
+        fingerprint = sha256(key.encode("utf-8")).hexdigest()
+        state = self._states.get(fingerprint)
         if state is None:
+            if len(self._states) >= MAX_TRACKED_FINGERPRINTS:
+                self._states.popitem(last=False)
             state = SuppressionState(
                 window_started_at=now,
                 loop_window_started_at=now,
                 last_seen_at=now,
             )
-            self._states[key] = state
+            self._states[fingerprint] = state
+        else:
+            self._states.move_to_end(fingerprint)
 
         if state.suppression_mode and now - state.last_seen_at >= LOOP_RESET_AFTER_SECONDS:
-            self._states[key] = SuppressionState(
+            self._states[fingerprint] = SuppressionState(
                 window_started_at=now,
                 loop_window_started_at=now,
                 last_seen_at=now,
             )
-            state = self._states[key]
+            state = self._states[fingerprint]
 
         if now - state.window_started_at >= DUPLICATE_WINDOW_SECONDS:
             state.window_started_at = now
@@ -94,7 +101,7 @@ class EventSuppressionTracker:
                 {
                     "event_type": "error_suppressed",
                     "payload": {
-                        "fingerprint": sha256(key.encode("utf-8")).hexdigest(),
+                        "fingerprint": key,
                         "suppressed_count": state.pending_suppressed_count,
                         "first_seen": _to_iso(state.pending_first_seen_at),
                         "last_seen": _to_iso(state.pending_last_seen_at),

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-1.5.0.dist-info → debugbundle_python-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 1.5.0
+Version: 2.0.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -51,6 +51,8 @@ Use this package to capture Python backend exceptions, request metadata, structu
 
 Requires Python 3.10 or newer.
 
+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
 
 `capture_logging()` attaches the stdlib logging handler and detects installed structlog/loguru integrations. Obtain structlog loggers after attachment. Structlog level filters and `DropEvent` processors run before capture; stdlib-backed structlog loggers also honor logger filters, disabled state and `logging.disable()`. Bound context and async logging are supported. SDK disposal stops capture through cached proxies. DebugBundle has its own minimum capture level; destination-specific filters on other handlers or Loguru sinks do not configure the DebugBundle handler.
@@ -99,6 +101,7 @@ debugbundle.capture_log("payment retry failed", level="warning", context={"order
 debugbundle.capture_message("worker started")
 debugbundle.probe("checkout.cart", {"item_count": len(cart.items)})
 
+# Use only during controlled teardown or tests, never on a request path.
 debugbundle.flush()
 ```
 
@@ -283,8 +286,10 @@ Post-V1 planned expansions from `spec/sdk-language-targets.md` remain out of sco
 ## Safety Defaults
 
 - SDK failures are caught internally and do not crash the host process.
+- A forked worker starts with a fresh SDK queue, lock, context and built-in HTTP client. Initialize the SDK in each child when remote configuration must poll there; custom transports must be fork-safe.
 - Sensitive fields are redacted before transport.
 - Duplicate event storms are suppressed locally.
+- Full-queue capture sheds warning/request noise before context scans. Exceptions, ERROR logs, and 5xx request incidents have priority over pending lower-priority events; all-error overloads are bounded and summarized.
 - Runtime context excludes environment variables.
 - Browser relay requests cannot smuggle server-side credentials.
 
@@ -352,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-1.5.0.dist-info → debugbundle_python-2.0.1.dist-info}/RECORD

@@ -1,17 +1,25 @@
 debugbundle/__init__.py,sha256=QH5RY2Cdp3Ry5PNSAhiV9akOMoS2pERRqowFnZ94roc,5131
-debugbundle/acknowledgement.py,sha256=tyI8XLRG9N3-Weo6uiGrAlf_O4tjptVe1x1cG7RjrMc,2314
+debugbundle/acknowledgement.py,sha256=2miOWbuIfElrbkktJHEuL7a2-IqKYUZCpO1UjSaouYw,2461
 debugbundle/before_send.py,sha256=_tmV6ovHUBIxfQPMQ8a0C6r91IAnd4DVs8UcjsKhqX0,7792
+debugbundle/capture_hooks.py,sha256=70Q6ske8JulyuYpeE9FohvMreytf4DUrj4QW9f2-o2Q,1940
 debugbundle/config.py,sha256=ENRSR5jUI7xYdBqUakWws3GIjBk00GWFmwXVE_iQp2Y,9296
-debugbundle/core.py,sha256=XnaHLLfo9cNHNy8n-Q2rG5SRQx9pXE3t5-hwpw2F93Y,34639
-debugbundle/event_support.py,sha256=TSaqYXla6NACknU1nIofe4gVPQAkUkB-yrav09FTvpA,9046
+debugbundle/core.py,sha256=uu2_VPvXwmccwwCcK1Y1kJgfehMOCrhFjV4L14X0cok,39467
+debugbundle/delivery_hooks.py,sha256=BUqtHuEv1MDOSLv0sUP6D582c06JofsbXhi7I7Y5IGc,2691
+debugbundle/event_support.py,sha256=keOpma92Hxer2mOD9ELw-w5MRFYNOsj5A9C9goLdkDE,9046
+debugbundle/exception_snapshot.py,sha256=_2p55F572sL7_ogBL6Raa137HRyUqvSaHVMwpKiC8fs,2831
+debugbundle/flush_aggregates.py,sha256=ukHsIUykeGp4YJsesA_9NCUMarg_BAXVuzO4bqJKH3Y,1464
 debugbundle/logger_integrations.py,sha256=T6LR10_DgDS8C-CUPxtC1kZz3qfX5j0B2YUV7LxDovk,3572
+debugbundle/probe_capture.py,sha256=c1a-ZKHyNeu6CMS5zgi8_wIfpLs5-pe12GEXNMpMTVM,3969
+debugbundle/process_support.py,sha256=D1aFhaP1wOGfMdzkdtEhO54R3XWa8dLCZlfWHWN3qA4,1962
 debugbundle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugbundle/queue_admission.py,sha256=QtFengGZ4KEVbu1UqSp3u8eLucQeS9dGIwrzq62A5cY,1433
 debugbundle/redaction.py,sha256=mxJgtILpVDUaj8LAhzswfaX1M4Ppyx87lfkhFqbMR8M,9663
 debugbundle/relay.py,sha256=9HkEEVZpqrebzH6A-sSuFVuFjyLg07JuTMpMG8pu7SY,14726
 debugbundle/relay_delivery.py,sha256=VL-nIgJR6mYXqKy-EbA0USWeY_iS_uAr1KBzrnwBnnk,4676
+debugbundle/request_capture_policy.py,sha256=fl1EilWAnBQCdGTafRpY0tMlYUoSJK_7hZyJmPHLkeI,1583
 debugbundle/structlog_integration.py,sha256=hDwCGXTQ8GAjnx2jwlRbpnvLE0y798kFFMsSB3iqOrM,6061
-debugbundle/suppression.py,sha256=XMn0GfF_-WZk2wHWk3KfbO5_u5QhEunues5h3jOInLs,4098
-debugbundle/transport.py,sha256=V289FwFWL6KV5gyzOsesluEMbpRobm_FHu3x8BpOYKU,2014
+debugbundle/suppression.py,sha256=V_JvDvcV7tN3EHkfpEJGK1WB2G4nR3GhXvaKd400iFQ,4418
+debugbundle/transport.py,sha256=_6L6XdjSSm-YzWsQLH8E5xku6yMS8wBYFpOwuYtY2cg,2764
 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
@@ -21,8 +29,8 @@ debugbundle/integrations/flask.py,sha256=cgyHbsAH96gpNPf_5IGJYzp2va28JdDgXROBsF-
 debugbundle/integrations/relay_django.py,sha256=Wj8BE9D5otU2KmtjgqdKIJ-BvXVcagCKgpLYvnPZ6WE,2281
 debugbundle/integrations/relay_fastapi.py,sha256=-Zl6bvhYMLii__mP6-UvSdwxS5VKsb9OZvk-yy-3hEw,2227
 debugbundle/integrations/relay_flask.py,sha256=VFHkDTJy4LkZzL_Ry_Ba-e_gW6UTG4PBwnLcvB_oXuQ,2011
-debugbundle_python-1.5.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-debugbundle_python-1.5.0.dist-info/METADATA,sha256=X1Q7PLLF5B1H2GYePJjV3wCuvkU2_s_q0ynr46dJO74,14569
-debugbundle_python-1.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-debugbundle_python-1.5.0.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
-debugbundle_python-1.5.0.dist-info/RECORD,,
+debugbundle_python-2.0.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+debugbundle_python-2.0.1.dist-info/METADATA,sha256=5el7IjAErunxEkDXAZNfD8eIirCrVCgB5I4kAYBxC88,16205
+debugbundle_python-2.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+debugbundle_python-2.0.1.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
+debugbundle_python-2.0.1.dist-info/RECORD,,