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

debugbundle/operation_context.py

@@ -0,0 +1,121 @@
+"""Monotonic operation ownership; retain only bounded technical metadata."""
+
+from __future__ import annotations
+
+import math
+import time
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Operation:
+    revision: int
+    scope: dict[str, str]
+    kind: str
+    name: str | None
+    limit: float | int | None
+    started: float
+    parent: Operation | None
+    active: bool = True
+    token_id: int = 0
+
+
+class OperationContexts:
+    def __init__(self) -> None:
+        self._current: ContextVar[Operation | None] = ContextVar("debugbundle_operation", default=None)
+        self._revision = 0
+
+    def clear(self) -> None:
+        self._revision += 1
+
+    def current(self) -> Operation | None:
+        current = self._current.get()
+        ancestor = current
+        for _ in range(16):
+            if ancestor is None:
+                return current
+            if not ancestor.active or ancestor.revision != self._revision:
+                return None
+            ancestor = ancestor.parent
+        return None
+
+    def begin(self, options: object) -> Token[Operation | None] | None:
+        try:
+            values: dict[str, Any] = options if type(options) is dict else {}
+            kind = values.get("kind")
+            kind = kind if type(kind) is str and kind in ("request", "command", "job", "unknown") else "unknown"
+            name = values.get("name")
+            name = name if type(name) is str and name.strip() and len(name.encode("utf-8")) <= 128 else None
+            limit = values.get("limit_ms")
+            limit = (
+                limit
+                if (type(limit) is int or type(limit) is float)
+                and 0 <= limit <= 1.7976931348623157e308
+                and math.isfinite(limit)
+                else None
+            )
+            parent = self.current()
+            # Count-bound inherited metadata as well as serialized fields.
+            depth, ancestor = 0, parent
+            while ancestor is not None:
+                depth += 1
+                ancestor = ancestor.parent
+            if depth >= 15:
+                return None
+            value = Operation(
+                self._revision,
+                {"kind": "operation", "operation_id": str(uuid.uuid4())},
+                kind,
+                name,
+                limit,
+                time.monotonic(),
+                parent,
+            )
+            token = self._current.set(value)
+            value.token_id = id(token)
+            return token
+        except BaseException:
+            return None
+
+    def end(self, token: Token[Operation | None] | None) -> None:
+        if token is None:
+            return
+        current = self._current.get()
+        value = current
+        for _ in range(16):
+            if value is None:
+                return
+            if value.token_id == id(token):
+                if value is current:
+                    self._current.reset(token)
+                value.active = False
+                return
+            value = value.parent
+
+    def snapshot(self) -> dict[str, object] | None:
+        value = self.current()
+        if value is None:
+            return None
+        return {
+            "version": 1,
+            "kind": value.kind,
+            "name": value.name,
+            "elapsed_ms": max(0, (time.monotonic() - value.started) * 1000),
+            "limit_ms": value.limit,
+        }
+
+    @contextmanager
+    def context(self, options: object) -> Iterator[None]:
+        token = self.begin(options)
+        try:
+            yield
+        finally:
+            try:
+                self.end(token)
+            except BaseException:
+                pass

debugbundle/process_support.py

@@ -7,6 +7,9 @@ import threading
 from contextvars import ContextVar
 from typing import TYPE_CHECKING
 
+from .diagnostic_budget import DiagnosticCaptureBudget
+from .evidence_delivery import EvidenceDelivery
+from .operation_context import OperationContexts
 from .suppression import EventSuppressionTracker
 from .transport import HttpTransport
 
@@ -27,6 +30,10 @@ def ensure_current_process(sdk: DebugBundleSdk) -> None:
     sdk._initial_config_ready = threading.Event()
     sdk._initial_config_ready.set()
     sdk._generation += 1
+    sdk._operations = OperationContexts()
+    sdk._evidence = EvidenceDelivery()
+    sdk._diagnostics = DiagnosticCaptureBudget()
+    sdk._hook_bypass = set()
     sdk._sending = False
     sdk._inflight_count = 0
     sdk._timer_due_at = 0.0

debugbundle/queue_admission.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from .evidence_delivery import reconcile_diagnostic
+
 if TYPE_CHECKING:
     from .core import DebugBundleSdk
 
@@ -14,8 +16,11 @@ def high_priority_event(event: dict[str, object]) -> bool:
     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)
