Cleanup scopes wip

Author: sl0thentr0py

sentry_sdk/integrations/opentelemetry/scope.py

@@ -29,6 +29,7 @@
 from sentry_sdk.integrations.opentelemetry.utils import trace_state_from_baggage
 from sentry_sdk.scope import Scope, ScopeType
 from sentry_sdk.tracing import Span
+from sentry_sdk.utils import logger
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -41,23 +42,25 @@
 class PotelScope(Scope):
     @classmethod
     def _get_scopes(cls):
-        # type: () -> Optional[Tuple[Scope, Scope]]
+        # type: () -> Optional[Tuple[PotelScope, PotelScope]]
         """
         Returns the current scopes tuple on the otel context. Internal use only.
         """
-        return cast("Optional[Tuple[Scope, Scope]]", get_value(SENTRY_SCOPES_KEY))
+        return cast(
+            "Optional[Tuple[PotelScope, PotelScope]]", get_value(SENTRY_SCOPES_KEY)
+        )
 
     @classmethod
     def get_current_scope(cls):
-        # type: () -> Scope
+        # type: () -> PotelScope
         """
         Returns the current scope.
         """
         return cls._get_current_scope() or _INITIAL_CURRENT_SCOPE
 
     @classmethod
     def _get_current_scope(cls):
-        # type: () -> Optional[Scope]
+        # type: () -> Optional[PotelScope]
         """
         Returns the current scope without creating a new one. Internal use only.
         """
@@ -66,15 +69,15 @@ def _get_current_scope(cls):
 
     @classmethod
     def get_isolation_scope(cls):
-        # type: () -> Scope
+        # type: () -> PotelScope
         """
         Returns the isolation scope.
         """
         return cls._get_isolation_scope() or _INITIAL_ISOLATION_SCOPE
 
     @classmethod
     def _get_isolation_scope(cls):
-        # type: () -> Optional[Scope]
+        # type: () -> Optional[PotelScope]
         """
         Returns the isolation scope without creating a new one. Internal use only.
         """
@@ -84,6 +87,11 @@ def _get_isolation_scope(cls):
     @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()
@@ -134,15 +142,18 @@ def start_transaction(self, **kwargs):
             This function is deprecated and will be removed in a future release.
             Use :py:meth:`sentry_sdk.start_span` instead.
         """
+        logger.warning(
+            "The `start_transaction` method is deprecated, please use `sentry_sdk.start_span instead.`"
+        )
         return self.start_span(**kwargs)
 
     def start_span(self, **kwargs):
         # type: (Any) -> Span
-        return Span(**kwargs, scope=self)
+        return Span(**kwargs)
 
 
-_INITIAL_CURRENT_SCOPE = None
-_INITIAL_ISOLATION_SCOPE = None
+_INITIAL_CURRENT_SCOPE = PotelScope(ty=ScopeType.CURRENT)
+_INITIAL_ISOLATION_SCOPE = PotelScope(ty=ScopeType.ISOLATION)
 
 
 def setup_initial_scopes():

sentry_sdk/scope.py

@@ -12,13 +12,11 @@
 from sentry_sdk.attachments import Attachment
 from sentry_sdk.consts import DEFAULT_MAX_BREADCRUMBS, FALSE_VALUES
 from sentry_sdk.feature_flags import FlagBuffer, DEFAULT_FLAG_CAPACITY
-from sentry_sdk.profiler.continuous_profiler import try_autostart_continuous_profiler
 from sentry_sdk.profiler.transaction_profiler import Profile
 from sentry_sdk.session import Session
 from sentry_sdk.tracing_utils import (
     Baggage,
     has_tracing_enabled,
-    normalize_incoming_data,
     PropagationContext,
 )
 from sentry_sdk.tracing import (
@@ -67,7 +65,6 @@
         ExcInfo,
         Hint,
         LogLevelStr,
-        SamplingContext,
         Type,
     )
 
@@ -949,71 +946,20 @@ def add_breadcrumb(self, crumb=None, hint=None, **kwargs):
         while len(self._breadcrumbs) > max_breadcrumbs:
             self._breadcrumbs.popleft()
 
-    def start_transaction(self, transaction=None, **kwargs):
-        # type: (Optional[Span], Optional[SamplingContext], Unpack[TransactionKwargs]) -> Union[Span, NoOpSpan]
+    def start_transaction(self, **kwargs):
+        # type: (Unpack[TransactionKwargs]) -> Union[NoOpSpan, Span]
         """
