.

Author: sentrivana

sentry_sdk/tracing_utils.py

@@ -7,7 +7,7 @@
 import uuid
 from collections.abc import Mapping
 from datetime import datetime, timedelta, timezone
-from decimal import ROUND_DOWN, Context, Decimal
+from decimal import ROUND_DOWN, Context, Decimal, InvalidOperation
 from functools import wraps
 from random import Random
 from urllib.parse import quote, unquote
@@ -393,6 +393,9 @@ def from_incoming_data(cls, incoming_data):
                     propagation_context = PropagationContext()
                 propagation_context.update(sentrytrace_data)
 
+        if propagation_context is not None:
+            propagation_context._fill_sample_rand()
+
         return propagation_context
 
     @property
@@ -434,6 +437,70 @@ def update(self, other_dict):
             except AttributeError:
                 pass
 
+    def _fill_sample_rand(self):
+        # type: () -> None
+        """
+        Ensure that there is a valid sample_rand value in the baggage.
+
+        If there is a valid sample_rand value in the baggage, we keep it.
+        Otherwise, we generate a sample_rand value according to the following:
+
+          - If we have a parent_sampled value and a sample_rate in the DSC, we compute
+            a sample_rand value randomly in the range:
+                - [0, sample_rate) if parent_sampled is True,
+                - or, in the range [sample_rate, 1) if parent_sampled is False.
+
+          - If either parent_sampled or sample_rate is missing, we generate a random
+            value in the range [0, 1).
+
+        The sample_rand is deterministically generated from the trace_id, if present.
+
+        This function does nothing if there is no dynamic_sampling_context.
+        """
+        if self.dynamic_sampling_context is None:
+            return
+
+        try:
+            sample_rand = Decimal(self.baggage.sentry_items.get("sample_rand"))
+        except (TypeError, ValueError, InvalidOperation):
+            sample_rand = None
+
+        if sample_rand is not None and 0 <= sample_rand < 1:
+            # sample_rand is present and valid, so don't overwrite it
+            return
+
+        # Get the sample rate and compute the transformation that will map the random value
+        # to the desired range: [0, 1), [0, sample_rate), or [sample_rate, 1).
+        try:
+            sample_rate = float(self.baggage.sentry_items.get("sample_rate"))
+        except (TypeError, ValueError):
+            sample_rate = None
+
+        lower, upper = _sample_rand_range(self.parent_sampled, sample_rate)
+
+        try:
+            sample_rand = _generate_sample_rand(self.trace_id, interval=(lower, upper))
+        except ValueError:
+            # ValueError is raised if the interval is invalid, i.e. lower >= upper.
+            # lower >= upper might happen if the incoming trace's sampled flag
+            # and sample_rate are inconsistent, e.g. sample_rate=0.0 but sampled=True.
+            # We cannot generate a sensible sample_rand value in this case.
+            logger.debug(
+                f"Could not backfill sample_rand, since parent_sampled={self.parent_sampled} "
+                f"and sample_rate={sample_rate}."
+            )
+            return
+
+        self.baggage.sentry_items["sample_rand"] = f"{sample_rand:.6f}"  # noqa: E231
+
+    def _sample_rand(self):
+        # type: () -> Optional[str]
+        """Convenience method to get the sample_rand value from the dynamic_sampling_context."""
+        if self.baggage is None:
+            return None
+
+        return self.baggage.sentry_items.get("sample_rand")
+
     def __repr__(self):
         # type: (...) -> str
         return "<PropagationContext _trace_id={} _span_id={} parent_span_id={} parent_sampled={} baggage={} dynamic_sampling_context={}>".format(

tests/test_propagationcontext.py

@@ -104,11 +104,11 @@ def test_update():
 def test_existing_sample_rand_kept():
     ctx = PropagationContext(
         trace_id="00000000000000000000000000000000",
-        dynamic_sampling_context={"sample_rand": "0.5"},
+        baggage=Baggage(sentry_items={"sample_rand": "0.5"}),
     )
 
-    # If sample_rand was regenerated, the value would be 0.919221 based on the trace_id
     assert ctx.dynamic_sampling_context["sample_rand"] == "0.5"
+    assert ctx.baggage.sentry_items["sample_rand"] == "0.5"
 
 
 @pytest.mark.parametrize(
@@ -158,7 +158,7 @@ def mock_random_class(seed):
         )
 
     assert (
-        ctx.dynamic_sampling_context["sample_rand"]
+        ctx.dynamic_sampling_context.get("sample_rand")
         == f"{expected_interval[0]:.6f}"  # noqa: E231
     )
     assert mock_uniform.call_count == 1

tests/tracing/test_sample_rand.py

@@ -4,7 +4,7 @@
 import pytest
 
 import sentry_sdk
-from sentry_sdk.tracing_utils import Baggage
+from sentry_sdk.tracing import BAGGAGE_HEADER_NAME, SENTRY_TRACE_HEADER_NAME
 
 
 @pytest.mark.parametrize("sample_rand", (0.0, 0.25, 0.5, 0.75))
@@ -40,16 +40,20 @@ def test_transaction_uses_incoming_sample_rand(
     """
     Test that the transaction uses the sample_rand value from the incoming baggage.
     """
-    baggage = Baggage(sentry_items={"sample_rand": f"{sample_rand:.6f}"})  # noqa: E231
-
     sentry_init(traces_sample_rate=sample_rate)
     events = capture_events()
 
-    with sentry_sdk.start_span(baggage=baggage) as root_span:
-        assert (
-            root_span.get_baggage().sentry_items["sample_rand"]
-            == f"{sample_rand:.6f}"  # noqa: E231
-        )
+    baggage = f"sentry-sample_rand={sample_rand:.6f},sentry-trace_id=771a43a4192642f0b136d5159a501700"  # noqa: E231
+    sentry_trace = "771a43a4192642f0b136d5159a501700-1234567890abcdef"
+
+    with sentry_sdk.continue_trace(
+        {BAGGAGE_HEADER_NAME: baggage, SENTRY_TRACE_HEADER_NAME: sentry_trace}
+    ):
+        with sentry_sdk.start_span() as root_span:
+            assert (
+                root_span.get_baggage().sentry_items["sample_rand"]
+                == f"{sample_rand:.6f}"  # noqa: E231
+            )
 
     # Transaction event captured if sample_rand < sample_rate, indicating that
     # sample_rand is used to make the sampling decision.