Merge branch 'master' into feat/span-first

Author: sentrivana

sentry_sdk/scope.py

@@ -31,7 +31,8 @@
     has_tracing_enabled,
     has_span_streaming_enabled,
     is_ignored_span,
-    make_sampling_decision,
+    _make_sampling_decision,
+    normalize_incoming_data,
     PropagationContext,
 )
 from sentry_sdk.traces import _DEFAULT_PARENT_SPAN, StreamedSpan, NoOpStreamedSpan
@@ -1252,7 +1253,7 @@ def start_streamed_span(
                     unsampled_reason="ignored",
                 )
 
-            sampled, sample_rate, sample_rand, outcome = make_sampling_decision(
+            sampled, sample_rate, sample_rand, outcome = _make_sampling_decision(
                 name,
                 attributes,
                 self,

sentry_sdk/traces.py

@@ -280,16 +280,6 @@ def __init__(
         self._start_timestamp = datetime.now(timezone.utc)
         self._timestamp: "Optional[datetime]" = None
 
-        try:
-            # profiling depends on this value and requires that
-            # it is measured in nanoseconds
-            self._start_timestamp_monotonic_ns = nanosecond_time()
-        except AttributeError:
-            pass
-
-        self._start_timestamp = datetime.now(timezone.utc)
-        self._timestamp: "Optional[datetime]" = None
-
         try:
             # profiling depends on this value and requires that
             # it is measured in nanoseconds
@@ -393,7 +383,9 @@ def _end(self, end_timestamp: "Optional[Union[float, datetime]]" = None) -> None
             if isinstance(end_timestamp, datetime):
                 self._timestamp = end_timestamp
             else:
-                logger.debug("Failed to set end_timestamp. Using current time instead.")
+                logger.debug(
+                    "[Tracing] Failed to set end_timestamp. Using current time instead."
+                )
 
         if self._timestamp is None:
             try:
@@ -438,7 +430,7 @@ def status(self, status: "Union[SpanStatus, str]") -> None:
 
         if status not in {e.value for e in SpanStatus}:
             logger.debug(
-                f'Unsupported span status {status}. Expected one of: "ok", "error"'
+                f'[Tracing] Unsupported span status {status}. Expected one of: "ok", "error"'
             )
             return
 
@@ -579,7 +571,10 @@ def _start_profile(self) -> None:
 
 
 class NoOpStreamedSpan(StreamedSpan):
-    __slots__ = ("_unsampled_reason",)
+    __slots__ = (
+        "_finished",
+        "_unsampled_reason",
+    )
 
     def __init__(
         self,
@@ -590,6 +585,7 @@ def __init__(
         self._unsampled_reason = unsampled_reason
 
         self._segment = None  # type: ignore[assignment]
+        self._finished = False
 
         self._start()
 
@@ -621,25 +617,28 @@ def _start(self) -> None:
         self._previous_span_on_scope = old_span
 
     def _end(self, end_timestamp: "Optional[Union[float, datetime]]" = None) -> None:
-        client = sentry_sdk.get_client()
-        if client and client.transport:
-            logger.debug("Discarding span because sampled = False")
-            client.transport.record_lost_event(
-                reason=self._unsampled_reason or "sample_rate",
-                data_category="span",
-                quantity=1,
-            )
-
-        if self._scope is None:
+        if self._finished:
             return
 
-        if not hasattr(self, "_previous_span_on_scope"):
-            return
+        if self._unsampled_reason is not None:
+            client = sentry_sdk.get_client()
+            if client.is_active() and client.transport:
+                logger.debug(
+                    f"[Tracing] Discarding span because sampled=False (reason: {self._unsampled_reason})"
+                )
+                client.transport.record_lost_event(
+                    reason=self._unsampled_reason,
+                    data_category="span",
+                    quantity=1,
+                )
+
+        if self._scope and hasattr(self, "_previous_span_on_scope"):
+            with capture_internal_exceptions():
+                old_span = self._previous_span_on_scope
+                del self._previous_span_on_scope
+                self._scope.span = old_span
 
-        with capture_internal_exceptions():
-            old_span = self._previous_span_on_scope
-            del self._previous_span_on_scope
-            self._scope.span = old_span
+        self._finished = True
 
     def end(self, end_timestamp: "Optional[Union[float, datetime]]" = None) -> None:
         self._end()

sentry_sdk/tracing_utils.py

@@ -1490,21 +1490,19 @@ def add_sentry_baggage_to_headers(
     )
 
 
-def make_sampling_decision(
+def _make_sampling_decision(
     name: str,
     attributes: "Optional[Attributes]",
     scope: "sentry_sdk.Scope",
 ) -> "tuple[bool, Optional[float], Optional[float], Optional[str]]":
     """
     Decide whether a span should be sampled.
 
-    Use traces_sampler if defined, otherwise traces_sample_rate.
-
     Returns a tuple with:
-    - the sampling decision
-    - the effective sample rate
-    - the sample rand
-    - the reason for not sampling the span, if unsampled
+    1. the sampling decision
+    2. the effective sample rate
+    3. the sample rand
+    4. the reason for not sampling the span, if unsampled
     """
     client = sentry_sdk.get_client()
 
@@ -1519,53 +1517,50 @@ def make_sampling_decision(
     if sample_rand is None:
         sample_rand = _generate_sample_rand(propagation_context.trace_id)
 
-    sampling_context = {
-        "name": name,
-        "trace_id": propagation_context.trace_id,
-        "parent_span_id": propagation_context.parent_span_id,
-        "parent_sampled": propagation_context.parent_sampled,
-        "attributes": attributes or {},
-    }
-    if propagation_context.custom_sampling_context:
-        sampling_context.update(propagation_context.custom_sampling_context)
-
     # If there's a traces_sampler, use that; otherwise use traces_sample_rate
     traces_sampler_defined = callable(client.options.get("traces_sampler"))
     if traces_sampler_defined:
+        sampling_context = {
+            "name": name,
+            "trace_id": propagation_context.trace_id,
+            "parent_span_id": propagation_context.parent_span_id,
+            "parent_sampled": propagation_context.parent_sampled,
+            "attributes": dict(attributes) if attributes else {},
+        }
+
+        if propagation_context.custom_sampling_context:
+            sampling_context.update(propagation_context.custom_sampling_context)
+
         sample_rate = client.options["traces_sampler"](sampling_context)
     else:
-        if sampling_context["parent_sampled"] is not None:
-            sample_rate = sampling_context["parent_sampled"]
+        if propagation_context.parent_sampled is not None:
+            sample_rate = propagation_context.parent_sampled
         else:
             sample_rate = client.options["traces_sample_rate"]
 
     # Validate whether the sample_rate we got is actually valid. Since
     # traces_sampler is user-provided, it could return anything.
     if not is_valid_sample_rate(sample_rate, source="Tracing"):
         logger.warning(f"[Tracing] Discarding {name} because of invalid sample rate.")
-        return False, None, None, None
+        return False, None, None, "sample_rate"
 
     sample_rate = float(sample_rate)
-
-    # Adjust sample rate if we're under backpressure
-    if client.monitor:
-        sample_rate /= 2**client.monitor.downsample_factor
-
-    outcome: "Optional[str]" = None
-
     if not sample_rate:
         if traces_sampler_defined:
             reason = "traces_sampler returned 0 or False"
         else:
             reason = "traces_sample_rate is set to 0"
 
         logger.debug(f"[Tracing] Discarding {name} because {reason}")
-        if client.monitor and client.monitor.downsample_factor > 0:
-            outcome = "backpressure"
-        else:
-            outcome = "sample_rate"
+        return False, 0.0, None, "sample_rate"
+
+    # Adjust sample rate if we're under backpressure
+    if client.monitor:
+        sample_rate /= 2**client.monitor.downsample_factor
 
-        return False, 0.0, None, outcome
+        if not sample_rate:
+            logger.debug(f"[Tracing] Discarding {name} because backpressure")
+            return False, 0.0, None, "backpressure"
 
     sampled = sample_rand < sample_rate