feat(span-streaming): Add span batcher

Author: sentrivana

sentry_sdk/_span_batcher.py

@@ -0,0 +1,134 @@
+import threading
+from collections import defaultdict
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from sentry_sdk._batcher import Batcher
+from sentry_sdk.consts import SPANSTATUS
+from sentry_sdk.envelope import Envelope, Item, PayloadRef
+from sentry_sdk.utils import format_timestamp, serialize_attribute, safe_repr
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, Optional
+    from sentry_sdk.traces import SpanStatus, StreamedSpan
+    from sentry_sdk._types import SerializedAttributeValue
+
+
+class SpanBatcher(Batcher["StreamedSpan"]):
+    # TODO[span-first]: size-based flushes
+    # TODO[span-first]: adjust flush/drop defaults
+    MAX_BEFORE_FLUSH = 1000
+    MAX_BEFORE_DROP = 5000
+    FLUSH_WAIT_TIME = 5.0
+
+    TYPE = "span"
+    CONTENT_TYPE = "application/vnd.sentry.items.span.v2+json"
+
+    def __init__(
+        self,
+        capture_func: "Callable[[Envelope], None]",
+        record_lost_func: "Callable[..., None]",
+    ) -> None:
+        # Spans from different traces cannot be emitted in the same envelope
+        # since the envelope contains a shared trace header. That's why we bucket
+        # by trace_id, so that we can then send the buckets each in its own
+        # envelope.
+        # trace_id -> span buffer
+        self._span_buffer: dict[str, list["StreamedSpan"]] = defaultdict(list)
+        self._capture_func = capture_func
+        self._record_lost_func = record_lost_func
+        self._running = True
+        self._lock = threading.Lock()
+
+        self._flush_event: "threading.Event" = threading.Event()
+
+        self._flusher: "Optional[threading.Thread]" = None
+        self._flusher_pid: "Optional[int]" = None
+
+    def get_size(self) -> int:
+        # caller is responsible for locking before checking this
+        return sum(len(buffer) for buffer in self._span_buffer.values())
+
+    def add(self, span: "StreamedSpan") -> None:
+        if not self._ensure_thread() or self._flusher is None:
+            return None
+
+        with self._lock:
+            size = self.get_size()
+            if size >= self.MAX_BEFORE_DROP:
+                self._record_lost_func(
+                    reason="queue_overflow",
+                    data_category="span",
+                    quantity=1,
+                )
+                return None
+
+            self._span_buffer[span.trace_id].append(span)
+            if size + 1 >= self.MAX_BEFORE_FLUSH:
+                self._flush_event.set()
+
+    @staticmethod
+    def _to_transport_format(item: "StreamedSpan") -> "Any":
+        res: "dict[str, Any]" = {
+            "trace_id": item.trace_id,
+            "span_id": item.span_id,
+            "name": item.get_name(),
+            "status": item.status,
+            "is_segment": item.is_segment(),
+            "start_timestamp": item.start_timestamp.timestamp(),  # TODO[span-first]
+        }
+
+        if item.timestamp:
+            res["end_timestamp"] = item.timestamp.timestamp()
+
+        if item.parent_span_id:
+            res["parent_span_id"] = item.parent_span_id
+
+        if item.attributes:
+            res["attributes"] = {
+                k: serialize_attribute(v) for (k, v) in item.attributes.items()
+            }
+
+        return res
+
+    def _flush(self) -> None:
+        with self._lock:
+            if len(self._span_buffer) == 0:
+                return None
+
+            envelopes = []
+            for trace_id, spans in self._span_buffer.items():
+                if spans:
+                    dsc = spans[0].dynamic_sampling_context()
+
+                    envelope = Envelope(
+                        headers={
+                            "sent_at": format_timestamp(datetime.now(timezone.utc)),
+                            "trace": dsc,
+                        }
+                    )
+
+                    envelope.add_item(
+                        Item(
+                            type="span",
+                            content_type="application/vnd.sentry.items.span.v2+json",
+                            headers={
+                                "item_count": len(spans),
+                            },
+                            payload=PayloadRef(
+                                json={
+                                    "items": [
+                                        self._to_transport_format(span)
+                                        for span in spans
+                                    ]
+                                }
+                            ),
+                        )
+                    )
+
+                    envelopes.append(envelope)
+
+            self._span_buffer.clear()
+
+        for envelope in envelopes:
+            self._capture_func(envelope)

