debugbundle-python 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

debugbundle/integrations/relay_django.py

@@ -11,12 +11,30 @@ def create_django_relay_view(
     max_body_bytes: int = 262_144,
     rate_limit_per_minute: int = 60,
     on_accept: Any = None,
+    project_mode: str | None = None,
+    project_token: str | None = None,
+    endpoint: str | None = None,
+    local_events_dir: str | None = None,
+    spool_dir: str | None = None,
+    durable_write: bool = True,
+    service: str | None = None,
+    environment: str | None = None,
+    forward_transport: Any = None,
 ) -> Any:
     handler = BrowserRelayHandler(
         allowed_origins=allowed_origins or [],
         max_body_bytes=max_body_bytes,
         rate_limit_per_minute=rate_limit_per_minute,
         on_accept=on_accept,
+        project_mode=project_mode,
+        project_token=project_token,
+        endpoint=endpoint,
+        local_events_dir=local_events_dir,
+        spool_dir=spool_dir,
+        durable_write=durable_write,
+        service=service,
+        environment=environment,
+        forward_transport=forward_transport,
     )
 
     def view(request: Any) -> Any:

debugbundle/integrations/relay_fastapi.py

@@ -14,6 +14,15 @@ def create_fastapi_relay_handler(
     max_body_bytes: int = 262_144,
     rate_limit_per_minute: int = 60,
     on_accept: Any = None,
+    project_mode: str | None = None,
+    project_token: str | None = None,
+    endpoint: str | None = None,
+    local_events_dir: str | None = None,
+    spool_dir: str | None = None,
+    durable_write: bool = True,
+    service: str | None = None,
+    environment: str | None = None,
+    forward_transport: Any = None,
     route_path: str = "/debugbundle/browser",
 ) -> Any:
     handler = BrowserRelayHandler(
@@ -21,6 +30,15 @@ def create_fastapi_relay_handler(
         max_body_bytes=max_body_bytes,
         rate_limit_per_minute=rate_limit_per_minute,
         on_accept=on_accept,
+        project_mode=project_mode,
+        project_token=project_token,
+        endpoint=endpoint,
+        local_events_dir=local_events_dir,
+        spool_dir=spool_dir,
+        durable_write=durable_write,
+        service=service,
+        environment=environment,
+        forward_transport=forward_transport,
     )
 
     def register(app: Any) -> None:

debugbundle/integrations/relay_flask.py

@@ -11,6 +11,15 @@ def create_flask_relay_handler(
     max_body_bytes: int = 262_144,
     rate_limit_per_minute: int = 60,
     on_accept: Any = None,
+    project_mode: str | None = None,
+    project_token: str | None = None,
+    endpoint: str | None = None,
+    local_events_dir: str | None = None,
+    spool_dir: str | None = None,
+    durable_write: bool = True,
+    service: str | None = None,
+    environment: str | None = None,
+    forward_transport: Any = None,
     route_path: str = "/debugbundle/browser",
 ) -> Any:
     handler = BrowserRelayHandler(
@@ -18,6 +27,15 @@ def create_flask_relay_handler(
         max_body_bytes=max_body_bytes,
         rate_limit_per_minute=rate_limit_per_minute,
         on_accept=on_accept,
+        project_mode=project_mode,
+        project_token=project_token,
+        endpoint=endpoint,
+        local_events_dir=local_events_dir,
+        spool_dir=spool_dir,
+        durable_write=durable_write,
+        service=service,
+        environment=environment,
+        forward_transport=forward_transport,
     )
 
     def register(app: Any) -> None:

debugbundle/relay.py

@@ -2,10 +2,18 @@ from __future__ import annotations
 
 import json
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from typing import Any
 
+from .relay_delivery import (
+    AtomicRelayFileTransport,
+    RelayForwardTransport,
+    mark_spool_file_delivered,
+    resolve_default_local_events_dir,
+    resolve_default_relay_spool_dir,
+)
+
 DEFAULT_MAX_BODY_BYTES = 262_144
 DEFAULT_RATE_LIMIT_PER_MINUTE = 60
 BROWSER_SDK_NAME = "@debugbundle/sdk-browser"
@@ -41,12 +49,32 @@ class BrowserRelayHandler:
     max_body_bytes: int = DEFAULT_MAX_BODY_BYTES
     rate_limit_per_minute: int = DEFAULT_RATE_LIMIT_PER_MINUTE
     on_accept: Callable[[BrowserRelayAcceptedBatch], None] | None = None
+    project_mode: str | None = None
+    project_token: str | None = None
+    endpoint: str | None = None
+    local_events_dir: str | None = None
+    spool_dir: str | None = None
+    durable_write: bool = True
+    service: str | None = None
+    environment: str | None = None
+    forward_transport: Callable[[Mapping[str, object]], object] | None = None
 
     def __post_init__(self) -> None:
         self.allowed_origins = [o for o in self.allowed_origins if o]
         self.max_body_bytes = max(1, self.max_body_bytes)
         self.rate_limit_per_minute = max(1, self.rate_limit_per_minute)
+        normalized_project_mode = (self.project_mode or "").strip().lower()
+        self.project_mode = normalized_project_mode or None
+        if self.project_mode not in {None, "connected", "local-only"}:
+            self.project_mode = None
         self._rate_limit_state: dict[str, list[int]] = {}
+        self._local_transports: dict[str, AtomicRelayFileTransport] = {}
+        self._spool_transports: dict[str, AtomicRelayFileTransport] = {}
+        self._forwarder = (
+            RelayForwardTransport(self.endpoint, self.forward_transport)
+            if self.project_mode == "connected" and self.endpoint is not None
+            else None
+        )
 
     def handle(self, request: dict[str, Any]) -> BrowserRelayResponse:
         method = str(request.get("method", "POST")).upper()
@@ -106,22 +134,29 @@ class BrowserRelayHandler:
                 errors.append(f"batch[{index}]: Unsupported browser relay event type {type_label}.")
                 continue
 
-            sanitized = _sanitize_event(candidate)
+            sanitized = _sanitize_event(candidate, service_override=self.service, environment_override=self.environment)
             if sanitized is None:
                 errors.append(f"batch[{index}]: Invalid browser relay event payload.")
                 continue
 
             accepted_events.append(sanitized)
 
-        if accepted_events and self.on_accept is not None:
-            self.on_accept(
-                BrowserRelayAcceptedBatch(
-                    events=accepted_events,
-                    headers=_strip_sensitive_headers(headers),
-                    ip_address=ip_address,
-                    received_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-                )
-            )
+        if accepted_events:
+            try:
+                if not self._deliver_events(accepted_events):
+                    return BrowserRelayResponse(500)
+
+                if self.on_accept is not None:
+                    self.on_accept(
+                        BrowserRelayAcceptedBatch(
+                            events=accepted_events,
+                            headers=_strip_sensitive_headers(headers),
+                            ip_address=ip_address,
+                            received_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                        )
+                    )
+            except Exception:
+                return BrowserRelayResponse(500)
 
         if errors:
             return BrowserRelayResponse(
@@ -134,6 +169,54 @@ class BrowserRelayHandler:
             {"accepted": len(accepted_events), "rejected": 0, "errors": []},
         )
 
+    def _deliver_events(self, accepted_events: list[dict[str, Any]]) -> bool:
+        if self.project_mode is None:
+            return True
+
+        service_name = self.service or str(accepted_events[0]["service"]["name"])
+
+        if self.project_mode == "local-only":
+            local_transport = self._local_transports.get(service_name)
+            if local_transport is None:
+                local_transport = AtomicRelayFileTransport(
+                    self.local_events_dir or resolve_default_local_events_dir(),
+                    service_name,
+                )
+                self._local_transports[service_name] = local_transport
+
+            return local_transport.write(accepted_events).status_code == 202
+
+        if self.project_mode != "connected":
+            return True
+
+        if self.durable_write:
+            spool_transport = self._spool_transports.get(service_name)
+            if spool_transport is None:
+                spool_transport = AtomicRelayFileTransport(
+                    self.spool_dir or resolve_default_relay_spool_dir(),
+                    service_name,
+                )
+                self._spool_transports[service_name] = spool_transport
+
+            spool_write_result = spool_transport.write(accepted_events)
+            if spool_write_result.status_code != 202:
+                return False
+
+            configured, succeeded = self._forward_connected_events(accepted_events)
+            if succeeded and spool_write_result.written_file_path is not None:
+                mark_spool_file_delivered(spool_write_result.written_file_path)
+
+            return True if configured or spool_write_result.written_file_path is not None else False
+
+        configured, succeeded = self._forward_connected_events(accepted_events)
+        return configured and succeeded
+
+    def _forward_connected_events(self, accepted_events: list[dict[str, Any]]) -> tuple[bool, bool]:
+        if self._forwarder is None or not self.project_token:
+            return (False, False)
+
+        return self._forwarder.send(self.project_token, accepted_events)
+
     def _is_origin_allowed(self, headers: dict[str, str]) -> bool:
         origin = _source_origin(headers)
         if origin is None:
@@ -210,7 +293,11 @@ def _strip_sensitive_headers(headers: dict[str, str]) -> dict[str, str]:
     return sanitized
 
 
-def _sanitize_event(event: dict[str, Any]) -> dict[str, Any] | None:
+def _sanitize_event(
+    event: dict[str, Any],
+    service_override: str | None = None,
+    environment_override: str | None = None,
+) -> dict[str, Any] | None:
     schema_version = event.get("schema_version")
     event_id = event.get("event_id")
     event_type = event.get("event_type")
@@ -239,6 +326,11 @@ def _sanitize_event(event: dict[str, Any]) -> dict[str, Any] | None:
     if not isinstance(service_name, str) or not service_name or not isinstance(environment, str) or not environment:
         return None
 
+    normalized_service_name = service_override or service_name
+    normalized_environment = environment_override or environment
+    if not normalized_service_name or not normalized_environment:
+        return None
+
     sanitized: dict[str, Any] = {
         "schema_version": schema_version,
         "event_id": event_id,
@@ -247,16 +339,29 @@ def _sanitize_event(event: dict[str, Any]) -> dict[str, Any] | None:
         "sdk_name": BROWSER_SDK_NAME,
         "sdk_version": sdk_version,
         "service": {
-            "name": service_name,
-            "environment": environment,
+            "name": normalized_service_name,
+            "environment": normalized_environment,
         },
         "payload": payload,
     }
 
+    runtime = service.get("runtime")
+    if isinstance(runtime, str) or runtime is None:
+        sanitized["service"]["runtime"] = runtime
+
+    framework = service.get("framework")
+    if isinstance(framework, str) or framework is None:
+        sanitized["service"]["framework"] = framework
+
     correlation = event.get("correlation")
     if isinstance(correlation, dict):
-        trace_id = correlation.get("trace_id")
-        if isinstance(trace_id, str) or trace_id is None:
-            sanitized["correlation"] = {"trace_id": trace_id}
+        normalized_correlation: dict[str, Any] = {}
+        for key in ("request_id", "trace_id", "session_id", "user_id_hash"):
+            value = correlation.get(key)
+            if isinstance(value, str) or value is None:
+                normalized_correlation[key] = value
+
+        if normalized_correlation:
+            sanitized["correlation"] = normalized_correlation
 
     return sanitized

debugbundle/relay_delivery.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import secrets
+import threading
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from .transport import HttpTransport, coerce_transport_response
+
+LOCAL_EVENTS_DIRECTORY_MODE = 0o700
+LOCAL_EVENT_FILE_MODE = 0o600
+RELAY_SPOOL_DELIVERED_MARKER_SUFFIX = ".delivered"
+OPTIONAL_NOFOLLOW_FLAG = getattr(os, "O_NOFOLLOW", 0)
+
+
+@dataclass(frozen=True)
+class RelayWriteResult:
+    status_code: int
+    written_file_path: str | None = None
+
+
+def resolve_default_local_events_dir(cwd: str | None = None) -> str:
+    return os.path.join(cwd or os.getcwd(), ".debugbundle", "local", "events")
+
+
+def resolve_default_relay_spool_dir(cwd: str | None = None) -> str:
+    return os.path.join(cwd or os.getcwd(), ".debugbundle", "local", "browser-relay-spool")
+
+
+def attach_project_token(events: list[dict[str, Any]], project_token: str) -> list[dict[str, Any]]:
+    return [{**event, "project_token": project_token} for event in events]
+
+
+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
+    except OSError:
+        # Durable acceptance already happened at the spool write; marker creation is maintenance metadata only.
+        return
+
+
+class AtomicRelayFileTransport:
+    def __init__(self, events_dir: str, service_name: str) -> None:
+        self._events_dir = os.path.abspath(os.path.normpath(events_dir))
+        self._service_name = _sanitize_service_name(service_name)
+        self._sequence = 0
+        self._dir_ensured = False
+        self._lock = threading.Lock()
+
+    def write(self, events: list[dict[str, Any]]) -> RelayWriteResult:
+        if not events:
+            return RelayWriteResult(status_code=202)
+
+        try:
+            with self._lock:
+                if not self._dir_ensured:
+                    os.makedirs(self._events_dir, mode=LOCAL_EVENTS_DIRECTORY_MODE, exist_ok=True)
+                    self._dir_ensured = True
+
+                timestamp = int(time.time() * 1000)
+                self._sequence += 1
+                filename = f"{timestamp}-{self._sequence}-{self._service_name}.events.json"
+                final_path = os.path.join(self._events_dir, filename)
+                tmp_path = f"{final_path}.tmp-{secrets.token_hex(8)}"
+
+                _assert_not_symlink(final_path)
+                _write_secure_temp_file(tmp_path, json.dumps(events, separators=(",", ":")))
+                os.replace(tmp_path, final_path)
+                return RelayWriteResult(status_code=202, written_file_path=final_path)
+        except OSError:
+            _cleanup_temp_files(self._events_dir)
+            return RelayWriteResult(status_code=500)
+
+
+class RelayForwardTransport:
+    def __init__(self, endpoint: str, transport: Callable[[Mapping[str, object]], object] | None = None) -> None:
+        self._transport = transport or HttpTransport(endpoint)
+
+    def send(self, project_token: str, events: list[dict[str, Any]]) -> tuple[bool, bool]:
+        if not project_token:
+            return (False, False)
+
+        try:
+            response = coerce_transport_response(
+                self._transport(
+                    {
+                        "project_token": project_token,
+                        "events": attach_project_token(events, project_token),
+                    }
+                )
+            )
+        except Exception:
+            return (True, False)
+
+        return (True, 200 <= response.status_code < 300)
+
+
+def _sanitize_service_name(service_name: str) -> str:
+    normalized = re.sub(r"[^A-Za-z0-9._-]+", "-", service_name.strip())
+    normalized = re.sub(r"-+", "-", normalized).strip("-")
+    return normalized or "service"
+
+
+def _assert_not_symlink(target_path: str) -> None:
+    try:
+        if os.path.islink(target_path):
+            raise OSError("symlink_path_rejected")
+    except OSError:
+        raise
+
+
+def _write_secure_temp_file(tmp_path: str, payload: str) -> None:
+    flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY | OPTIONAL_NOFOLLOW_FLAG
+    encoded = payload.encode("utf-8")
+    fd = os.open(tmp_path, flags, LOCAL_EVENT_FILE_MODE)
+    try:
+        os.write(fd, encoded)
+    finally:
+        os.close(fd)
+
+
+def _cleanup_temp_files(events_dir: str) -> None:
+    try:
+        for entry in os.listdir(events_dir):
+            if ".tmp-" not in entry:
+                continue
+            try:
+                os.remove(os.path.join(events_dir, entry))
+            except OSError:
+                continue
+    except OSError:
+        return

{debugbundle_python-0.1.5.dist-info → debugbundle_python-0.1.6.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 0.1.5
+Version: 0.1.6
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: AGPL-3.0-only
-Project-URL: Homepage, https://debugbundle.com/docs/sdk-python
+Project-URL: Homepage, https://debugbundle.com/docs/sdks/python
 Project-URL: Repository, https://github.com/debugbundle/debugbundle-python
 Project-URL: Issues, https://github.com/debugbundle/debugbundle-python/issues
 Keywords: debugbundle,debugging,ai-agent,error-tracking
@@ -59,7 +59,7 @@ debugbundle.flush()
 
 ## Status
 
-This repository currently contains the full Phase 18 Python SDK scope in eleven implementation slices: core SDK surface, buffering, redaction, duplicate suppression, probe buffering, vanilla runtime hooks, framework integrations for Django, Flask, and FastAPI, remote config polling and capture-policy enforcement, optional `structlog` and `loguru` auto-detection when `capture_logging()` is enabled, contract-aligned `EventEnvelope` emission for log, request, exception, suppression, and probe payloads, explicit public wrapper signatures and a validated buildable typed package artifact, real HTTP integration coverage against a lightweight mock ingestion server, vendored machine-readable schema validation for all event types the Python SDK currently emits, a standalone CI workflow that validates Ruff, mypy, pytest, and package builds for the Python 3.10+ support floor actually used by the package, an enforced per-file coverage gate that keeps every shipped Python SDK module at or above the required 80% minimum, request-local framework correlation binding so `X-DebugBundle-Trace-Id` flows through Django, Flask, and FastAPI into the emitted event correlation metadata for cross-context linking, and safe backend runtime process facts on exception payloads without reading environment variables.
+This repository currently contains the full Phase 18 Python SDK scope in eleven implementation slices: core SDK surface, buffering, redaction, duplicate suppression, probe buffering, vanilla runtime hooks, framework integrations for Django, Flask, and FastAPI, remote config polling and capture-policy enforcement, optional `structlog` and `loguru` auto-detection when `capture_logging()` is enabled, contract-aligned `EventEnvelope` emission for log, request, exception, suppression, and probe payloads, explicit public wrapper signatures and a validated buildable typed package artifact, real HTTP integration coverage against a lightweight mock ingestion server, vendored machine-readable schema validation for all event types the Python SDK currently emits, a standalone CI workflow that validates Ruff, mypy, pytest, and package builds for the Python 3.10+ support floor actually used by the package, an enforced per-file coverage gate that keeps every shipped Python SDK module at or above the required 80% minimum, request-local framework correlation binding so `X-DebugBundle-Trace-Id` flows through Django, Flask, and FastAPI into the emitted event correlation metadata for cross-context linking, full browser relay handler parity with Django/Flask/FastAPI helpers plus local-only and connected delivery modes, and safe backend runtime process facts on exception payloads without reading environment variables.
 
 ## Runtime Context
 
@@ -77,9 +77,25 @@ Backend exception events now include safe runtime process facts when the host ex
 
 The SDK does not read or emit environment variables in this runtime block.
 
+## Browser Relay
+
+The Python SDK includes a framework-agnostic `BrowserRelayHandler` plus framework helpers for the contract-required `POST /debugbundle/browser` endpoint in Python servers that also load `@debugbundle/sdk-browser`.
+
+- `create_django_relay_view()` returns a Django view for the relay route.
+- `create_flask_relay_handler()` registers the relay route on a Flask app.
+- `create_fastapi_relay_handler()` registers the relay route on a FastAPI app.
+
+The relay handler enforces same-origin or configured allowed origins, requires `Content-Type: application/json`, accepts the canonical `batch` body shape only, rejects bodies larger than `256 KB`, applies per-IP rate limiting, accepts only supported browser event types, strips trust-sensitive headers and fields, forces `sdk_name` to `@debugbundle/sdk-browser`, and preserves browser correlation fields (`request_id`, `trace_id`, `session_id`, and `user_id_hash`) when they are strings or `null`.
+
+Delivery behavior matches the shared relay contract across the shipped server SDKs:
+
+- `project_mode="local-only"` writes accepted browser events to local event files for CLI processing.
+- `project_mode="connected"` with the default `durable_write=True` writes a durable relay spool record and then forwards to the ingestion API with the server-side project token.
+- `project_mode="connected"` with `durable_write=False` uses the lower-latency forward-only path.
+
 ## Docs
 
-https://debugbundle.com/docs/sdk-python
+https://debugbundle.com/docs/sdks/python
 
 ## License
 

{debugbundle_python-0.1.5.dist-info → debugbundle_python-0.1.6.dist-info}/RECORD

@@ -4,7 +4,8 @@ debugbundle/core.py,sha256=YQFQax6EhjnN7SKFMXq_AohHZyFqxx18Az1ezIZiaDg,35772
 debugbundle/logger_integrations.py,sha256=RuTNaD9RRVmiE-BBkksAXWVEGaMzLrWavVpQdgGZBpE,4564
 debugbundle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 debugbundle/redaction.py,sha256=QTaPkSsYv54yR1mz8SB6Q4vWjvp7Ddcui4WXaH2RVz8,736
-debugbundle/relay.py,sha256=TUzlUsTtDKDVVHj0RvYgQVmxy-Jl3Sp8BMBT033mGDM,8703
+debugbundle/relay.py,sha256=BssBwjAp3usfZ3HPrFD1QpW7i7FPT_jf8fqyhocRZ_w,13143
+debugbundle/relay_delivery.py,sha256=VL-nIgJR6mYXqKy-EbA0USWeY_iS_uAr1KBzrnwBnnk,4676
 debugbundle/suppression.py,sha256=XMn0GfF_-WZk2wHWk3KfbO5_u5QhEunues5h3jOInLs,4098
 debugbundle/transport.py,sha256=oOk0xazHxq9h4CneJdRODKtwDciwikvpHVJM_6iBYXU,1791
 debugbundle/trigger_token.py,sha256=YUwIWnnxu1klAVaB8Ltgk_PwWW_PPjq9rzmEbWXeFeM,4455
@@ -13,11 +14,11 @@ debugbundle/integrations/common.py,sha256=iiwf5wDlpujFuWfbO-ziFTn4MtiHBXSIZNXtam
 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=_2TiH-oS0DOwThyfMJZ6ZJr5MkXEekEDaBUfPapMxt8,1523
-debugbundle/integrations/relay_fastapi.py,sha256=Z2spWy3wufVrBjYwRDDOL5Dsjgwcd5g72L23_sdulvo,1512
-debugbundle/integrations/relay_flask.py,sha256=WHk_ALOtT0xUuI1eINWFyLig9eRjSmIBpQ39xdkV608,1329
-debugbundle_python-0.1.5.dist-info/licenses/LICENSE,sha256=AKZZ5DQAHrOKGwt24VoRd-SXJLM9OloxlsX8ZgENdEY,735
-debugbundle_python-0.1.5.dist-info/METADATA,sha256=Y_moPWkJytlJI71XSFm2Y7q9X4pjQjhFoh25Vv6IwtA,3589
-debugbundle_python-0.1.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-debugbundle_python-0.1.5.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
-debugbundle_python-0.1.5.dist-info/RECORD,,
+debugbundle/integrations/relay_django.py,sha256=MMuh1Grdfk5IPUkAHqny6rkHb0cPfUXQDOi7w6Rxkuk,2152
+debugbundle/integrations/relay_fastapi.py,sha256=AW6XA1FzFvjh2mD_gmhdIRgXp5YRUuVV7Cdy7H7_92M,2141
+debugbundle/integrations/relay_flask.py,sha256=oJY0KLDB5fnIHjbZfcRL0X2zzSbCmAagKYLwK8mD_Bo,1958
+debugbundle_python-0.1.6.dist-info/licenses/LICENSE,sha256=AKZZ5DQAHrOKGwt24VoRd-SXJLM9OloxlsX8ZgENdEY,735
+debugbundle_python-0.1.6.dist-info/METADATA,sha256=hIx0qILB2fF-SpIlyisBe5DRtUadKnNihPDRTuiSP5c,5130
+debugbundle_python-0.1.6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+debugbundle_python-0.1.6.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
+debugbundle_python-0.1.6.dist-info/RECORD,,