reimplement ignore_spans

Author: sentrivana

sentry_sdk/_span_batcher.py

@@ -79,10 +79,13 @@ def _to_transport_format(item: "StreamedSpan") -> "Any":
         }
 
         if item.timestamp:
-            # this is here to make mypy happy
             res["end_timestamp"] = item.timestamp.timestamp()
 
-        if item.parent_span_id:
+        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:
             res["parent_span_id"] = item.parent_span_id
 
         if item.attributes:

sentry_sdk/scope.py

@@ -34,7 +34,7 @@
     normalize_incoming_data,
     PropagationContext,
 )
-from sentry_sdk.traces import StreamedSpan, NoOpStreamedSpan
+from sentry_sdk.traces import StreamedSpan
 from sentry_sdk.tracing import (
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
@@ -1232,53 +1232,62 @@ def start_streamed_span(
     ) -> "StreamedSpan":
         # TODO: rename to start_span once we drop the old API
         if parent_span is None:
-            # Get currently active span
             parent_span = self.span or self.get_current_scope().span  # type: ignore
 
-        if isinstance(parent_span, NoOpStreamedSpan):
-            # If the parent is an ignored span, attempt to reparent to the
-            # first non-ignored ancestor
-            parent_span = parent_span.last_valid_parent
-
         # If no specific parent_span provided and there is no currently
         # active span, this is a segment
         if parent_span is None:
             propagation_context = self.get_active_propagation_context()
 
-            span: "Union[StreamedSpan, NoOpStreamedSpan]"
+            unsampled_reason = None
             if is_ignored_span(name, attributes):
-                span = NoOpStreamedSpan(name=name, scope=self, last_valid_parent=None)
-            else:
-                span = StreamedSpan(
-                    name=name,
-                    attributes=attributes,
-                    scope=self,
-                    segment=None,
-                    trace_id=propagation_context.trace_id,
-                    parent_span_id=propagation_context.parent_span_id,
-                    parent_sampled=propagation_context.parent_sampled,
-                    baggage=propagation_context.baggage,
-                )
+                unsampled_reason = "ignored"
+
+            span = StreamedSpan(
+                name=name,
+                attributes=attributes,
+                scope=self,
+                segment=None,
+                trace_id=propagation_context.trace_id,
+                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):
-                span = NoOpStreamedSpan(
-                    name=name, scope=self, last_valid_parent=parent_span
-                )
-            else:
-                span = 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,
+                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
                 )
 
+            span = 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:

sentry_sdk/traces.py

@@ -223,6 +223,8 @@ class StreamedSpan:
         "sample_rate",
         "_sample_rand",
         "_finished",
+        "_unsampled_reason",
+        "_last_valid_parent_id",
     )
 
     def __init__(
@@ -241,6 +243,9 @@ def __init__(
         parent_sampled: "Optional[bool]" = None,
         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
 
@@ -269,8 +274,10 @@ def __init__(
         self.set_source(SegmentSource.CUSTOM)
         # XXX[span-first] ^ populate this correctly
 
-        self._sampled: "Optional[bool]" = None
+        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
 
         # XXX[span-first]: just do this for segments?
         self._baggage = baggage
@@ -394,6 +401,8 @@ 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"
 
@@ -489,7 +498,7 @@ def sampled(self) -> "Optional[bool]":
             return self._sampled
 
         if not self.is_segment():
-            self._sampled = self.parent_sampled
+            self._sampled = self.segment.sampled
 
         return self._sampled
 
@@ -566,14 +575,16 @@ def _set_sampling_decision(self, sampling_context: "SamplingContext") -> None:
         """Set a segment's sampling decision."""
         client = sentry_sdk.get_client()
 
-        # nothing to do if tracing is disabled
         if not has_tracing_enabled(client.options):
             self._sampled = False
             return
 
         if not self.is_segment():
             return
 
+        if self._sampled is not None:
+            return
+
         traces_sampler_defined = callable(client.options.get("traces_sampler"))
 
         # We would have bailed already if neither `traces_sampler` nor
@@ -631,26 +642,6 @@ def _set_segment_attributes(self) -> None:
         self.set_attribute("sentry.segment.name", self.segment.name)
 
 
-class NoOpStreamedSpan(StreamedSpan):
-    # XXX[span-first]: make this actually no-op
-    def __init__(
-        self,
-        *args: "Any",
-        last_valid_parent: "Optional[StreamedSpan]" = None,
-        **kwargs: "Any",
-    ):
-        self._sampled = False
-        self.last_valid_parent = last_valid_parent
-
-    def __enter__(self) -> "NoOpStreamedSpan":
-        return self
-
-    def __exit__(
-        self, ty: "Optional[Any]", value: "Optional[Any]", tb: "Optional[Any]"
-    ) -> None:
-        return
-
-
 def trace(
     func: "Optional[Callable[P, R]]" = None,
     *,

sentry_sdk/tracing_utils.py

@@ -1481,29 +1481,31 @@ def is_ignored_span(name: str, attributes: "Optional[Attributes]") -> bool:
     if not ignore_spans:
         return False
 
-    def _match_name(rule: "Union[str, Pattern[str]]") -> bool:
+    def _match_string(rule: "Union[str, Pattern[str]]", string: str) -> bool:
         if isinstance(rule, Pattern):
-            return bool(rule.match(name))
-        return rule == name
+            return bool(rule.match(string))
+        return rule == string
 
     for rule in ignore_spans:
         if isinstance(rule, (str, Pattern)):
-            if _match_name(rule):
+            if _match_string(rule, name):
                 return True
 
         elif isinstance(rule, dict):
             name_matches = True
             attributes_match = True
 
             if "name" in rule:
-                name_matches = _match_name(rule["name"])
+                name_matches = _match_string(rule["name"], name)
 
             if "attributes" in rule:
                 if not attributes:
                     attributes_match = False
                 else:
                     for attribute, value in rule["attributes"].items():
-                        if attribute not in attributes:
+                        if attribute not in attributes or not _match_string(
+                            value, attributes[attribute]
+                        ):
                             attributes_match = False
                             break