new ignore_spans

Author: sentrivana

sentry_sdk/_span_batcher.py

@@ -79,11 +79,7 @@ def _to_transport_format(item: "StreamedSpan") -> "Any":
         if item.timestamp:
             res["end_timestamp"] = item.timestamp.timestamp()
 
-        if item._last_valid_parent_id:
-            # This span needs to be reparented because its parent is ignored
-            res["parent_span_id"] = item._last_valid_parent_id
-
-        elif item.parent_span_id:
+        if item.parent_span_id:
             res["parent_span_id"] = item.parent_span_id
 
         if item._attributes:

sentry_sdk/scope.py

@@ -33,7 +33,7 @@
     is_ignored_span,
     PropagationContext,
 )
-from sentry_sdk.traces import StreamedSpan
+from sentry_sdk.traces import StreamedSpan, NoOpStreamedSpan
 from sentry_sdk.tracing import (
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
@@ -1228,22 +1228,29 @@ def start_streamed_span(
         name: str,
         attributes: "Optional[Attributes]" = None,
         parent_span: "Optional[StreamedSpan]" = None,
-        **kwargs: "Any",  # TODO: remove, just for expediting seer testing
+        **kwargs: "Any",  # TODO[span-first]: remove, just for expediting seer testing
     ) -> "StreamedSpan":
         # TODO: rename to start_span once we drop the old API
-        if parent_span is None:
+        if isinstance(parent_span, NoOpStreamedSpan):
+            # parent_span is only set if the user explicitly set it
+            logger.debug(
+                "Ignored parent span provided. Span will be parented to the "
+                "currently active span instead."
+            )
+
+        if parent_span is None or isinstance(parent_span, NoOpStreamedSpan):
             parent_span = self.span or self.get_current_scope().span  # type: ignore
 
-        # If no specific parent_span provided and there is no currently
+        # If no specific parent_span was provided and there is no currently
         # active span, this is a segment
         if parent_span is None:
             propagation_context = self.get_active_propagation_context()
 
-            unsampled_reason = None
             if is_ignored_span(name, attributes):
-                unsampled_reason = "ignored"
+                return NoOpStreamedSpan(scope=self)
+                # TODO[span-first]: emit "ignored" client report
 
-            span = StreamedSpan(
+            return StreamedSpan(
                 name=name,
                 attributes=attributes,
                 scope=self,
@@ -1252,44 +1259,25 @@ def start_streamed_span(
                 parent_span_id=propagation_context.parent_span_id,
                 parent_sampled=propagation_context.parent_sampled,
                 baggage=propagation_context.baggage,
-                sampled=None if unsampled_reason is None else False,
-                unsampled_reason=unsampled_reason,
             )
 
-            return span
-
         # This is a child span; take propagation context from the parent span
         with new_scope():
-            unsampled_reason = None
-            if is_ignored_span(name, attributes):
-                unsampled_reason = "ignored"
-
-            # If this span's parent is ignored, we'll eventually attempt to
-            # reparent it to its last non-ignored ancestor, so keep track of it
-            last_valid_parent_id = None
-            if parent_span.sampled is False:
-                # If the parent's parent is also ignored, it'll have a last valid
-                # parent ID stored already. Otherwise, take the parent's parent
-                # if it's not ignored.
-                last_valid_parent_id = (
-                    parent_span._last_valid_parent_id or parent_span.parent_span_id
-                )
+            if is_ignored_span(name, attributes) or isinstance(parent_span, NoOpStreamedSpan):
+                # TODO[span-first]: emit "ignored" client report
+                # also add tests for it
+                return NoOpStreamedSpan()
 
-            span = StreamedSpan(
+            return StreamedSpan(
                 name=name,
                 attributes=attributes,
                 scope=self,
                 trace_id=parent_span.trace_id,
                 parent_span_id=parent_span.span_id,
                 parent_sampled=parent_span.sampled,
                 segment=parent_span.segment,
-                sampled=None if unsampled_reason is None else False,
-                unsampled_reason=unsampled_reason,
-                last_valid_parent_id=last_valid_parent_id,
             )
 
-            return span
-
     def _start_profile_on_segment(self, span: "StreamedSpan") -> None:
         try_autostart_continuous_profiler()
 

sentry_sdk/traces.py

@@ -222,7 +222,6 @@ class StreamedSpan:
         "sample_rate",
         "_sample_rand",
         "_finished",
-        "_unsampled_reason",
         "_last_valid_parent_id",
     )
 
@@ -243,7 +242,6 @@ def __init__(
         baggage: "Optional[Baggage]" = None,
         segment: "Optional[StreamedSpan]" = None,
         sampled: "Optional[bool]" = None,
-        unsampled_reason: "Optional[str]" = None,
         last_valid_parent_id: "Optional[str]" = None,
     ) -> None:
         self._scope = scope
@@ -277,7 +275,6 @@ def __init__(
         # XXX[span-first] ^ populate this correctly
 
         self._sampled: "Optional[bool]" = sampled
-        self._unsampled_reason: "Optional[str]" = unsampled_reason
         self.sample_rate: "Optional[float]" = None
         self._last_valid_parent_id: "Optional[str]" = last_valid_parent_id
 
@@ -412,8 +409,6 @@ def _end(
             if client.transport and has_tracing_enabled(client.options):
                 if client.monitor and client.monitor.downsample_factor > 0:
                     reason = "backpressure"
-                elif self._unsampled_reason:
-                    reason = self._unsampled_reason
                 else:
                     reason = "sample_rate"
 
@@ -653,6 +648,128 @@ def _set_segment_attributes(self) -> None:
         self.set_attribute("sentry.segment.name", self.segment.name)
 
 
+class NoOpStreamedSpan(StreamedSpan):
+    def __init__(self, name: "Optional[str]" = None, scope: "Optional[sentry_sdk.Scope]" = None, **kwargs: "Any") -> None:
+        self.name = name
+        self.parent_span_id = None
+        self.segment = None
+        self._scope = scope
+        self._context_manager_state = None
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__name__}("
+            f"name={self.name}, "
+            f"sampled={self.sampled})>"
+        )
+
+    def __enter__(self) -> "NoOpStreamedSpan":
+        if self._scope is None:
+            return self
+
+        scope = self._scope or sentry_sdk.get_current_scope()
+        old_span = scope.span
+        scope.span = self
+        self._context_manager_state = (scope, old_span)
+        return self
+
+    def __exit__(
+        self, ty: "Optional[Any]", value: "Optional[Any]", tb: "Optional[Any]"
+    ) -> None:
+        client = sentry_sdk.get_client()
+        if not client.is_active():
+            return
+        transport = client.transport
+        if not transport:
+            return
+
+        transport.record_lost_event(
+            reason="ignored",
+            data_category="span",
+            quantity=1,
+        )
+
+        if self._context_manager_state is None:
+            return
+
+        with capture_internal_exceptions():
+            scope, old_span = self._context_manager_state
+            del self._context_manager_state
+            scope.span = old_span
+
+    def start(self) -> None:
+        return self.__enter__()
+
+    def end(self) -> None:
+        self.__exit__(None, None, None)
+
+    def finish(self) -> None:
+        pass
+
+    def get_attributes(self) -> "Attributes":
+        return {}
+
+    def set_attribute(self, key: str, value: "AttributeValue") -> None:
+        pass
+
+    def set_attributes(self) -> None:
+        pass
+
+    def remove_attribute(self, key: str) -> None:
+        pass
+
+    def set_name(self, name: str) -> None:
+        pass
+
+    def get_name(self) -> str:
+        return ""
+
+    def set_flag(self) -> None:
+        pass
+
+    def set_op(self, op: str) -> None:
+        pass
+
+    def set_origin(self, origin: str) -> None:
+        pass
+
+    def set_source(self, source: "Union[str, SegmentSource]") -> None:
+        pass
+
+    def is_segment(self) -> bool:
+        return False
+
+    @property
+    def span_id(self) -> str:
+        return "000000"
+
+    @property
+    def trace_id(self) -> str:
+        return "000000"
+
+    @property
+    def sampled(self) -> "Optional[bool]":
+        return False
+
+    def dynamic_sampling_context(self) -> dict[str, str]:
+        return {}
+
+    def get_baggage(self) -> "Baggage":
+        return Baggage()
+
+    def to_baggage(self) -> "Optional[Baggage]":
+        return None
+
+    def to_traceparent(self) -> str:
+        return "0000-0000-0"
+
+    def iter_headers(self) -> "Iterator[tuple[str, str]]":
+        return
+
+    def _set_segment_attributes(self) -> None:
+        pass
+
+
 def trace(
     func: "Optional[Callable[P, R]]" = None,
     *,