+        or (
+            event.get("event_type") == "request_event"
+            and type(payload.get("response_status")) is int
+            and payload["response_status"] >= 500
+        )
     )
 
 
@@ -32,8 +37,43 @@ 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._hook_bypass.discard(id(evicted))
+            if evicted.get("event_type") == "diagnostic_context":
+                sdk._diagnostics.release([str(evicted["event_id"])])
             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
+
+
+def offer_protected_event(
+    sdk: DebugBundleSdk,
+    protected: dict[str, object],
+    event_bytes: int,
+    max_events: int,
+    max_bytes: int,
+) -> bool:
+    if event_bytes > max_bytes:
+        sdk._pressure_drops += 1
+        return False
+    high_priority = high_priority_event(protected)
+    under_pressure = len(sdk._buffer) >= max_events or sdk._buffer_bytes + event_bytes > max_bytes
+    while len(sdk._buffer) >= max_events or sdk._buffer_bytes + event_bytes > max_bytes:
+        if not high_priority or not evict_low_priority(sdk):
+            sdk._pressure_drops += 1
+            return False
+    insertion = sdk._inflight_count
+    if not reconcile_diagnostic(sdk, None, protected):
+        return False
+    if high_priority and (protected.get("event_type") != "request_event" or under_pressure):
+        while insertion < len(sdk._buffer) and high_priority_event(sdk._buffer[insertion]):
+            insertion += 1
+        sdk._buffer.insert(insertion, protected)
+    else:
+        sdk._buffer.append(protected)
+        sdk._pending_low_priority += 1
+    sdk._buffer_bytes += event_bytes
+    sdk._buffer_sizes[id(protected)] = event_bytes
+    sdk._schedule_flush_locked(delay=0.0 if len(sdk._buffer) >= sdk._batch_size else None)
+    return True

debugbundle/recovery_capture.py

