.

Author: sentrivana

sentry_sdk/_types.py

@@ -1,3 +1,4 @@
+from consts import SPANSTATUS
 from typing import TYPE_CHECKING, TypeVar, Union
 
 
@@ -222,6 +223,17 @@ class SDKInfo(TypedDict):
     # TODO: Make a proper type definition for this (PRs welcome!)
     Hint = Dict[str, Any]
 
+    # TODO: Consolidate attribute types. E.g. metrics use the same attr structure.
+    # I'm keeping span attrs separate for now so that the span first stuff is
+    # isolated until it's not experimental.
+    SpanAttributeValue = TypedDict(
+        "SpanAttributeValue",
+        {
+            "type": Literal["string", "boolean", "double", "integer"],
+            "value": str | bool | float | int,
+        },
+    )
+
     Log = TypedDict(
         "Log",
         {
@@ -260,6 +272,23 @@ class SDKInfo(TypedDict):
 
     MetricProcessor = Callable[[Metric, Hint], Optional[Metric]]
 
+    # This is the V2 span format
+    # https://develop.sentry.dev/sdk/telemetry/spans/span-protocol/
+    SpanV2 = TypedDict(
+        "SpanV2",
+        {
+            "trace_id": str,
+            "span_id": str,
+            "parent_span_id": Optional[str],
+            "name": str,
+            "status": Literal[SPANSTATUS.OK, SPANSTATUS.ERROR],
+            "is_segment": bool,
+            "start_timestamp": float,
+            "end_timestamp": float,
+            "attributes": Optional[dict[str, SpanAttributeValue]],
+        },
+    )
+
     # TODO: Make a proper type definition for this (PRs welcome!)
     Breadcrumb = Dict[str, Any]
 

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,
@@ -187,6 +188,7 @@ def __init__(self, options=None):
         self.monitor = None  # type: Optional[Monitor]
         self.log_batcher = None  # type: Optional[LogBatcher]
         self.metrics_batcher = None  # type: Optional[MetricsBatcher]
+        self._span_batcher = None  # type: Optional[SpanBatcher]
 
     def __getstate__(self, *args, **kwargs):
         # type: (*Any, **Any) -> Any
@@ -398,6 +400,13 @@ def _record_lost_event(
                     record_lost_func=_record_lost_event,
                 )
 
+            self._span_batcher = None
+            if self.options["_experiments"].get("trace_lifecycle", None) == "stream":
+                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(

sentry_sdk/scope.py

@@ -22,6 +22,7 @@
 from sentry_sdk.session import Session
 from sentry_sdk.tracing_utils import (
     Baggage,
+    has_streaming_enabled,
     has_tracing_enabled,
     normalize_incoming_data,
     PropagationContext,
@@ -1124,9 +1125,10 @@ def start_transaction(
                 transaction.set_profiler_id(get_profiler_id())
 
             # we don't bother to keep spans if we already know we're not going to
-            # send the transaction
-            max_spans = (client.options["_experiments"].get("max_spans")) or 1000
-            transaction.init_span_recorder(maxlen=max_spans)
+            # send the transaction or if we're in streaming mode
+            if not has_streaming_enabled(client.options):
+                max_spans = (client.options["_experiments"].get("max_spans")) or 1000
+                transaction.init_span_recorder(maxlen=max_spans)
 
         return transaction
 

sentry_sdk/tracing.py

@@ -711,6 +711,14 @@ def finish(self, scope=None, end_timestamp=None):
         scope = scope or sentry_sdk.get_current_scope()
         maybe_create_breadcrumbs_from_span(scope, self)
 
+        client = sentry_sdk.get_client()
+        if client.is_active():
+            if (
+                has_span_streaming_enabled(client.options)
+                and self.containing_transaction.sampled
+            ):
+                client._span_batcher.add(self)
+
         return None
 
     def to_json(self):
@@ -857,6 +865,12 @@ def __init__(  # type: ignore[misc]
         else:
             self._sample_rand = _generate_sample_rand(self.trace_id)
 
+        self._mode = "static"
+        client = sentry_sdk.get_client()
+        if client.is_active():
+            if has_span_streaming_enabled(client.options):
+                self._mode = "stream"
+
     def __repr__(self):
         # type: () -> str
         return (
@@ -882,9 +896,11 @@ def _possibly_started(self):
         with sentry_sdk.start_transaction, and therefore the transaction will
         be discarded.
         """
-
-        # We must explicitly check self.sampled is False since self.sampled can be None
-        return self._span_recorder is not None or self.sampled is False
+        if self._mode == "static":
+            # We must explicitly check self.sampled is False since self.sampled can be None
+            return self._span_recorder is not None or self.sampled is False
+        else:
+            return True
 
     def __enter__(self):
         # type: () -> Transaction
@@ -972,7 +988,8 @@ def finish(
     ):
         # type: (...) -> Optional[str]
         """Finishes the transaction and sends it to Sentry.
-        All finished spans in the transaction will also be sent to Sentry.
+        If we're in non-streaming mode, all finished spans in the transaction
+        will also be sent to Sentry at this point.
 
         :param scope: The Scope to use for this transaction.
             If not provided, the current Scope will be used.
@@ -1000,7 +1017,7 @@ def finish(
             # We have no active client and therefore nowhere to send this transaction.
             return None
 
-        if self._span_recorder is None:
+        if self._mode == "static" and self._span_recorder is None:
             # Explicit check against False needed because self.sampled might be None
             if self.sampled is False:
                 logger.debug("Discarding transaction because sampled = False")
@@ -1482,5 +1499,6 @@ def calculate_interest_rate(amount, rate, years):
     extract_sentrytrace_data,
     _generate_sample_rand,
     has_tracing_enabled,
+    has_span_streaming_enabled,
     maybe_create_breadcrumbs_from_span,
 )

sentry_sdk/tracing_utils.py

@@ -110,6 +110,14 @@ def has_tracing_enabled(options):
     )
 
 
+def has_span_streaming_enabled(options):
+    # type: (Optional[Dict[str, Any]]) -> bool
+    if options is None:
+        return False
+
+    return options.get("_experiments").get("trace_lifecycle") == "stream"
+
+
 @contextlib.contextmanager
 def record_sql_queries(
     cursor,  # type: Any

sentry_sdk/utils.py

@@ -2076,3 +2076,20 @@ def get_before_send_metric(options):
     return options.get("before_send_metric") or options["_experiments"].get(
         "before_send_metric"
     )
+
+
+def format_attribute_value(value):
+    # type: (Any) -> dict[str, bool | str | int | float]
+    if isinstance(value, bool):
+        return {"value": value, "type": "boolean"}
+
+    if isinstance(value, int):
+        return {"value": value, "type": "integer"}
+
+    if isinstance(value, float):
+        return {"value": value, "type": "double"}
+
+    if isinstance(value, str):
+        return {"value": value, "type": "string"}
+
+    return {"value": safe_repr(value), "type": "string"}