-        Start and return a transaction.
-
-        Start an existing transaction if given, otherwise create and start a new
-        transaction with kwargs.
-
-        This is the entry point to manual tracing instrumentation.
-
-        A tree structure can be built by adding child spans to the transaction,
-        and child spans to other spans. To start a new child span within the
-        transaction or any span, call the respective `.start_child()` method.
-
-        Every child span must be finished before the transaction is finished,
-        otherwise the unfinished spans are discarded.
-
-        When used as context managers, spans and transactions are automatically
-        finished at the end of the `with` block. If not using context managers,
-        call the `.finish()` method.
-
-        When the transaction is finished, it will be sent to Sentry with all its
-        finished child spans.
-
-        :param transaction: The transaction to start. If omitted, we create and
-            start a new transaction.
-        :param kwargs: Optional keyword arguments to be passed to the Transaction
-            constructor. See :py:class:`sentry_sdk.tracing.Transaction` for
-            available arguments.
+        .. deprecated:: 3.0.0
+            This function is deprecated and will be removed in a future release.
+            Use :py:meth:`sentry_sdk.start_span` instead.
         """
-        # TODO-neel-potel fix signature and no op
-        kwargs.setdefault("scope", self)
-
-        client = self.get_client()
-
-        try_autostart_continuous_profiler()
-
-        # if we haven't been given a transaction, make one
-        transaction = Span(**kwargs)
-
-        # use traces_sample_rate, traces_sampler, and/or inheritance to make a
-        # sampling decision
-        sampling_context = {
-            "transaction_context": transaction.to_json(),
-            "parent_sampled": transaction.parent_sampled,
-        }
-        transaction._set_initial_sampling_decision(sampling_context=sampling_context)
-
-        if transaction.sampled:
-            profile = Profile(
-                transaction.sampled, transaction._start_timestamp_monotonic_ns
-            )
-            profile._set_initial_sampling_decision(sampling_context=sampling_context)
-
-            transaction._profile = profile
-
-            # we don't bother to keep spans if we already know we're not going to
-            # send the transaction
-            max_spans = (client.options["_experiments"].get("max_spans")) or 1000
-            transaction.init_span_recorder(maxlen=max_spans)
-
-        return transaction
+        logger.warning(
+            "The `start_transaction` method is deprecated, please use `sentry_sdk.start_span instead.`"
+        )
+        return NoOpSpan(**kwargs)
 
     def start_span(self, **kwargs):
-        # type: (Optional[Span], Any) -> Span
+        # type: (Optional[Span], Any) -> Union[NoOpSpan, Span]
         """
         Start a span whose parent is the currently active span, if any.
 
@@ -1023,53 +969,16 @@ def start_span(self, **kwargs):
 
         For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Span`.
         """
-        # TODO-neel-potel fix signature and no op
-        if kwargs.get("description") is not None:
-            warnings.warn(
-                "The `description` parameter is deprecated. Please use `name` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-        with new_scope():
-            kwargs.setdefault("scope", self)
-
-            # get current span or transaction
-            span = self.span or self.get_isolation_scope().span
+        return NoOpSpan(**kwargs)
 
-            if span is None:
-                # New spans get the `trace_id` from the scope
-                if "trace_id" not in kwargs:
-                    propagation_context = self.get_active_propagation_context()
-                    if propagation_context is not None:
-                        kwargs["trace_id"] = propagation_context.trace_id
-
-                span = Span(**kwargs)
-            else:
-                # Children take `trace_id`` from the parent span.
-                span = span.start_child(**kwargs)
-
-            return span
-
-    def continue_trace(
-        self, environ_or_headers, op=None, name=None, source=None, origin=None
-    ):
-        # TODO-neel-potel fix signature and no op
-        # type: (Dict[str, Any], Optional[str], Optional[str], Optional[str], Optional[str]) -> Span
+    @contextmanager
+    def continue_trace(self, environ_or_headers):
+        # type: (Dict[str, Any]) -> Generator[None, None, None]
         """
-        Sets the propagation context from environment or headers and returns a transaction.
+        Sets the propagation context from environment or headers to continue an incoming trace.
         """
         self.generate_propagation_context(environ_or_headers)
-
-        transaction = Span.continue_from_headers(
-            normalize_incoming_data(environ_or_headers),
-            op=op,
-            origin=origin,
-            name=name,
-            source=source,
-        )
-
-        return transaction
+        yield
 
     def capture_event(self, event, hint=None, scope=None, **scope_kwargs):
         # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]

sentry_sdk/tracing.py

@@ -200,6 +200,9 @@ def get_span_status_from_http_code(http_status_code):
 
 
 class NoOpSpan:
+    def __init__(self, **kwargs):
+        pass
+
     def __repr__(self):
         # type: () -> str
         return "<%s>" % self.__class__.__name__
@@ -263,7 +266,6 @@ def get_profile_context(self):
 
     def finish(
         self,
-        scope=None,  # type: Optional[sentry_sdk.Scope]
         end_timestamp=None,  # type: Optional[Union[float, datetime]]
     ):
         # type: (...) -> None