sentry-sdk 2.26.1__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/tracing_utils.py

@@ -1,18 +1,25 @@
 import contextlib
+import decimal
 import inspect
 import os
 import re
 import sys
+import uuid
 from collections.abc import Mapping
-from datetime import timedelta
-from decimal import ROUND_DOWN, Context, Decimal
+from datetime import datetime, timedelta, timezone
+from decimal import ROUND_DOWN, Decimal, DefaultContext, localcontext
 from functools import wraps
 from random import Random
 from urllib.parse import quote, unquote
-import uuid
 
 import sentry_sdk
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import (
+    OP,
+    SPANDATA,
+    SPANSTATUS,
+    BAGGAGE_HEADER_NAME,
+    SENTRY_TRACE_HEADER_NAME,
+)
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     filename_for_module,
@@ -21,7 +28,6 @@ from sentry_sdk.utils import (
     match_regex_list,
     qualname_from_function,
     to_string,
-    try_convert,
     is_sentry_url,
     _is_external_source,
     _is_in_project_root,
@@ -36,7 +42,6 @@ if TYPE_CHECKING:
     from typing import Generator
     from typing import Optional
     from typing import Union
-
     from types import FrameType
 
 
@@ -96,17 +101,14 @@ def has_tracing_enabled(options):
     # type: (Optional[Dict[str, Any]]) -> bool
     """
     Returns True if either traces_sample_rate or traces_sampler is
-    defined and enable_tracing is set and not false.
+    defined.
     """
     if options is None:
         return False
 
     return bool(
-        options.get("enable_tracing") is not False
-        and (
-            options.get("traces_sample_rate") is not None
-            or options.get("traces_sampler") is not None
-        )
+        options.get("traces_sample_rate") is not None
+        or options.get("traces_sampler") is not None
     )
 
 
@@ -118,7 +120,7 @@ def record_sql_queries(
     paramstyle,  # type: Optional[str]
     executemany,  # type: bool
     record_cursor_repr=False,  # type: bool
-    span_origin="manual",  # type: str
+    span_origin=None,  # type: Optional[str]
 ):
     # type: (...) -> Generator[sentry_sdk.tracing.Span, None, None]
 
@@ -152,44 +154,13 @@ def record_sql_queries(
         op=OP.DB,
         name=query,
         origin=span_origin,
+        only_if_parent=True,
     ) as span:
         for k, v in data.items():
-            span.set_data(k, v)
+            span.set_attribute(k, v)
         yield span
 
 
-def maybe_create_breadcrumbs_from_span(scope, span):
-    # type: (sentry_sdk.Scope, sentry_sdk.tracing.Span) -> None
-    if span.op == OP.DB_REDIS:
-        scope.add_breadcrumb(
-            message=span.description, type="redis", category="redis", data=span._tags
-        )
-
-    elif span.op == OP.HTTP_CLIENT:
-        level = None
-        status_code = span._data.get(SPANDATA.HTTP_STATUS_CODE)
-        if status_code:
-            if 500 <= status_code <= 599:
-                level = "error"
-            elif 400 <= status_code <= 499:
-                level = "warning"
-
-        if level:
-            scope.add_breadcrumb(
-                type="http", category="httplib", data=span._data, level=level
-            )
-        else:
-            scope.add_breadcrumb(type="http", category="httplib", data=span._data)
-
-    elif span.op == "subprocess":
-        scope.add_breadcrumb(
-            type="subprocess",
-            category="subprocess",
-            message=span.description,
-            data=span._data,
-        )
-
-
 def _get_frame_module_abs_path(frame):
     # type: (FrameType) -> Optional[str]
     try:
@@ -227,14 +198,17 @@ def add_query_source(span):
     if not client.is_active():
         return
 
-    if span.timestamp is None or span.start_timestamp is None:
+    if span.start_timestamp is None:
         return
 
     should_add_query_source = client.options.get("enable_db_query_source", True)
     if not should_add_query_source:
         return
 
-    duration = span.timestamp - span.start_timestamp
+    # We assume here that the query is just ending now. We can't use
+    # the actual end timestamp of the span because in OTel the span
+    # can't be finished in order to set any attributes on it.
+    duration = datetime.now(tz=timezone.utc) - span.start_timestamp
     threshold = client.options.get("db_query_source_threshold_ms", 0)
     slow_query = duration / timedelta(milliseconds=1) > threshold
 
@@ -281,14 +255,14 @@ def add_query_source(span):
         except Exception:
             lineno = None
         if lineno is not None:
-            span.set_data(SPANDATA.CODE_LINENO, frame.f_lineno)
+            span.set_attribute(SPANDATA.CODE_LINENO, frame.f_lineno)
 
         try:
             namespace = frame.f_globals.get("__name__")
         except Exception:
             namespace = None
         if namespace is not None:
-            span.set_data(SPANDATA.CODE_NAMESPACE, namespace)
+            span.set_attribute(SPANDATA.CODE_NAMESPACE, namespace)
 
         filepath = _get_frame_module_abs_path(frame)
         if filepath is not None:
@@ -298,7 +272,7 @@ def add_query_source(span):
                 in_app_path = filepath.replace(project_root, "").lstrip(os.sep)
             else:
                 in_app_path = filepath
-            span.set_data(SPANDATA.CODE_FILEPATH, in_app_path)
+            span.set_attribute(SPANDATA.CODE_FILEPATH, in_app_path)
 
         try:
             code_function = frame.f_code.co_name
@@ -306,7 +280,7 @@ def add_query_source(span):
             code_function = None
 
         if code_function is not None:
-            span.set_data(SPANDATA.CODE_FUNCTION, frame.f_code.co_name)
+            span.set_attribute(SPANDATA.CODE_FUNCTION, frame.f_code.co_name)
 
 
 def extract_sentrytrace_data(header):
@@ -371,7 +345,7 @@ class PropagationContext:
         "_span_id",
         "parent_span_id",
         "parent_sampled",
-        "dynamic_sampling_context",
+        "baggage",
     )
 
     def __init__(
@@ -380,7 +354,7 @@ class PropagationContext:
         span_id=None,  # type: Optional[str]
         parent_span_id=None,  # type: Optional[str]
         parent_sampled=None,  # type: Optional[bool]
-        dynamic_sampling_context=None,  # type: Optional[Dict[str, str]]
+        baggage=None,  # type: Optional[Baggage]
     ):
         # type: (...) -> None
         self._trace_id = trace_id
