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

debugbundle/exception_capture.py

@@ -0,0 +1,92 @@
+"""Native optional evidence preserves the protected legacy exception event."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, cast
+
+from .capture_hooks import try_capture_lock
+from .event_support import (
+    backend_exception_request_payload,
+    backend_exception_response_payload,
+    redact_mapping,
+    runtime_process_facts,
+)
+from .exception_evidence import snapshot_exception
+from .exception_snapshot import exception_details
+from .process_support import ensure_current_process
+from .queue_admission import may_prepare_event
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def capture_exception(
+    sdk: DebugBundleSdk,
+    error: BaseException,
+    context: Mapping[str, object] | None,
+    handled: bool,
+    max_pending_events: int,
+    max_pending_bytes: int,
+    fatal: bool = False,
+) -> None:
+    ensure_current_process(sdk)
+    if not sdk._enabled or not may_prepare_event(sdk, True, max_pending_events, max_pending_bytes):
+        return
+    try:
+        name, message, stack = exception_details(error)
+        redacted_context = redact_mapping(dict(context or {}), sdk._redact_fields)
+        request_payload = backend_exception_request_payload(redacted_context.get("request"))
+        response_payload = backend_exception_response_payload(redacted_context.get("response"))
+
+        payload: dict[str, object] = {
+            "name": name,
+            "message": message,
+            "stack": stack,
+            "handled": handled,
+            "request": request_payload,
+            "response": response_payload,
+            "runtime": runtime_process_facts(),
+        }
+        if sdk._probe_flush_on_error and try_capture_lock(sdk):
+            try:
+                probe_data = sdk._build_probe_data()
+            finally:
+                sdk._lock.release()
+            if probe_data is not None:
+                payload["probe_data"] = probe_data
+
+        candidate = sdk._base_event("backend_exception", payload, context=redacted_context)
+        if sdk._capture_exception_evidence and sdk._evidence.supports("exception_evidence_v1"):
+            execution = sdk._operations.snapshot()
+            additions: dict[str, object] = {"execution": execution} if execution is not None else {}
+            selected_context = candidate.get("context")
+            if type(selected_context) is dict and "evidence_reference" in selected_context:
+                additions["evidence_reference"] = selected_context["evidence_reference"]
+            overhead = len(json.dumps(additions, ensure_ascii=False, separators=(",", ":")).encode("utf-8")) + 32
+            graph = snapshot_exception(error, fatal=fatal, budget_bytes=(4096 if fatal else 32768) - overhead)
+            if graph is not None:
+                payload["exception_evidence"] = graph
+                if execution is not None:
+                    payload["execution"] = execution
+        event = sdk._protect_event(candidate)
+        if event is None or not sdk._passes_sample_rate():
+            return
+        event_payload = cast(dict[str, object], event["payload"])
+        suppression_key = (
+            f"{event['event_type']}:{event_payload.get('name', '')}:"
+            f"{event_payload.get('message', '')}:{event_payload.get('stack', '')}"
+        )
+        event_bytes = sdk._event_bytes(event)
+        if not try_capture_lock(sdk):
+            sdk._pressure_drops += 1
+            return
+        try:
+            if sdk._enabled and sdk._suppression.should_capture(suppression_key, sdk._time_provider()):
+                if sdk._offer_protected_event(event, event_bytes) and fatal:
+                    sdk._hook_bypass.add(id(event))
+        finally:
+            sdk._lock.release()
+    except BaseException:
+        return

debugbundle/exception_evidence.py

@@ -0,0 +1,199 @@
+"""Bounded native snapshots. No source reads, locals, custom renderers or raw-error retention."""
+
+from __future__ import annotations
+
+import builtins
+import json
+from typing import TypedDict, cast
+from urllib.parse import urlsplit, urlunsplit
+
+from .exception_snapshot import _exception_name, _safe_message
+from .redaction import UnsafeTelemetry, sanitize_telemetry
+
+
+class Frame(TypedDict):
+    function: str | None
+    file: str | None
+    line: int | None
+    column: int | None
+    classification: str
+
+
+class Relationship(TypedDict):
+    kind: str
+    target_id: int
+
+
+class Node(TypedDict):
+    id: int
+    name: str
+    message: str
+    stack: str | None
+    trace_origin: str
+    parsing_status: str
+    frames: list[Frame]
+    relationships: list[Relationship]
+
+
+class ExceptionEvidence(TypedDict):
+    version: int
+    runtime: str
+    root_id: int
+    nodes: list[Node]
+    truncated: bool
+    unavailable_reason: str | None
+
+
+_GROUP = vars(builtins).get("BaseExceptionGroup")
+_GROUP_CHILDREN = vars(_GROUP).get("exceptions") if _GROUP is not None else None
+_GROUP_MESSAGE = vars(_GROUP).get("message") if _GROUP is not None else None
+
+
+def _bytes(value: object) -> int:
+    return len(json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8"))
+
+
+def snapshot_exception(
+    error: BaseException,
+    *,
+    fatal: bool = False,
+    budget_bytes: int | None = None,
+) -> ExceptionEvidence | None:
+    maximum = min(4096 if fatal else 32768, budget_bytes if budget_bytes is not None else 32768)
+    if maximum < 512:
+        return None
+    graph: ExceptionEvidence = {
+        "version": 1,
+        "runtime": "python",
+        "root_id": 0,
+        "nodes": [],
+        "truncated": False,
+        "unavailable_reason": None,
+    }
+    identities: dict[int, int] = {}
+
+    def text(value: str, limit: int) -> str:
+        # Native metadata may be very long; bound work before encoding/scrubbing.
+        bounded = value[:limit]
+        encoded = bounded.encode("utf-8", errors="replace")
+        result = encoded[:limit].decode("utf-8", errors="ignore")
+        if result != value:
+            graph["truncated"] = True
+        try:
+            return cast(str, sanitize_telemetry(result))
+        except UnsafeTelemetry:
+            return "[withheld]"
+
+    def location(value: str) -> str:
+        result = text(value, 2048)
+        if result.lower().startswith(("https://", "http://")):
+            try:
+                parts = urlsplit(result)
+                result = urlunsplit((parts.scheme, parts.netloc.rsplit("@", 1)[-1], parts.path, "", ""))
+            except ValueError:
+                return "[withheld]"
+        return result
+
+    def height(index: int) -> int:
+        return max((1 + height(edge["target_id"]) for edge in graph["nodes"][index]["relationships"]), default=0)
+
+    def visit(current: BaseException, depth: int, ancestors: set[int]) -> int | None:
+        identity = id(current)
+        if identity in ancestors or depth > 4:
+            graph["truncated"] = True
+            return None
+        existing = identities.get(identity)
+        if existing is not None:
+            if depth + height(existing) > 4:
+                graph["truncated"] = True
+                return None
+            return existing
+        if len(graph["nodes"]) >= (2 if fatal else 8):
+            graph["truncated"] = True
+            return None
+        name = text(_exception_name(current), 256) or "Error"
+        is_group = _GROUP is not None and issubclass(type(current), _GROUP)
+        message = _GROUP_MESSAGE.__get__(current) if is_group and _GROUP_MESSAGE is not None else _safe_message(current)
+        node: Node = {
+            "id": len(graph["nodes"]),
+            "name": name,
+            "message": text(message, 512 if fatal else 2048) or name,
+            "stack": None,
+            "trace_origin": "unavailable",
+            "parsing_status": "unavailable",
+            "frames": [],
+            "relationships": [],
+        }
+        graph["nodes"].append(node)
+        identities[identity] = node["id"]
+        # Final built-in descriptors bypass subclass properties/__getattribute__.
+        traceback = BaseException.__dict__["__traceback__"].__get__(current)
+        while traceback is not None and len(node["frames"]) < (8 if fatal else 32):
+            code = traceback.tb_frame.f_code
+            node["frames"].append(
+                {
+                    "function": text(code.co_name, 256) or None,
+                    "file": location(code.co_filename) or None,
+                    "line": traceback.tb_lineno if traceback.tb_lineno > 0 else None,
+                    "column": None,
+                    "classification": "unknown",
+                }
+            )
+            traceback = traceback.tb_next
+        if node["frames"]:
+            node["trace_origin"] = "runtime_reported"
+            node["parsing_status"] = "parsed"
+        if traceback is not None:
+            graph["truncated"] = True
+            node["parsing_status"] = "truncated"
+        next_ancestors = ancestors | {identity}
+
+        def link(child: BaseException, kind: str) -> None:
+            if len(node["relationships"]) >= 5:
+                graph["truncated"] = True
+                return
+            target = visit(child, depth + 1, next_ancestors)
+            if target is not None:
+                edge: Relationship = {"kind": kind, "target_id": target}
+                if edge not in node["relationships"]:
+                    node["relationships"].append(edge)
+
+        cause = BaseException.__dict__["__cause__"].__get__(current)
+        if cause is not None:
+            link(cause, "cause")
+        elif not BaseException.__dict__["__suppress_context__"].__get__(current):
+            context = BaseException.__dict__["__context__"].__get__(current)
+            if context is not None:
+                link(context, "context")
+        if is_group and _GROUP_CHILDREN is not None:
+            children = _GROUP_CHILDREN.__get__(current)
+            # The built-in tuple needs no application iterator, len or item hooks.
+            count = tuple.__len__(children)
+            for index in range(min(count, 5)):
+                link(tuple.__getitem__(children, index), "aggregate")
+            if count > 5:
+                graph["truncated"] = True
+        return node["id"]
+
+    try:
+        visit(error, 0, set())
+        if _bytes(graph) > maximum:
+            graph["truncated"] = True
+            graph["unavailable_reason"] = "budget_exceeded"
+            for node in reversed(graph["nodes"]):
+                while node["frames"] and _bytes(graph) > maximum:
+                    node["frames"].pop()
+                    node["parsing_status"] = "truncated"
+            if _bytes(graph) > maximum:
+                for node in graph["nodes"]:
+                    node["name"] = text(node["name"], 64 if fatal else 128)
+                    node["message"] = text(node["message"], 128 if fatal else 256)
+            while len(graph["nodes"]) > 1 and _bytes(graph) > maximum:
+                removed = graph["nodes"].pop()["id"]
+                for node in graph["nodes"]:
+                    node["relationships"] = [edge for edge in node["relationships"] if edge["target_id"] != removed]
+        if graph["truncated"] and graph["unavailable_reason"] is None:
+            graph["unavailable_reason"] = "budget_exceeded"
+        return graph if graph["nodes"] and _bytes(graph) <= maximum else None
+    except BaseException:
+        return None

debugbundle/exception_snapshot.py

@@ -65,7 +65,7 @@ def _safe_message(error: BaseException) -> 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):
+            elif type(value) is int or type(value) is float or type(value) is bool:
                 parts.append(str(value))
             else:
                 parts.append("[unsupported argument]")

debugbundle/flush_delivery.py

@@ -0,0 +1,203 @@
+"""Reserved bounded delivery, canonical ACK handling and retry ownership."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .acknowledgement import decide_acknowledgement
+from .delivery_hooks import finalize_batch
+from .evidence_delivery import downgrade_rejections
+from .flush_aggregates import prepare_flush_aggregates
+from .ingestion_wire import prefix
+from .process_support import ensure_current_process
+from .queue_admission import high_priority_event
+from .transport import HttpTransport, bounded_retry_after_ms, coerce_transport_response
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def flush_sdk(sdk: DebugBundleSdk, max_events: int, max_bytes: int) -> None:
+    ensure_current_process(sdk)
+    with sdk._lock:
+        if not sdk._enabled or sdk._transport is None or sdk._sending:
+            return
+        if sdk._timer is not None:
+            sdk._timer.cancel()
+            sdk._timer = None
+        now = sdk._time_provider()
+        if now < sdk._retry_after:
+            sdk._schedule_flush_locked(delay=sdk._retry_after - now)
+            return
+        sdk._sending = True
+        generation = sdk._generation
+        suppression = sdk._suppression.drain_aggregates(now)
+        pressure_count = (
+            sdk._pressure_drops
+            if sdk._pressure_drops and now - sdk._last_pressure_report_at >= 60.0 and len(sdk._buffer) < max_events
+            else 0
+        )
+
+    try:
+        aggregates, pressure = prepare_flush_aggregates(sdk, suppression, pressure_count)
+    except BaseException:
+        aggregates, pressure = [], None
+
+    with sdk._lock:
+        if generation != sdk._generation:
+            sdk._sending = False
+            sdk._inflight_count = 0
+            if sdk._buffer:
+                sdk._schedule_flush_locked()
+            return
+        for aggregate, aggregate_bytes in aggregates:
+            sdk._offer_protected_event(aggregate, aggregate_bytes)
+        if (
+            pressure is not None
+            and len(sdk._buffer) < max_events
+            and sdk._buffer_bytes + pressure[1] <= max_bytes
+            and sdk._offer_protected_event(*pressure)
+        ):
+            sdk._pressure_drops = max(0, sdk._pressure_drops - pressure_count)
+            sdk._last_pressure_report_at = now
+        if not sdk._buffer:
+            sdk._sending = False
+            sdk._schedule_pressure_report_locked()
+            return
+        batch = list(sdk._buffer)
+        sdk._inflight_count = len(batch)
+        sdk._pending_low_priority = 0
+        transport = sdk._transport
+        request = {
+            "project_token": sdk._project_token,
+            "events": batch,
+        }
+
+    finalized = finalize_batch(sdk, batch, generation, max_bytes)
+    # Native serialization stays outside the capture lock, like hook/privacy
+    # work. The committed queue still owns every finalized event meanwhile.
+    wire_batch = prefix(finalized) if finalized is not None and isinstance(transport, HttpTransport) else finalized
+
+    with sdk._lock:
+        if generation != sdk._generation or finalized is None:
+            sdk._sending = False
+            sdk._inflight_count = 0
+            if sdk._buffer:
+                sdk._schedule_flush_locked()
+            return
+        batch = finalized
+        if isinstance(transport, HttpTransport):
+            assert wire_batch is not None
+            batch = wire_batch
+            # Finalized unsent tails stay charged and must not execute an
+            # application hook again merely because the wire batch was split.
+            sdk._hook_bypass.update(id(event) for event in finalized[len(batch) :])
+        sdk._inflight_count = len(batch)
+        if not batch:
+            sdk._sending = False
+            if sdk._buffer:
+                sdk._schedule_flush_locked()
+            return
+        request["events"] = batch
+
+    try:
+        response = coerce_transport_response(transport(request))
+    except BaseException:
+        response = None
+
+    with sdk._lock:
+        sdk._sending = False
+        sdk._inflight_count = 0
+        if generation != sdk._generation:
+            if sdk._buffer:
+                sdk._schedule_flush_locked()
+            return
+        try:
+            if response is None:
+                sdk._consecutive_failures += 1
+                sdk._schedule_flush_locked()
+                return
+
+            if 200 <= response.status_code < 300:
+                acknowledgement = decide_acknowledgement(
+                    response.body, len(batch), isinstance(transport, HttpTransport)
+                )
+                lost = sdk._evidence.observe(
+                    response.body, isinstance(transport, HttpTransport), acknowledgement.kind == "acknowledged"
+                )
+                if acknowledgement.kind == "protocol_failure":
+                    sdk._consecutive_failures += 1
+                    retry_after_ms = bounded_retry_after_ms(response.retry_after_ms)
+                    sdk._retry_after = sdk._time_provider() + (retry_after_ms / 1000)
+                    sdk._emit_diagnostic(
+                        "ingestion_acknowledgement_invalid",
+                        "sdk-python retained a batch after an invalid ingestion acknowledgement",
+                        metadata={"reason": acknowledgement.reason or "invalid"},
+                    )
+                    sdk._schedule_flush_locked(delay=retry_after_ms / 1000)
+                    return
+                if acknowledgement.kind == "legacy":
+                    sdk._buffer = sdk._buffer[len(batch) :]
+                    sdk._retry_after = 0.0
+                    sdk._last_event_at = sdk._time_provider() * 1000
+                    sdk._consecutive_failures = 0
+                    return
+
+                trailing_events = sdk._buffer[len(batch) :]
+                downgraded = downgrade_rejections(sdk, batch, acknowledgement.terminal_errors, lost)
+                sdk._buffer = (
+                    [batch[index] for index in acknowledgement.retryable_indices if 0 <= index < len(batch)]
+                    + downgraded
+                    + trailing_events
+                )
+                if acknowledgement.terminal_errors:
+                    sdk._emit_diagnostic(
+                        "ingestion_events_rejected",
+                        "sdk-python removed terminally rejected ingestion events",
+                        metadata={
+                            "rejected_count": len(acknowledgement.terminal_errors),
+                            "reasons": sorted({reason for _, reason in acknowledgement.terminal_errors}),
+                        },
+                    )
+                if acknowledgement.accepted > 0:
+                    sdk._last_event_at = sdk._time_provider() * 1000
+                if acknowledgement.retryable_indices or downgraded:
+                    sdk._consecutive_failures += 1
+                    retry_after_ms = bounded_retry_after_ms(response.retry_after_ms)
+                    sdk._retry_after = sdk._time_provider() + (retry_after_ms / 1000)
+                    sdk._schedule_flush_locked(delay=retry_after_ms / 1000)
+                    return
+                sdk._retry_after = 0.0
+                sdk._consecutive_failures = 0 if acknowledgement.accepted > 0 else 3
+                return
+
+            sdk._consecutive_failures += 1
+            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)
+                sdk._retry_after = sdk._time_provider() + (retry_after_ms / 1000)
+                sdk._schedule_flush_locked(delay=retry_after_ms / 1000)
+                return
+            if 400 <= response.status_code < 500:
+                sdk._buffer = sdk._buffer[len(batch) :]
+                sdk._retry_after = 0.0
+                return
+            sdk._schedule_flush_locked()
+        finally:
+            sdk._hook_bypass.intersection_update(id(event) for event in sdk._buffer)
+            sdk._diagnostics.retain(
+                {str(event["event_id"]) for event in sdk._buffer if event["event_type"] == "diagnostic_context"}
+            )
+            sdk._buffer_sizes = {id(event): sdk._buffer_sizes[id(event)] for event in sdk._buffer}
+            sdk._buffer_bytes = sum(sdk._buffer_sizes.values())
+            sdk._pending_low_priority = sum(not high_priority_event(event) for event in sdk._buffer)
+            if sdk._buffer and sdk._timer is None and sdk._retry_after <= sdk._time_provider():
+                sdk._schedule_flush_locked(
+                    delay=0.0
+                    if isinstance(transport, HttpTransport)
+                    and response is not None
+                    and 200 <= response.status_code < 300
+                    and sdk._consecutive_failures == 0
+                    else None
+                )
+            elif not sdk._buffer and sdk._timer is None:
+                sdk._schedule_pressure_report_locked()

