sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/opentelemetry/scope.py

@@ -0,0 +1,218 @@
+from typing import cast
+from contextlib import contextmanager
+import warnings
+
+from opentelemetry.context import (
+    get_value,
+    set_value,
+    attach,
+    detach,
+    get_current,
+)
+from opentelemetry.trace import (
+    SpanContext,
+    NonRecordingSpan,
+    TraceFlags,
+    TraceState,
+    use_span,
+)
+
+from sentry_sdk.opentelemetry.consts import (
+    SENTRY_SCOPES_KEY,
+    SENTRY_FORK_ISOLATION_SCOPE_KEY,
+    SENTRY_USE_CURRENT_SCOPE_KEY,
+    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
+from sentry_sdk._types import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Tuple, Optional, Generator, Dict, Any
+
+
+class PotelScope(Scope):
+    @classmethod
+    def _get_scopes(cls):
+        # type: () -> 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)
+        )
+
+    @classmethod
+    def get_current_scope(cls):
+        # type: () -> PotelScope
+        """
+        Returns the current scope.
+        """
+        return cls._get_current_scope() or _INITIAL_CURRENT_SCOPE
+
+    @classmethod
+    def _get_current_scope(cls):
+        # type: () -> Optional[PotelScope]
+        """
+        Returns the current scope without creating a new one. Internal use only.
+        """
+        scopes = cls._get_scopes()
+        return scopes[0] if scopes else None
+
+    @classmethod
+    def get_isolation_scope(cls):
+        # type: () -> PotelScope
+        """
+        Returns the isolation scope.
+        """
+        return cls._get_isolation_scope() or _INITIAL_ISOLATION_SCOPE
+
+    @classmethod
+    def _get_isolation_scope(cls):
+        # type: () -> Optional[PotelScope]
+        """
+        Returns the isolation scope without creating a new one. Internal use only.
+        """
+        scopes = cls._get_scopes()
+        return scopes[1] if scopes else None
+
+    @contextmanager
+    def continue_trace(self, environ_or_headers):
+        # type: (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
+        and inherit the sampling decision from the incoming trace.
+        """
+        self.generate_propagation_context(environ_or_headers)
+
+        span_context = self._incoming_otel_span_context()
+        if span_context is None:
+            yield
+        else:
+            with use_span(NonRecordingSpan(span_context)):
+                yield
+
+    def _incoming_otel_span_context(self):
+        # type: () -> 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
+        if self._propagation_context.parent_span_id is None:
+            return None
+
+        trace_flags = TraceFlags(
+            TraceFlags.SAMPLED
+            if self._propagation_context.parent_sampled
+            else TraceFlags.DEFAULT
+        )
+
+        if self._propagation_context.baggage:
+            trace_state = trace_state_from_baggage(self._propagation_context.baggage)
+        else:
+            trace_state = TraceState()
+
+        # for twp to work, we also need to consider deferred sampling when the sampling
+        # flag is not present, so the above TraceFlags are not sufficient
+        if self._propagation_context.parent_sampled is None:
+            trace_state = trace_state.update(TRACESTATE_SAMPLED_KEY, "deferred")
+
+        span_context = SpanContext(
+            trace_id=int(self._propagation_context.trace_id, 16),
+            span_id=int(self._propagation_context.parent_span_id, 16),
+            is_remote=True,
+            trace_flags=trace_flags,
+            trace_state=trace_state,
+        )
+
+        return span_context
+
+    def start_transaction(self, **kwargs):
+        # type: (Any) -> Span
+        """
+        .. deprecated:: 3.0.0
+            This function is deprecated and will be removed in a future release.
+            Use :py:meth:`sentry_sdk.start_span` instead.
+        """
+        warnings.warn(
+            "The `start_transaction` method is deprecated, please use `sentry_sdk.start_span instead.`",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.start_span(**kwargs)
+
+    def start_span(self, **kwargs):
+        # type: (Any) -> Span
+        return Span(**kwargs)
+
+
+_INITIAL_CURRENT_SCOPE = PotelScope(ty=ScopeType.CURRENT)
+_INITIAL_ISOLATION_SCOPE = PotelScope(ty=ScopeType.ISOLATION)
+
+
+def setup_initial_scopes():
+    # type: () -> None
+    global _INITIAL_CURRENT_SCOPE, _INITIAL_ISOLATION_SCOPE
+    _INITIAL_CURRENT_SCOPE = PotelScope(ty=ScopeType.CURRENT)
+    _INITIAL_ISOLATION_SCOPE = PotelScope(ty=ScopeType.ISOLATION)
+
+    scopes = (_INITIAL_CURRENT_SCOPE, _INITIAL_ISOLATION_SCOPE)
+    attach(set_value(SENTRY_SCOPES_KEY, scopes))
+
+
+def setup_scope_context_management():
+    # type: () -> None
+    import opentelemetry.context
+
+    opentelemetry.context._RUNTIME_CONTEXT = SentryContextVarsRuntimeContext()
+    setup_initial_scopes()
+
+
+@contextmanager
+def isolation_scope():
+    # type: () -> Generator[PotelScope, None, None]
+    context = set_value(SENTRY_FORK_ISOLATION_SCOPE_KEY, True)
+    token = attach(context)
+    try:
+        yield PotelScope.get_isolation_scope()
+    finally:
+        detach(token)
+
+
+@contextmanager
+def new_scope():
+    # type: () -> Generator[PotelScope, None, None]
+    token = attach(get_current())
+    try:
+        yield PotelScope.get_current_scope()
+    finally:
+        detach(token)
+
+
+@contextmanager
+def use_scope(scope):
+    # type: (PotelScope) -> Generator[PotelScope, None, None]
+    context = set_value(SENTRY_USE_CURRENT_SCOPE_KEY, scope)
+    token = attach(context)
+
+    try:
+        yield scope
+    finally:
+        detach(token)
+
+
+@contextmanager
+def use_isolation_scope(isolation_scope):
+    # type: (PotelScope) -> Generator[PotelScope, None, None]
+    context = set_value(SENTRY_USE_ISOLATION_SCOPE_KEY, isolation_scope)
+    token = attach(context)
+
+    try:
+        yield isolation_scope
+    finally:
+        detach(token)

sentry_sdk/opentelemetry/span_processor.py

@@ -0,0 +1,335 @@
+from collections import deque, defaultdict
+from typing import cast
+
+from opentelemetry.trace import (
+    format_trace_id,
+    format_span_id,
+    get_current_span,
+    INVALID_SPAN,
+    Span as AbstractSpan,
+)
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import Span, ReadableSpan, SpanProcessor
+
+import sentry_sdk
+from sentry_sdk.consts import SPANDATA, DEFAULT_SPAN_ORIGIN
+from sentry_sdk.utils import get_current_thread_meta
+from sentry_sdk.opentelemetry.consts import (
+    OTEL_SENTRY_CONTEXT,
+    SentrySpanAttribute,
+)
+from sentry_sdk.opentelemetry.sampler import create_sampling_context
+from sentry_sdk.opentelemetry.utils import (
+    is_sentry_span,
+    convert_from_otel_timestamp,
+    extract_span_attributes,
+    extract_span_data,
+    extract_transaction_name_source,
+    get_trace_context,
+    get_profile_context,
+    get_sentry_meta,
+    set_sentry_meta,
+    delete_sentry_meta,
+)
+from sentry_sdk.profiler.continuous_profiler import (
+    try_autostart_continuous_profiler,
+    get_profiler_id,
+    try_profile_lifecycle_trace_start,
+)
+from sentry_sdk.profiler.transaction_profiler import Profile
+from sentry_sdk._types import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Optional, List, Any, Deque, DefaultDict
+    from sentry_sdk._types import Event
+
+
+DEFAULT_MAX_SPANS = 1000
+
+
+class SentrySpanProcessor(SpanProcessor):
+    """
+    Converts OTel spans into Sentry spans so they can be sent to the Sentry backend.
+    """
+
+    def __new__(cls):
+        # type: () -> 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 on_start(self, span, parent_context=None):
+        # type: (Span, Optional[Context]) -> 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
+        if is_sentry_span(span):
+            return
+
+        is_root_span = not span.parent or span.parent.is_remote
+        if is_root_span:
+            # if have a root span ending, stop the profiler, build a transaction and send it
+            self._stop_profile(span)
+            self._flush_root_span(span)
+        else:
+            self._append_child_span(span)
+
+    # TODO-neel-potel not sure we need a clear like JS
+    def shutdown(self):
+        # type: () -> 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
+        return True
+
+    def _add_root_span(self, span, parent_span):
+        # type: (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.
+        """
+        if parent_span != INVALID_SPAN and not parent_span.get_span_context().is_remote:
+            # child span points to parent's root or parent
+            parent_root_span = get_sentry_meta(parent_span, "root_span")
+            set_sentry_meta(span, "root_span", parent_root_span or parent_span)
+        else:
+            # root span points to itself
+            set_sentry_meta(span, "root_span", span)
+
+    def _start_profile(self, span):
+        # type: (Span) -> None
+        try_autostart_continuous_profiler()
+
+        profiler_id = get_profiler_id()
+        thread_id, thread_name = get_current_thread_meta()
+
+        if profiler_id:
+            span.set_attribute(SPANDATA.PROFILER_ID, profiler_id)
+        if thread_id:
+            span.set_attribute(SPANDATA.THREAD_ID, str(thread_id))
+        if thread_name:
+            span.set_attribute(SPANDATA.THREAD_NAME, thread_name)
+
+        is_root_span = not span.parent or span.parent.is_remote
+        sampled = span.context and span.context.trace_flags.sampled
+
+        if is_root_span and sampled:
+            # profiler uses time.perf_counter_ns() so we cannot use the
+            # unix timestamp that is on span.start_time
+            # setting it to 0 means the profiler will internally measure time on start
+            profile = Profile(sampled, 0)
+
+            sampling_context = create_sampling_context(
+                span.name, span.attributes, span.parent, span.context.trace_id
+            )
+            profile._set_initial_sampling_decision(sampling_context)
+            profile.__enter__()
+            set_sentry_meta(span, "profile", profile)
+
+            continuous_profile = try_profile_lifecycle_trace_start()
+            profiler_id = get_profiler_id()
+            if profiler_id:
+                span.set_attribute(SPANDATA.PROFILER_ID, profiler_id)
+            set_sentry_meta(span, "continuous_profile", continuous_profile)
+
+    def _stop_profile(self, span):
+        # type: (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
+        transaction_event = self._root_span_to_transaction_event(span)
+        if not transaction_event:
+            return
+
+        collected_spans, dropped_spans = self._collect_children(span)
+        spans = []
+        for child in collected_spans:
+            span_json = self._span_to_json(child)
+            if span_json:
+                spans.append(span_json)
+
+        transaction_event["spans"] = spans
+        if dropped_spans > 0:
+            transaction_event["_dropped_spans"] = dropped_spans
+
+        # 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
+        if not span.parent:
+            return
+
+        max_spans = (
+            sentry_sdk.get_client().options["_experiments"].get("max_spans")
+            or DEFAULT_MAX_SPANS
+        )
+
+        children_spans = self._children_spans[span.parent.span_id]
+        if len(children_spans) < max_spans:
+            children_spans.append(span)
+        else:
+            self._dropped_spans[span.parent.span_id] += 1
+
+    def _collect_children(self, span):
+        # type: (ReadableSpan) -> tuple[List[ReadableSpan], int]
+        if not span.context:
+            return [], 0
+
+        children = []
+        dropped_spans = 0
+        bfs_queue = deque()  # type: Deque[int]
+        bfs_queue.append(span.context.span_id)
+
+        while bfs_queue:
+            parent_span_id = bfs_queue.popleft()
+            node_children = self._children_spans.pop(parent_span_id, [])
+            dropped_spans += self._dropped_spans.pop(parent_span_id, 0)
+            children.extend(node_children)
+            bfs_queue.extend(
+                [child.context.span_id for child in node_children if child.context]
+            )
+
+        return children, dropped_spans
+
+    # 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]
+        if not span.context:
+            return None
+
+        event = self._common_span_transaction_attributes_as_json(span)
+        if event is None:
+            return None
+
+        transaction_name, transaction_source = extract_transaction_name_source(span)
+        span_data = extract_span_data(span)
+        trace_context = get_trace_context(span, span_data=span_data)
+        contexts = {"trace": trace_context}
+
+        profile_context = get_profile_context(span)
+        if profile_context:
+            contexts["profile"] = profile_context
+
+        (_, description, _, http_status, _) = span_data
+
+        if http_status:
+            contexts["response"] = {"status_code": http_status}
+
+        if span.resource.attributes:
+            contexts[OTEL_SENTRY_CONTEXT] = {"resource": dict(span.resource.attributes)}
+
+        event.update(
+            {
+                "type": "transaction",
+                "transaction": transaction_name or description,
+                "transaction_info": {"source": transaction_source or "custom"},
+                "contexts": contexts,
+            }
+        )
+
+        profile = cast("Optional[Profile]", get_sentry_meta(span, "profile"))
+        if profile:
+            profile.__exit__(None, None, None)
+            if profile.valid():
+                event["profile"] = profile
+
+        return event
+
+    def _span_to_json(self, span):
+        # type: (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)
+        )
+        if span_json is None:
+            return None
+
+        trace_id = format_trace_id(span.context.trace_id)
+        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_json.update(
+            {
+                "trace_id": trace_id,
+                "span_id": span_id,
+                "op": op,
+                "description": description,
+                "status": status,
+                "origin": origin or DEFAULT_SPAN_ORIGIN,
+            }
+        )
+
+        if parent_span_id:
+            span_json["parent_span_id"] = parent_span_id
+
+        attributes = getattr(span, "attributes", {}) or {}
+        if attributes:
+            span_json["data"] = {}
+            for key, value in attributes.items():
+                if not key.startswith("_"):
+                    span_json["data"][key] = value
+
+        return span_json
+
+    def _common_span_transaction_attributes_as_json(self, span):
+        # type: (ReadableSpan) -> Optional[Event]
+        if not span.start_time or not span.end_time:
+            return None
+
+        common_json = {
+            "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
+
+        return common_json
+
+    def _cleanup_references(self, spans):
+        # type: (List[ReadableSpan]) -> None
+        for span in spans:
+            delete_sentry_meta(span)
+
+    def _log_debug_info(self):
+        # type: () -> None
+        import pprint
+
+        pprint.pprint(
+            {
+                format_span_id(span_id): [
+                    (format_span_id(child.context.span_id), child.name)
+                    for child in children
+                ]
+                for span_id, children in self._children_spans.items()
+            }
+        )

sentry_sdk/opentelemetry/tracing.py

@@ -0,0 +1,59 @@
+from opentelemetry import trace
+from opentelemetry.propagate import set_global_textmap
+from opentelemetry.sdk.trace import TracerProvider, Span, ReadableSpan
+
+from sentry_sdk.opentelemetry import (
+    SentryPropagator,
+    SentrySampler,
+    SentrySpanProcessor,
+)
+from sentry_sdk.utils import logger
+
+
+def patch_readable_span():
+    # type: () -> None
+    """
+    We need to pass through sentry specific metadata/objects from Span to ReadableSpan
+    to work with them consistently in the SpanProcessor.
+    """
+    old_readable_span = Span._readable_span
+
+    def sentry_patched_readable_span(self):
+        # type: (Span) -> ReadableSpan
+        readable_span = old_readable_span(self)
+        readable_span._sentry_meta = getattr(self, "_sentry_meta", {})  # type: ignore[attr-defined]
+        return readable_span
+
+    Span._readable_span = sentry_patched_readable_span  # type: ignore[method-assign]
+
+
+def setup_sentry_tracing():
+    # type: () -> None
+    # TracerProvider can only be set once. If we're the first ones setting it,
+    # there's no issue. If it already exists, we need to patch it.
+    from opentelemetry.trace import _TRACER_PROVIDER
+
+    if _TRACER_PROVIDER is not None:
+        logger.debug("[Tracing] Detected an existing TracerProvider, patching")
+        tracer_provider = _TRACER_PROVIDER
+        tracer_provider.sampler = SentrySampler()  # type: ignore[attr-defined]
+
+    else:
+        logger.debug("[Tracing] No TracerProvider set, creating a new one")
+        tracer_provider = TracerProvider(sampler=SentrySampler())
+        trace.set_tracer_provider(tracer_provider)
+
+    try:
+        existing_span_processors = (
+            tracer_provider._active_span_processor._span_processors  # type: ignore[attr-defined]
+        )
+    except Exception:
+        existing_span_processors = []
+
+    for span_processor in existing_span_processors:
+        if isinstance(span_processor, SentrySpanProcessor):
+            break
+    else:
+        tracer_provider.add_span_processor(SentrySpanProcessor())  # type: ignore[attr-defined]
+
+    set_global_textmap(SentryPropagator())