sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/opentelemetry/sampler.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 from decimal import Decimal
-from typing import cast
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace.sampling import Sampler, SamplingResult, Decision
@@ -21,15 +21,16 @@ from sentry_sdk.utils import is_valid_sample_rate, logger
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Optional, Sequence, Union
+    from typing import Any, Optional, Sequence
     from opentelemetry.context import Context
     from opentelemetry.trace import Link, SpanKind
     from opentelemetry.trace.span import SpanContext
     from opentelemetry.util.types import Attributes
 
 
-def get_parent_sampled(parent_context, trace_id):
-    # type: (Optional[SpanContext], int) -> Optional[bool]
+def get_parent_sampled(
+    parent_context: Optional[SpanContext], trace_id: int
+) -> Optional[bool]:
     if parent_context is None:
         return None
 
@@ -54,8 +55,9 @@ def get_parent_sampled(parent_context, trace_id):
     return None
 
 
-def get_parent_sample_rate(parent_context, trace_id):
-    # type: (Optional[SpanContext], int) -> Optional[float]
+def get_parent_sample_rate(
+    parent_context: Optional[SpanContext], trace_id: int
+) -> Optional[float]:
     if parent_context is None:
         return None
 
@@ -74,8 +76,9 @@ def get_parent_sample_rate(parent_context, trace_id):
     return None
 
 
-def get_parent_sample_rand(parent_context, trace_id):
-    # type: (Optional[SpanContext], int) -> Optional[Decimal]
+def get_parent_sample_rand(
+    parent_context: Optional[SpanContext], trace_id: int
+) -> Optional[Decimal]:
     if parent_context is None:
         return None
 
@@ -91,8 +94,12 @@ def get_parent_sample_rand(parent_context, trace_id):
     return None
 
 
-def dropped_result(span_context, attributes, sample_rate=None, sample_rand=None):
-    # type: (SpanContext, Attributes, Optional[float], Optional[Decimal]) -> SamplingResult
+def dropped_result(
+    span_context: SpanContext,
+    attributes: Attributes,
+    sample_rate: Optional[float] = None,
+    sample_rand: Optional[Decimal] = None,
+) -> SamplingResult:
     """
     React to a span getting unsampled and return a DROP SamplingResult.
 
@@ -129,8 +136,12 @@ def dropped_result(span_context, attributes, sample_rate=None, sample_rand=None)
     )
 
 
-def sampled_result(span_context, attributes, sample_rate=None, sample_rand=None):
-    # type: (SpanContext, Attributes, Optional[float], Optional[Decimal]) -> SamplingResult
+def sampled_result(
+    span_context: SpanContext,
+    attributes: Attributes,
+    sample_rate: Optional[float] = None,
+    sample_rand: Optional[Decimal] = None,
+) -> SamplingResult:
     """
     React to a span being sampled and return a sampled SamplingResult.
 
@@ -151,8 +162,12 @@ def sampled_result(span_context, attributes, sample_rate=None, sample_rand=None)
     )
 
 
-def _update_trace_state(span_context, sampled, sample_rate=None, sample_rand=None):
-    # type: (SpanContext, bool, Optional[float], Optional[Decimal]) -> TraceState
+def _update_trace_state(
+    span_context: SpanContext,
+    sampled: bool,
+    sample_rate: Optional[float] = None,
+    sample_rand: Optional[Decimal] = None,
+) -> TraceState:
     trace_state = span_context.trace_state
 
     sampled = "true" if sampled else "false"
@@ -175,15 +190,14 @@ def _update_trace_state(span_context, sampled, sample_rate=None, sample_rand=Non
 class SentrySampler(Sampler):
     def should_sample(
         self,
-        parent_context,  # type: Optional[Context]
-        trace_id,  # type: int
-        name,  # type: str
-        kind=None,  # type: Optional[SpanKind]
-        attributes=None,  # type: Attributes
-        links=None,  # type: Optional[Sequence[Link]]
-        trace_state=None,  # type: Optional[TraceState]
-    ):
-        # type: (...) -> SamplingResult
+        parent_context: Optional[Context],
+        trace_id: int,
+        name: str,
+        kind: Optional[SpanKind] = None,
+        attributes: Attributes = None,
+        links: Optional[Sequence[Link]] = None,
+        trace_state: Optional[TraceState] = None,
+    ) -> SamplingResult:
         client = sentry_sdk.get_client()
 
         parent_span_context = trace.get_current_span(parent_context).get_span_context()