@@ -0,0 +1,43 @@
+"""Explicit application observations share protected queue ownership."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .capture_hooks import try_capture_lock
+from .evidence_delivery import allows_recovery
+from .evidence_wire import normalise_recovery
+
+if TYPE_CHECKING:
+    from .core import DebugBundleSdk
+
+
+def capture_recovery(sdk: DebugBundleSdk, observation: object) -> None:
+    try:
+        if not sdk._enabled or not allows_recovery(sdk) or not sdk._passes_sample_rate():
+            return
+        operation = sdk._operations.current()
+        payload = normalise_recovery(observation, operation.scope if operation is not None else None)
+        if payload is None:
+            return
+        correlation = observation.get("correlation") if type(observation) is dict else None
+        # Correlation remains metadata and must never invoke application mappings.
+        context = (
+            {
+                key: value
+                for key, value in correlation.items()
+                if key in ("request_id", "trace_id", "session_id", "user_id_hash")
+                and (value is None or type(value) is str)
+            }
+            if type(correlation) is dict and len(correlation) <= 4 and all(type(key) is str for key in correlation)
+            else {}
+        )
+        event = sdk._protect_event(sdk._base_event("diagnostic_context", payload, context=context))
+        if event is None or not try_capture_lock(sdk):
+            return
+        try:
+            sdk._offer_protected_event(event, sdk._event_bytes(event))
+        finally:
+            sdk._lock.release()
+    except BaseException:
+        return

debugbundle/relay.py

@@ -5,7 +5,11 @@ import time
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from typing import Any
+from urllib.parse import parse_qs, urlsplit
 
+from .before_send import _is_valid_event
+from .evidence_delivery import EvidenceDelivery
+from .evidence_wire import strip_unsupported, validate_evidence, without_optional
 from .redaction import UnsafeTelemetry, has_safe_event_identity, sanitize_telemetry
 from .relay_delivery import (
     AtomicRelayFileTransport,
@@ -27,6 +31,7 @@ ACCEPTED_EVENT_TYPES = frozenset(
         "request_event",
         "probe_event",
         "analytics_event",
+        "diagnostic_context",
     }
 )
 
@@ -61,6 +66,7 @@ class BrowserRelayHandler:
     service: str | None = None
     environment: str | None = None
     forward_transport: Callable[[Mapping[str, object]], object] | None = None
+    evidence_capabilities: object = None
 
     def __post_init__(self) -> None:
         self.allowed_origins = [o for o in self.allowed_origins if o]
@@ -73,8 +79,9 @@ class BrowserRelayHandler:
         self._rate_limit_state: dict[str, list[int]] = {}
         self._local_transports: dict[str, AtomicRelayFileTransport] = {}
         self._spool_transports: dict[str, AtomicRelayFileTransport] = {}
+        self._evidence = EvidenceDelivery(self.evidence_capabilities)
         self._forwarder = (
-            RelayForwardTransport(self.endpoint, self.forward_transport)
+            RelayForwardTransport(self.endpoint, self.forward_transport, self._evidence)
             if self.project_mode == "connected" and self.endpoint is not None
             else None
         )
@@ -87,9 +94,19 @@ class BrowserRelayHandler:
             return BrowserRelayResponse(403)
 
         response_headers = _cors_headers(source_origin) if source_origin else {}
+        discover = headers.get("x-debugbundle-evidence") == "1" or parse_qs(
+            urlsplit(str(request.get("url", ""))).query
+        ).get("debugbundle_evidence") == ["1"]
 
         def with_headers(response: BrowserRelayResponse) -> BrowserRelayResponse:
-            return BrowserRelayResponse(response.status, response.body, {**response_headers, **response.headers})
+            body = response.body
+            if discover and body is not None:
+                body = {**body, "evidence_capabilities": {"version": 1, "features": list(self._evidence.features)}}
+                if "errors" in body and indexed_errors:
+                    body["evidence_errors"] = indexed_errors
+            return BrowserRelayResponse(response.status, body, {**response_headers, **response.headers})
+
+        indexed_errors: list[dict[str, object]] = []
 
         if method == "OPTIONS":
             return with_headers(BrowserRelayResponse(204))
@@ -98,10 +115,16 @@ class BrowserRelayHandler:
             return with_headers(BrowserRelayResponse(405))
 
         if not _is_supported_content_type(headers.get("content-type")):
-            return with_headers(BrowserRelayResponse(
-                400,
-                {"accepted": 0, "rejected": 0, "errors": ["Relay requests must use Content-Type: application/json."]},
-            ))
+            return with_headers(
+                BrowserRelayResponse(
+                    400,
+                    {
+                        "accepted": 0,
+                        "rejected": 0,
+                        "errors": ["Relay requests must use Content-Type: application/json."],
+                    },
+                )
+            )
 
         body: str = request.get("body", "")
         if len(body.encode("utf-8") if isinstance(body, str) else body) > self.max_body_bytes:
@@ -114,23 +137,29 @@ class BrowserRelayHandler:
         try:
             decoded = json.loads(body)
         except (json.JSONDecodeError, TypeError, ValueError):
-            return with_headers(BrowserRelayResponse(
-                400,
-                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
-            ))
+            return with_headers(
+                BrowserRelayResponse(
+                    400,
+                    {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
+                )
+            )
 
         if not isinstance(decoded, dict):
-            return with_headers(BrowserRelayResponse(
-                400,
-                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
-            ))
+            return with_headers(
+                BrowserRelayResponse(
+                    400,
+                    {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
+                )
+            )
 
         batch = decoded.get("batch")
         if not isinstance(batch, list):
-            return with_headers(BrowserRelayResponse(
-                400,
-                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must include a batch array."]},
-            ))
+            return with_headers(
+                BrowserRelayResponse(
+                    400,
+                    {"accepted": 0, "rejected": 0, "errors": ["Relay request body must include a batch array."]},
+                )
+            )
 
         accepted_events: list[dict[str, Any]] = []
         errors: list[str] = []
@@ -138,24 +167,31 @@ class BrowserRelayHandler:
         for index, candidate in enumerate(batch):
             if not isinstance(candidate, dict):
                 errors.append(f"batch[{index}]: Relay events must be objects.")
+                indexed_errors.append({"index": index, "reason": "invalid_event"})
                 continue
 
             event_type = candidate.get("event_type")
             if not isinstance(event_type, str) or event_type not in ACCEPTED_EVENT_TYPES:
                 type_label = event_type if isinstance(event_type, str) else "unknown"
                 errors.append(f"batch[{index}]: Unsupported browser relay event type {type_label}.")
+                indexed_errors.append({"index": index, "reason": "invalid_event"})
                 continue
 
             sanitized = _sanitize_event(candidate, service_override=self.service, environment_override=self.environment)
+            if sanitized is not None and sanitized["event_type"] != "analytics_event":
+                sanitized = strip_unsupported(sanitized, self._evidence.features)
+            if sanitized is not None and self._forwarder is not None and self.project_token:
+                sanitized = self._forwarder.prepare_event(sanitized, self.project_token)
             if sanitized is None:
                 errors.append(f"batch[{index}]: Invalid browser relay event payload.")
+                indexed_errors.append({"index": index, "reason": "invalid_event"})
                 continue
 
             accepted_events.append(sanitized)
 
         if accepted_events:
             try:
-                if not self._deliver_events(accepted_events):
+                if not self._deliver_events(accepted_events, discover):
                     return with_headers(BrowserRelayResponse(500))
 
                 if self.on_accept is not None:
@@ -171,17 +207,21 @@ class BrowserRelayHandler:
                 return with_headers(BrowserRelayResponse(500))
 
         if errors:
-            return with_headers(BrowserRelayResponse(
-                400,
-                {"accepted": len(accepted_events), "rejected": len(errors), "errors": errors},
-            ))
+            return with_headers(
+                BrowserRelayResponse(
+                    202 if discover else 400,
+                    {"accepted": len(accepted_events), "rejected": len(errors), "errors": errors},
+                )
+            )
 
-        return with_headers(BrowserRelayResponse(
-            202,
-            {"accepted": len(accepted_events), "rejected": 0, "errors": []},
-        ))
+        return with_headers(
+            BrowserRelayResponse(
+                202,
+                {"accepted": len(accepted_events), "rejected": 0, "errors": []},
+            )
+        )
 
-    def _deliver_events(self, accepted_events: list[dict[str, Any]]) -> bool:
+    def _deliver_events(self, accepted_events: list[dict[str, Any]], discover: bool = False) -> bool:
         if self.project_mode is None:
             return True
 
@@ -214,20 +254,22 @@ class BrowserRelayHandler:
             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:
+            configured, _succeeded, complete = self._forward_connected_events(accepted_events, discover)
+            if complete 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)
+        configured, succeeded, _complete = self._forward_connected_events(accepted_events, discover)
         return configured and succeeded
 
-    def _forward_connected_events(self, accepted_events: list[dict[str, Any]]) -> tuple[bool, bool]:
+    def _forward_connected_events(
+        self, accepted_events: list[dict[str, Any]], discover: bool = False
+    ) -> tuple[bool, bool, bool]:
         if self._forwarder is None or not self.project_token:
-            return (False, False)
+            return (False, False, False)
 
-        return self._forwarder.send(self.project_token, accepted_events)
+        return self._forwarder.send_verified(self.project_token, accepted_events, discover)
 
     def _is_origin_allowed(self, headers: dict[str, str]) -> bool:
         origin = _source_origin(headers)
@@ -277,7 +319,7 @@ def _cors_headers(origin: str) -> dict[str, str]:
     return {
         "access-control-allow-origin": origin,
         "access-control-allow-methods": "POST, OPTIONS",
-        "access-control-allow-headers": "content-type",
+        "access-control-allow-headers": "content-type, x-debugbundle-evidence",
         "access-control-max-age": "600",
         "vary": "Origin",
     }
@@ -393,11 +435,26 @@ def _sanitize_event(
         if normalized_correlation:
             sanitized["correlation"] = normalized_correlation
 
+    if isinstance(event.get("context"), dict):
+        sanitized["context"] = event["context"]
+    evidence = event_type != "analytics_event" and (
+        event_type == "diagnostic_context"
+        or any(key in payload for key in ("exception_evidence", "execution", "resource_observations"))
+    )
+    if evidence and not _is_valid_event(sanitized):
+        return None
+
     try:
         if not has_safe_event_identity(sanitized):
             return None
         sanitized["payload"] = sanitize_telemetry(sanitized["payload"])
         sanitized["service"] = sanitize_telemetry(sanitized["service"])
+        if "context" in sanitized:
+            sanitized["context"] = sanitize_telemetry(sanitized["context"])
     except UnsafeTelemetry:
-        return None
+        fallback = without_optional(sanitized) if evidence else None
+        return _sanitize_event(fallback, service_override, environment_override) if fallback is not None else None
+    if evidence and (not _is_valid_event(sanitized) or not validate_evidence(sanitized)):
+        fallback = without_optional(sanitized)
+        return _sanitize_event(fallback, service_override, environment_override) if fallback is not None else None
     return sanitized

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