@@ -398,8 +372,13 @@ class PropagationContext:
         Important when the parent span originated in an upstream service,
         because we want to sample the whole trace, or nothing from the trace."""
 
-        self.dynamic_sampling_context = dynamic_sampling_context
-        """Data that is used for dynamic sampling decisions."""
+        self.baggage = baggage
+        """Baggage object used for dynamic sampling decisions."""
+
+    @property
+    def dynamic_sampling_context(self):
+        # type: () -> Optional[Dict[str, str]]
+        return self.baggage.dynamic_sampling_context() if self.baggage else None
 
     @classmethod
     def from_incoming_data(cls, incoming_data):
@@ -410,9 +389,7 @@ class PropagationContext:
         baggage_header = normalized_data.get(BAGGAGE_HEADER_NAME)
         if baggage_header:
             propagation_context = PropagationContext()
-            propagation_context.dynamic_sampling_context = Baggage.from_incoming_header(
-                baggage_header
-            ).dynamic_sampling_context()
+            propagation_context.baggage = Baggage.from_incoming_header(baggage_header)
 
         sentry_trace_header = normalized_data.get(SENTRY_TRACE_HEADER_NAME)
         if sentry_trace_header:
@@ -432,7 +409,6 @@ class PropagationContext:
         # type: () -> str
         """The trace id of the Sentry trace."""
         if not self._trace_id:
-            # New trace, don't fill in sample_rand
             self._trace_id = uuid.uuid4().hex
 
         return self._trace_id
@@ -456,6 +432,21 @@ class PropagationContext:
         # type: (str) -> None
         self._span_id = value
 
+    def to_traceparent(self):
+        # type: () -> str
+        if self.parent_sampled is True:
+            sampled = "1"
+        elif self.parent_sampled is False:
+            sampled = "0"
+        else:
+            sampled = None
+
+        traceparent = "%s-%s" % (self.trace_id, self.span_id)
+        if sampled is not None:
+            traceparent += "-%s" % (sampled,)
+
+        return traceparent
+
     def update(self, other_dict):
         # type: (Dict[str, Any]) -> None
         """
@@ -467,22 +458,12 @@ class PropagationContext:
             except AttributeError:
                 pass
 