@@ -209,13 +223,12 @@ class SentrySampler(Sampler):
             sample_rand = parent_sample_rand
         else:
             # We are the head SDK and we need to generate a new sample_rand
-            sample_rand = cast(Decimal, _generate_sample_rand(str(trace_id), (0, 1)))
+            sample_rand = _generate_sample_rand(str(trace_id), (0, 1))
 
         # Explicit sampled value provided at start_span
-        custom_sampled = cast(
-            "Optional[bool]", attributes.get(SentrySpanAttribute.CUSTOM_SAMPLED)
-        )
-        if custom_sampled is not None:
+        custom_sampled = attributes.get(SentrySpanAttribute.CUSTOM_SAMPLED)
+
+        if custom_sampled is not None and isinstance(custom_sampled, bool):
             if is_root_span:
                 sample_rate = float(custom_sampled)
                 if sample_rate > 0:
@@ -262,7 +275,8 @@ class SentrySampler(Sampler):
                 sample_rate_to_propagate = sample_rate
 
         # If the sample rate is invalid, drop the span
-        if not is_valid_sample_rate(sample_rate, source=self.__class__.__name__):
+        sample_rate = is_valid_sample_rate(sample_rate, source=self.__class__.__name__)
+        if sample_rate is None:
             logger.warning(
                 f"[Tracing.Sampler] Discarding {name} because of invalid sample rate."
             )
@@ -275,7 +289,6 @@ class SentrySampler(Sampler):
                 sample_rate_to_propagate = sample_rate
 
         # Compare sample_rand to sample_rate to make the final sampling decision
-        sample_rate = float(cast("Union[bool, float, int]", sample_rate))
         sampled = sample_rand < Decimal.from_float(sample_rate)
 
         if sampled:
@@ -307,9 +320,13 @@ class SentrySampler(Sampler):
         return self.__class__.__name__
 
 
-def create_sampling_context(name, attributes, parent_span_context, trace_id):
-    # type: (str, Attributes, Optional[SpanContext], int) -> dict[str, Any]
-    sampling_context = {
+def create_sampling_context(
+    name: str,
+    attributes: Attributes,
+    parent_span_context: Optional[SpanContext],
+    trace_id: int,
+) -> dict[str, Any]:
+    sampling_context: dict[str, Any] = {
         "transaction_context": {
             "name": name,
             "op": attributes.get(SentrySpanAttribute.OP) if attributes else None,
@@ -318,7 +335,7 @@ def create_sampling_context(name, attributes, parent_span_context, trace_id):
             ),
         },
         "parent_sampled": get_parent_sampled(parent_span_context, trace_id),
-    }  # type: dict[str, Any]
+    }
 
     if attributes is not None:
         sampling_context.update(attributes)

sentry_sdk/opentelemetry/scope.py

@@ -1,4 +1,4 @@
-from typing import cast
+from __future__ import annotations
 from contextlib import contextmanager
 import warnings
 
@@ -24,9 +24,6 @@ from sentry_sdk.opentelemetry.consts import (
     SENTRY_USE_ISOLATION_SCOPE_KEY,
     TRACESTATE_SAMPLED_KEY,
 )
-from sentry_sdk.opentelemetry.contextvars_context import (
-    SentryContextVarsRuntimeContext,
-)
 from sentry_sdk.opentelemetry.utils import trace_state_from_baggage
 from sentry_sdk.scope import Scope, ScopeType
 from sentry_sdk.tracing import Span
@@ -38,26 +35,21 @@ if TYPE_CHECKING:
 
 class PotelScope(Scope):
     @classmethod