debugbundle/ingestion_wire.py

@@ -0,0 +1,75 @@
+"""Size the final HTTP serializer; local/custom persistence keeps its own budget."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .evidence_wire import reference, without_optional
+
+MAX_BODY_BYTES = 256 * 1024
+MAX_EVENT_BYTES = MAX_BODY_BYTES - 13
+
+
+def encode_body(events: object) -> bytes:
+    return json.dumps({"events": events}, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
+
+
+def event_bytes(event: dict[str, Any]) -> int:
+    return len(json.dumps(event, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8"))
+
+
+def fit_event(event: dict[str, Any] | None) -> dict[str, Any] | None:
+    if event is None:
+        return None
+    if event_bytes(event) <= MAX_EVENT_BYTES:
+        return event
+    reduced = without_optional(event)
+    if reduced is not None:
+        fields = ("exception_evidence", "execution", "resource_observations")
+        marked = dict(
+            reduced,
+            context={
+                **event.get("context", {}),
+                "evidence_limits": {
+                    "version": 1,
+                    **{field: "budget_exceeded" for field in fields if field in event["payload"]},
+                },
+            },
+        )
+        if event_bytes(marked) <= MAX_EVENT_BYTES:
+            return marked
+        if event_bytes(reduced) <= MAX_EVENT_BYTES:
+            return reduced
+    else:
+        reduced = event
+    context = reduced.get("context")
+    if type(context) is dict and reference(context.get("evidence_reference")) is not None:
+        reduced = dict(reduced, context={key: value for key, value in context.items() if key != "evidence_reference"})
+        if event_bytes(reduced) <= MAX_EVENT_BYTES:
+            return reduced
+    return None
+
+
+def prefix(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    size = 12  # {"events":[]}
+    for index, event in enumerate(events):
+        length = event_bytes(event)
+        cost = length + (1 if index else 0)
+        if length > MAX_EVENT_BYTES:
+            raise ValueError("event exceeds ingestion limit")
+        if size + cost > MAX_BODY_BYTES:
+            return events[:index]
+        size += cost
+    return events
+
+
+def chunks(events: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
+    result = []
+    while events:
+        selected = prefix(events)
+        if not selected:
+            raise ValueError("event exceeds ingestion limit")
+        result.append(selected)
+        events = events[len(selected) :]
+    return result

debugbundle/integrations/relay_django.py

@@ -20,6 +20,7 @@ def create_django_relay_view(
     service: str | None = None,
     environment: str | None = None,
     forward_transport: Any = None,
+    evidence_capabilities: object = None,
 ) -> Any:
     handler = BrowserRelayHandler(
         allowed_origins=allowed_origins or [],
@@ -35,6 +36,7 @@ def create_django_relay_view(
         service=service,
         environment=environment,
         forward_transport=forward_transport,
+        evidence_capabilities=evidence_capabilities,
     )
 
     def view(request: Any) -> Any:
@@ -47,8 +49,9 @@ def create_django_relay_view(
         response = handler.handle(
             {
                 "method": request.method,
+                "url": request.get_full_path(),
                 "headers": headers,
-                "body": request.body.decode("utf-8") if isinstance(request.body, bytes) else str(request.body),
+                "body": request.read(handler.max_body_bytes + 1),
                 "ipAddress": _get_client_ip(request),
             }
         )

debugbundle/integrations/relay_fastapi.py

@@ -23,6 +23,7 @@ def create_fastapi_relay_handler(
     service: str | None = None,
     environment: str | None = None,
     forward_transport: Any = None,
+    evidence_capabilities: object = None,
     route_path: str = "/debugbundle/browser",
 ) -> Any:
     handler = BrowserRelayHandler(
@@ -39,20 +40,27 @@ def create_fastapi_relay_handler(
         service=service,
         environment=environment,
         forward_transport=forward_transport,
+        evidence_capabilities=evidence_capabilities,
     )
 
     def register(app: Any) -> None:
         @app.api_route(route_path, methods=["POST", "OPTIONS"])
         async def debugbundle_browser_relay(request: Request) -> Response:
-            body = await request.body()
+            body = bytearray()
+            async for chunk in request.stream():
+                remaining = handler.max_body_bytes + 1 - len(body)
+                body.extend(chunk[:remaining])
+                if len(body) > handler.max_body_bytes:
+                    break
             headers = {str(key): str(value) for key, value in request.headers.items()}
             ip_address = request.client.host if request.client else None
 
             response = handler.handle(
                 {
                     "method": request.method,
+                    "url": str(request.url),
                     "headers": headers,
-                    "body": body.decode("utf-8") if isinstance(body, bytes) else str(body),
+                    "body": bytes(body),
                     "ipAddress": ip_address,
                 }
             )

debugbundle/integrations/relay_flask.py

@@ -20,6 +20,7 @@ def create_flask_relay_handler(
     service: str | None = None,
     environment: str | None = None,
     forward_transport: Any = None,
+    evidence_capabilities: object = None,
     route_path: str = "/debugbundle/browser",
 ) -> Any:
     handler = BrowserRelayHandler(
@@ -36,6 +37,7 @@ def create_flask_relay_handler(
         service=service,
         environment=environment,
         forward_transport=forward_transport,
+        evidence_capabilities=evidence_capabilities,
     )
 
     def register(app: Any) -> None:
@@ -46,8 +48,9 @@ def create_flask_relay_handler(
             response = handler.handle(
                 {
                     "method": request.method,
+                    "url": request.full_path,
                     "headers": dict(request.headers.items()),
-                    "body": request.get_data(as_text=True),
+                    "body": request.stream.read(handler.max_body_bytes + 1),
                     "ipAddress": request.remote_addr,
                 }
             )