-    def __repr__(self):
-        # type: (...) -> str
-        return "<PropagationContext _trace_id={} _span_id={} parent_span_id={} parent_sampled={} dynamic_sampling_context={}>".format(
-            self._trace_id,
-            self._span_id,
-            self.parent_span_id,
-            self.parent_sampled,
-            self.dynamic_sampling_context,
-        )
-
     def _fill_sample_rand(self):
         # type: () -> None
         """
-        Ensure that there is a valid sample_rand value in the dynamic_sampling_context.
+        Ensure that there is a valid sample_rand value in the baggage.
 
-        If there is a valid sample_rand value in the dynamic_sampling_context, we keep it.
+        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
@@ -497,21 +478,33 @@ class PropagationContext:
 
         This function does nothing if there is no dynamic_sampling_context.
         """
-        if self.dynamic_sampling_context is None:
+        if self.dynamic_sampling_context is None or self.baggage is None:
             return
 
-        sample_rand = try_convert(
-            Decimal, self.dynamic_sampling_context.get("sample_rand")
-        )
+        sentry_baggage = self.baggage.sentry_items
+
+        sample_rand = None
+        if sentry_baggage.get("sample_rand"):
+            try:
+                sample_rand = Decimal(sentry_baggage["sample_rand"])
+            except Exception:
+                logger.debug(
+                    f"Failed to convert incoming sample_rand to Decimal: {sample_rand}"
+                )
+
         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).
-        sample_rate = try_convert(
-            float, self.dynamic_sampling_context.get("sample_rate")
-        )
+        sample_rate = None
+        if sentry_baggage.get("sample_rate"):
+            try:
+                sample_rate = float(sentry_baggage["sample_rate"])
+            except Exception:
+                logger.debug(
+                    f"Failed to convert incoming sample_rate to float: {sample_rate}"
+                )
+
         lower, upper = _sample_rand_range(self.parent_sampled, sample_rate)
 
         try:
@@ -527,17 +520,26 @@ class PropagationContext:
             )
             return
 
-        self.dynamic_sampling_context["sample_rand"] = (
-            f"{sample_rand:.6f}"  # noqa: E231
-        )
+        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.dynamic_sampling_context is None:
+        """Convenience method to get the sample_rand value from the baggage."""
+        if self.baggage is None:
             return None
 
-        return self.dynamic_sampling_context.get("sample_rand")
+        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(
+            self._trace_id,
+            self._span_id,
+            self.parent_span_id,
+            self.parent_sampled,
+            self.baggage,
+            self.dynamic_sampling_context,
+        )
 
 
 class Baggage:
@@ -568,8 +570,6 @@ class Baggage:
     def from_incoming_header(
         cls,
         header,  # type: Optional[str]
-        *,
-        _sample_rand=None,  # type: Optional[str]
     ):
         # type: (...) -> Baggage
         """
@@ -594,10 +594,6 @@ class Baggage:
                     else:
                         third_party_items += ("," if third_party_items else "") + item
 
-        if _sample_rand is not None:
-            sentry_items["sample_rand"] = str(_sample_rand)
-            mutable = False
-
         return Baggage(sentry_items, third_party_items, mutable)
 
     @classmethod
@@ -633,53 +629,6 @@ class Baggage:
 
         return Baggage(sentry_items, third_party_items, mutable)
 
-    @classmethod
-    def populate_from_transaction(cls, transaction):
-        # type: (sentry_sdk.tracing.Transaction) -> Baggage
-        """
-        Populate fresh baggage entry with sentry_items and make it immutable
-        if this is the head SDK which originates traces.
-        """
-        client = sentry_sdk.get_client()
-        sentry_items = {}  # type: Dict[str, str]
-
-        if not client.is_active():
-            return Baggage(sentry_items)
-
-        options = client.options or {}
-
-        sentry_items["trace_id"] = transaction.trace_id
-        sentry_items["sample_rand"] = str(transaction._sample_rand)
-
-        if options.get("environment"):
-            sentry_items["environment"] = options["environment"]
-
-        if options.get("release"):
-            sentry_items["release"] = options["release"]
-
-        if options.get("dsn"):
-            sentry_items["public_key"] = Dsn(options["dsn"]).public_key
-
-        if (
-            transaction.name
-            and transaction.source not in LOW_QUALITY_TRANSACTION_SOURCES
-        ):
-            sentry_items["transaction"] = transaction.name
-
-        if transaction.sample_rate is not None:
-            sentry_items["sample_rate"] = str(transaction.sample_rate)
-
-        if transaction.sampled is not None:
-            sentry_items["sampled"] = "true" if transaction.sampled else "false"
-
-        # there's an existing baggage but it was mutable,
-        # which is why we are creating this new baggage.
-        # However, if by chance the user put some sentry items in there, give them precedence.
-        if transaction._baggage and transaction._baggage.sentry_items:
-            sentry_items.update(transaction._baggage.sentry_items)
-
-        return Baggage(sentry_items, mutable=False)
-
     def freeze(self):
         # type: () -> None
         self.mutable = False
@@ -722,20 +671,6 @@ class Baggage:
             )
         )
 
-    def _sample_rand(self):
-        # type: () -> Optional[Decimal]
-        """Convenience method to get the sample_rand value from the sentry_items.
-
-        We validate the value and parse it as a Decimal before returning it. The value is considered
-        valid if it is a Decimal in the range [0, 1).
-        """
-        sample_rand = try_convert(Decimal, self.sentry_items.get("sample_rand"))
-
-        if sample_rand is not None and Decimal(0) <= sample_rand < Decimal(1):
-            return sample_rand
-
-        return None
-
     def __repr__(self):
         # type: () -> str
         return f'<Baggage "{self.serialize(include_third_party=True)}", mutable={self.mutable}>'
@@ -837,7 +772,7 @@ def start_child_span_decorator(func):
 
 
 def get_current_span(scope=None):
-    # type: (Optional[sentry_sdk.Scope]) -> Optional[Span]
+    # type: (Optional[sentry_sdk.Scope]) -> Optional[sentry_sdk.tracing.Span]
     """
     Returns the currently active span if there is one running, otherwise `None`
     """
@@ -848,10 +783,9 @@ def get_current_span(scope=None):
 
 def _generate_sample_rand(
     trace_id,  # type: Optional[str]
-    *,
     interval=(0.0, 1.0),  # type: tuple[float, float]
 ):
-    # type: (...) -> Decimal
+    # type: (...) -> Optional[decimal.Decimal]
     """Generate a sample_rand value from a trace ID.
 
     The generated value will be pseudorandomly chosen from the provided