sentry_sdk/client.py

@@ -11,6 +11,7 @@
 import sentry_sdk
 from sentry_sdk._compat import PY37, check_uwsgi_thread_support
 from sentry_sdk._metrics_batcher import MetricsBatcher
+from sentry_sdk._span_batcher import SpanBatcher
 from sentry_sdk.utils import (
     AnnotatedValue,
     ContextVar,
@@ -31,6 +32,7 @@
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.transport import BaseHttpTransport, make_transport
 from sentry_sdk.consts import (
     SPANDATA,
@@ -67,6 +69,7 @@
     from sentry_sdk.scope import Scope
     from sentry_sdk.session import Session
     from sentry_sdk.spotlight import SpotlightClient
+    from sentry_sdk.traces import StreamedSpan
     from sentry_sdk.transport import Transport, Item
     from sentry_sdk._log_batcher import LogBatcher
     from sentry_sdk._metrics_batcher import MetricsBatcher
@@ -188,6 +191,7 @@ def __init__(self, options: "Optional[Dict[str, Any]]" = None) -> None:
         self.monitor: "Optional[Monitor]" = None
         self.log_batcher: "Optional[LogBatcher]" = None
         self.metrics_batcher: "Optional[MetricsBatcher]" = None
+        self.span_batcher: "Optional[SpanBatcher]" = None
         self.integrations: "dict[str, Integration]" = {}
 
     def __getstate__(self, *args: "Any", **kwargs: "Any") -> "Any":
@@ -224,6 +228,9 @@ def _capture_log(self, log: "Log", scope: "Scope") -> None:
     def _capture_metric(self, metric: "Metric", scope: "Scope") -> None:
         pass
 
+    def _capture_span(self, span: "StreamedSpan", scope: "Scope") -> None:
+        pass
+
     def capture_session(self, *args: "Any", **kwargs: "Any") -> None:
         return None
 
@@ -399,6 +406,13 @@ def _record_lost_event(
                     record_lost_func=_record_lost_event,
                 )
 
+            self.span_batcher = None
+            if has_span_streaming_enabled(self.options):
+                self.span_batcher = SpanBatcher(
+                    capture_func=_capture_envelope,
+                    record_lost_func=_record_lost_event,
+                )
+
             max_request_body_size = ("always", "never", "small", "medium")
             if self.options["max_request_body_size"] not in max_request_body_size:
                 raise ValueError(
@@ -909,7 +923,10 @@ def capture_event(
         return return_value
 
     def _capture_telemetry(
-        self, telemetry: "Optional[Union[Log, Metric]]", ty: str, scope: "Scope"
+        self,
+        telemetry: "Optional[Union[Log, Metric, StreamedSpan]]",
+        ty: str,
+        scope: "Scope",
     ) -> None:
         # Capture attributes-based telemetry (logs, metrics, spansV2)
         if telemetry is None:
@@ -934,6 +951,8 @@ def _capture_telemetry(
             batcher = self.log_batcher
         elif ty == "metric":
             batcher = self.metrics_batcher  # type: ignore
+        elif ty == "span":
+            batcher = self.span_batcher  # type: ignore
 
         if batcher is not None:
             batcher.add(telemetry)  # type: ignore
@@ -944,6 +963,9 @@ def _capture_log(self, log: "Optional[Log]", scope: "Scope") -> None:
     def _capture_metric(self, metric: "Optional[Metric]", scope: "Scope") -> None:
         self._capture_telemetry(metric, "metric", scope)
 
+    def _capture_span(self, span: "Optional[StreamedSpan]", scope: "Scope") -> None:
+        self._capture_telemetry(span, "span", scope)
+
     def capture_session(
         self,
         session: "Session",
@@ -993,6 +1015,8 @@ def close(
                 self.log_batcher.kill()
             if self.metrics_batcher is not None:
                 self.metrics_batcher.kill()
+            if self.span_batcher is not None:
+                self.span_batcher.kill()
             if self.monitor:
                 self.monitor.kill()
             self.transport.kill()
@@ -1018,6 +1042,8 @@ def flush(
                 self.log_batcher.flush()
             if self.metrics_batcher is not None:
                 self.metrics_batcher.flush()
+            if self.span_batcher is not None:
+                self.span_batcher.flush()
             self.transport.flush(timeout=timeout, callback=callback)
 
     def __enter__(self) -> "_Client":