-    def _get_scopes(cls):
-        # type: () -> Optional[Tuple[PotelScope, PotelScope]]
+    def _get_scopes(cls) -> Optional[Tuple[PotelScope, PotelScope]]:
         """
         Returns the current scopes tuple on the otel context. Internal use only.
         """
-        return cast(
-            "Optional[Tuple[PotelScope, PotelScope]]", get_value(SENTRY_SCOPES_KEY)
-        )
+        return validate_scopes(get_value(SENTRY_SCOPES_KEY))
 
     @classmethod
-    def get_current_scope(cls):
-        # type: () -> PotelScope
+    def get_current_scope(cls) -> PotelScope:
         """
         Returns the current scope.
         """
         return cls._get_current_scope() or _INITIAL_CURRENT_SCOPE
 
     @classmethod
-    def _get_current_scope(cls):
-        # type: () -> Optional[PotelScope]
+    def _get_current_scope(cls) -> Optional[PotelScope]:
         """
         Returns the current scope without creating a new one. Internal use only.
         """
@@ -65,16 +57,14 @@ class PotelScope(Scope):
         return scopes[0] if scopes else None
 
     @classmethod
-    def get_isolation_scope(cls):
-        # type: () -> PotelScope
+    def get_isolation_scope(cls) -> PotelScope:
         """
         Returns the isolation scope.
         """
         return cls._get_isolation_scope() or _INITIAL_ISOLATION_SCOPE
 
     @classmethod
-    def _get_isolation_scope(cls):
-        # type: () -> Optional[PotelScope]
+    def _get_isolation_scope(cls) -> Optional[PotelScope]:
         """
         Returns the isolation scope without creating a new one. Internal use only.
         """
@@ -82,8 +72,9 @@ class PotelScope(Scope):
         return scopes[1] if scopes else None
 
     @contextmanager
-    def continue_trace(self, environ_or_headers):
-        # type: (Dict[str, Any]) -> Generator[None, None, None]
+    def continue_trace(
+        self, environ_or_headers: Dict[str, Any]
+    ) -> Generator[None, None, None]:
         """
         Sets the propagation context from environment or headers to continue an incoming trace.
         Any span started within this context manager will use the same trace_id, parent_span_id
@@ -98,8 +89,7 @@ class PotelScope(Scope):
             with use_span(NonRecordingSpan(span_context)):
                 yield
 
-    def _incoming_otel_span_context(self):
-        # type: () -> Optional[SpanContext]
+    def _incoming_otel_span_context(self) -> Optional[SpanContext]:
         if self._propagation_context is None:
             return None
         # If sentry-trace extraction didn't have a parent_span_id, we don't have an upstream header
@@ -132,8 +122,7 @@ class PotelScope(Scope):
 
         return span_context
 
-    def start_transaction(self, **kwargs):
-        # type: (Any) -> Span
+    def start_transaction(self, **kwargs: Any) -> Span:
         """
         .. deprecated:: 3.0.0
             This function is deprecated and will be removed in a future release.
@@ -146,8 +135,7 @@ class PotelScope(Scope):
         )
         return self.start_span(**kwargs)
 
-    def start_span(self, **kwargs):
-        # type: (Any) -> Span
+    def start_span(self, **kwargs: Any) -> Span:
         return Span(**kwargs)
 
 
@@ -155,8 +143,7 @@ _INITIAL_CURRENT_SCOPE = PotelScope(ty=ScopeType.CURRENT)
 _INITIAL_ISOLATION_SCOPE = PotelScope(ty=ScopeType.ISOLATION)
 
 
-def setup_initial_scopes():
-    # type: () -> None
+def setup_initial_scopes() -> None:
     global _INITIAL_CURRENT_SCOPE, _INITIAL_ISOLATION_SCOPE
     _INITIAL_CURRENT_SCOPE = PotelScope(ty=ScopeType.CURRENT)
     _INITIAL_ISOLATION_SCOPE = PotelScope(ty=ScopeType.ISOLATION)