@@ -872,10 +806,13 @@ def _generate_sample_rand(
 
     # Round down to exactly six decimal-digit precision.
     # Setting the context is needed to avoid an InvalidOperation exception
-    # in case the user has changed the default precision.
-    return Decimal(sample_rand).quantize(
-        Decimal("0.000001"), rounding=ROUND_DOWN, context=Context(prec=6)
-    )
+    # in case the user has changed the default precision or set traps.
+    with localcontext(DefaultContext) as ctx:
+        ctx.prec = 6
+        return Decimal(sample_rand).quantize(
+            Decimal("0.000001"),
+            rounding=ROUND_DOWN,
+        )
 
 
 def _sample_rand_range(parent_sampled, sample_rate):
@@ -893,12 +830,40 @@ def _sample_rand_range(parent_sampled, sample_rate):
         return sample_rate, 1.0
 
 
-# Circular imports
-from sentry_sdk.tracing import (
-    BAGGAGE_HEADER_NAME,
-    LOW_QUALITY_TRANSACTION_SOURCES,
-    SENTRY_TRACE_HEADER_NAME,
-)
+def get_span_status_from_http_code(http_status_code):
+    # type: (int) -> str
+    """
+    Returns the Sentry status corresponding to the given HTTP status code.
 
-if TYPE_CHECKING:
-    from sentry_sdk.tracing import Span
+    See: https://develop.sentry.dev/sdk/event-payloads/contexts/#trace-context
+    """
+    if http_status_code < 400:
+        return SPANSTATUS.OK
+
+    elif 400 <= http_status_code < 500:
+        if http_status_code == 403:
+            return SPANSTATUS.PERMISSION_DENIED
+        elif http_status_code == 404:
+            return SPANSTATUS.NOT_FOUND
+        elif http_status_code == 429:
+            return SPANSTATUS.RESOURCE_EXHAUSTED
+        elif http_status_code == 413:
+            return SPANSTATUS.FAILED_PRECONDITION
+        elif http_status_code == 401:
+            return SPANSTATUS.UNAUTHENTICATED
+        elif http_status_code == 409:
+            return SPANSTATUS.ALREADY_EXISTS
+        else:
+            return SPANSTATUS.INVALID_ARGUMENT
+
+    elif 500 <= http_status_code < 600:
+        if http_status_code == 504:
+            return SPANSTATUS.DEADLINE_EXCEEDED
+        elif http_status_code == 501:
+            return SPANSTATUS.UNIMPLEMENTED
+        elif http_status_code == 503:
+            return SPANSTATUS.UNAVAILABLE
+        else:
+            return SPANSTATUS.INTERNAL_ERROR
+
+    return SPANSTATUS.UNKNOWN_ERROR