@@ -165,17 +152,18 @@ def setup_initial_scopes():
     attach(set_value(SENTRY_SCOPES_KEY, scopes))
 
 
-def setup_scope_context_management():
-    # type: () -> None
+def setup_scope_context_management() -> None:
     import opentelemetry.context
+    from sentry_sdk.opentelemetry.contextvars_context import (
+        SentryContextVarsRuntimeContext,
+    )
 
     opentelemetry.context._RUNTIME_CONTEXT = SentryContextVarsRuntimeContext()
     setup_initial_scopes()
 
 
 @contextmanager
-def isolation_scope():
-    # type: () -> Generator[PotelScope, None, None]
+def isolation_scope() -> Generator[PotelScope, None, None]:
     context = set_value(SENTRY_FORK_ISOLATION_SCOPE_KEY, True)
     token = attach(context)
     try:
@@ -185,8 +173,7 @@ def isolation_scope():
 
 
 @contextmanager
-def new_scope():
-    # type: () -> Generator[PotelScope, None, None]
+def new_scope() -> Generator[PotelScope, None, None]:
     token = attach(get_current())
     try:
         yield PotelScope.get_current_scope()
@@ -195,8 +182,7 @@ def new_scope():
 
 
 @contextmanager
-def use_scope(scope):
-    # type: (PotelScope) -> Generator[PotelScope, None, None]
+def use_scope(scope: PotelScope) -> Generator[PotelScope, None, None]:
     context = set_value(SENTRY_USE_CURRENT_SCOPE_KEY, scope)
     token = attach(context)
 
@@ -207,8 +193,9 @@ def use_scope(scope):
 
 
 @contextmanager
-def use_isolation_scope(isolation_scope):
-    # type: (PotelScope) -> Generator[PotelScope, None, None]
+def use_isolation_scope(
+    isolation_scope: PotelScope,
+) -> Generator[PotelScope, None, None]:
     context = set_value(SENTRY_USE_ISOLATION_SCOPE_KEY, isolation_scope)
     token = attach(context)
 
@@ -216,3 +203,15 @@ def use_isolation_scope(isolation_scope):
         yield isolation_scope
     finally:
         detach(token)
+
+
+def validate_scopes(scopes: Any) -> Optional[Tuple[PotelScope, PotelScope]]:
+    if (
+        isinstance(scopes, tuple)
+        and len(scopes) == 2
+        and isinstance(scopes[0], PotelScope)
+        and isinstance(scopes[1], PotelScope)
+    ):
+        return scopes
+    else:
+        return None

sentry_sdk/opentelemetry/span_processor.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 from collections import deque, defaultdict
-from typing import cast
 
 from opentelemetry.trace import (
     format_trace_id,
@@ -29,6 +29,7 @@ from sentry_sdk.opentelemetry.utils import (
     get_profile_context,
     get_sentry_meta,
     set_sentry_meta,
+    delete_sentry_meta,
 )
 from sentry_sdk.profiler.continuous_profiler import (
     try_autostart_continuous_profiler,
@@ -36,6 +37,7 @@ from sentry_sdk.profiler.continuous_profiler import (
     try_profile_lifecycle_trace_start,
 )
 from sentry_sdk.profiler.transaction_profiler import Profile
+from sentry_sdk.utils import safe_str
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -51,30 +53,24 @@ class SentrySpanProcessor(SpanProcessor):
     Converts OTel spans into Sentry spans so they can be sent to the Sentry backend.
     """
 
-    def __new__(cls):
-        # type: () -> SentrySpanProcessor
+    def __new__(cls) -> SentrySpanProcessor:
         if not hasattr(cls, "instance"):
             cls.instance = super().__new__(cls)
 
         return cls.instance
 
-    def __init__(self):
-        # type: () -> None
-        self._children_spans = defaultdict(
-            list
-        )  # type: DefaultDict[int, List[ReadableSpan]]
-        self._dropped_spans = defaultdict(lambda: 0)  # type: DefaultDict[int, int]
+    def __init__(self) -> None:
+        self._children_spans: DefaultDict[int, List[ReadableSpan]] = defaultdict(list)
+        self._dropped_spans: DefaultDict[int, int] = defaultdict(lambda: 0)
 
-    def on_start(self, span, parent_context=None):
-        # type: (Span, Optional[Context]) -> None
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
         if is_sentry_span(span):
             return
 
         self._add_root_span(span, get_current_span(parent_context))
         self._start_profile(span)
 
-    def on_end(self, span):
-        # type: (ReadableSpan) -> None
+    def on_end(self, span: ReadableSpan) -> None:
         if is_sentry_span(span):
             return
 
@@ -87,18 +83,15 @@ class SentrySpanProcessor(SpanProcessor):
             self._append_child_span(span)
 
     # TODO-neel-potel not sure we need a clear like JS
-    def shutdown(self):
-        # type: () -> None
+    def shutdown(self) -> None:
         pass
 
     # TODO-neel-potel change default? this is 30 sec
     # TODO-neel-potel call this in client.flush
-    def force_flush(self, timeout_millis=30000):
-        # type: (int) -> bool
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
         return True
 
-    def _add_root_span(self, span, parent_span):
-        # type: (Span, AbstractSpan) -> None
+    def _add_root_span(self, span: Span, parent_span: AbstractSpan) -> None:
         """
         This is required to make Span.root_span work
         since we can't traverse back to the root purely with otel efficiently.
@@ -111,8 +104,7 @@ class SentrySpanProcessor(SpanProcessor):
             # root span points to itself
             set_sentry_meta(span, "root_span", span)
 
-    def _start_profile(self, span):
-        # type: (Span) -> None
+    def _start_profile(self, span: Span) -> None:
         try_autostart_continuous_profiler()
 
         profiler_id = get_profiler_id()
@@ -147,14 +139,12 @@ class SentrySpanProcessor(SpanProcessor):
                 span.set_attribute(SPANDATA.PROFILER_ID, profiler_id)
             set_sentry_meta(span, "continuous_profile", continuous_profile)
 
-    def _stop_profile(self, span):
-        # type: (ReadableSpan) -> None
+    def _stop_profile(self, span: ReadableSpan) -> None:
         continuous_profiler = get_sentry_meta(span, "continuous_profile")
         if continuous_profiler:
             continuous_profiler.stop()
 
-    def _flush_root_span(self, span):
-        # type: (ReadableSpan) -> None
+    def _flush_root_span(self, span: ReadableSpan) -> None:
         transaction_event = self._root_span_to_transaction_event(span)
         if not transaction_event:
             return
@@ -173,9 +163,9 @@ class SentrySpanProcessor(SpanProcessor):
         # TODO-neel-potel sort and cutoff max spans
 
         sentry_sdk.capture_event(transaction_event)
+        self._cleanup_references([span] + collected_spans)
 
-    def _append_child_span(self, span):
-        # type: (ReadableSpan) -> None
+    def _append_child_span(self, span: ReadableSpan) -> None:
         if not span.parent:
             return
 
@@ -190,14 +180,13 @@ class SentrySpanProcessor(SpanProcessor):
         else:
             self._dropped_spans[span.parent.span_id] += 1
 
-    def _collect_children(self, span):
-        # type: (ReadableSpan) -> tuple[List[ReadableSpan], int]
+    def _collect_children(self, span: ReadableSpan) -> tuple[List[ReadableSpan], int]:
         if not span.context:
             return [], 0
 
         children = []
         dropped_spans = 0
-        bfs_queue = deque()  # type: Deque[int]
+        bfs_queue: Deque[int] = deque()
         bfs_queue.append(span.context.span_id)
 
         while bfs_queue:
@@ -213,8 +202,7 @@ class SentrySpanProcessor(SpanProcessor):
 
     # we construct the event from scratch here
     # and not use the current Transaction class for easier refactoring
-    def _root_span_to_transaction_event(self, span):
-        # type: (ReadableSpan) -> Optional[Event]
+    def _root_span_to_transaction_event(self, span: ReadableSpan) -> Optional[Event]:
         if not span.context:
             return None
 
@@ -231,10 +219,8 @@ class SentrySpanProcessor(SpanProcessor):
         if profile_context:
             contexts["profile"] = profile_context
 
-        (_, description, _, http_status, _) = span_data
-
-        if http_status:
-            contexts["response"] = {"status_code": http_status}
+        if span_data.http_status:
+            contexts["response"] = {"status_code": span_data.http_status}
 
         if span.resource.attributes:
             contexts[OTEL_SENTRY_CONTEXT] = {"resource": dict(span.resource.attributes)}
@@ -242,30 +228,26 @@ class SentrySpanProcessor(SpanProcessor):
         event.update(
             {
                 "type": "transaction",
-                "transaction": transaction_name or description,
+                "transaction": transaction_name or span_data.description,
                 "transaction_info": {"source": transaction_source or "custom"},
                 "contexts": contexts,
             }
         )
 
-        profile = cast("Optional[Profile]", get_sentry_meta(span, "profile"))
-        if profile:
+        profile = get_sentry_meta(span, "profile")
+        if profile is not None and isinstance(profile, Profile):
             profile.__exit__(None, None, None)
             if profile.valid():
                 event["profile"] = profile
-                set_sentry_meta(span, "profile", None)
 
         return event
 
-    def _span_to_json(self, span):
-        # type: (ReadableSpan) -> Optional[dict[str, Any]]
+    def _span_to_json(self, span: ReadableSpan) -> Optional[dict[str, Any]]:
         if not span.context:
             return None
 
-        # This is a safe cast because dict[str, Any] is a superset of Event
-        span_json = cast(
-            "dict[str, Any]", self._common_span_transaction_attributes_as_json(span)
-        )
+        # need to ignore the type here due to TypedDict nonsense
+        span_json: Optional[dict[str, Any]] = self._common_span_transaction_attributes_as_json(span)  # type: ignore
         if span_json is None:
             return None
 
@@ -273,19 +255,21 @@ class SentrySpanProcessor(SpanProcessor):
         span_id = format_span_id(span.context.span_id)
         parent_span_id = format_span_id(span.parent.span_id) if span.parent else None
 
-        (op, description, status, _, origin) = extract_span_data(span)
+        span_data = extract_span_data(span)
 
         span_json.update(
             {
                 "trace_id": trace_id,
                 "span_id": span_id,
-                "op": op,
-                "description": description,
-                "status": status,
-                "origin": origin or DEFAULT_SPAN_ORIGIN,
+                "description": span_data.description,
+                "origin": span_data.origin or DEFAULT_SPAN_ORIGIN,
             }
         )
 
+        if span_data.op:
+            span_json["op"] = span_data.op
+        if span_data.status:
+            span_json["status"] = span_data.status
         if parent_span_id:
             span_json["parent_span_id"] = parent_span_id
 
@@ -298,24 +282,30 @@ class SentrySpanProcessor(SpanProcessor):
 
         return span_json
 
-    def _common_span_transaction_attributes_as_json(self, span):
-        # type: (ReadableSpan) -> Optional[Event]
+    def _common_span_transaction_attributes_as_json(
+        self, span: ReadableSpan
+    ) -> Optional[Event]:
         if not span.start_time or not span.end_time:
             return None
 
-        common_json = {
+        common_json: Event = {
             "start_timestamp": convert_from_otel_timestamp(span.start_time),
             "timestamp": convert_from_otel_timestamp(span.end_time),
-        }  # type: Event
+        }
 
         tags = extract_span_attributes(span, SentrySpanAttribute.TAG)
         if tags:
-            common_json["tags"] = tags
+            common_json["tags"] = {
+                tag: safe_str(tag_value) for tag, tag_value in tags.items()
+            }
 
         return common_json
 
-    def _log_debug_info(self):
-        # type: () -> None
+    def _cleanup_references(self, spans: List[ReadableSpan]) -> None:
+        for span in spans:
+            delete_sentry_meta(span)
+
+    def _log_debug_info(self) -> None:
         import pprint
 
         pprint.pprint(