sentry-sdk 0.7.5__py2.py3-none-any.whl → 2.46.0__py2.py3-none-any.whl

sentry_sdk/hub.py

@@ -1,151 +1,125 @@
-import sys
-import copy
-import weakref
-from datetime import datetime
+import warnings
 from contextlib import contextmanager
-from warnings import warn
 
+from sentry_sdk import (
+    get_client,
+    get_global_scope,
+    get_isolation_scope,
+    get_current_scope,
+)
 from sentry_sdk._compat import with_metaclass
-from sentry_sdk.scope import Scope
+from sentry_sdk.consts import INSTRUMENTER
+from sentry_sdk.scope import _ScopeManager
 from sentry_sdk.client import Client
+from sentry_sdk.tracing import (
+    NoOpSpan,
+    Span,
+    Transaction,
+)
+
 from sentry_sdk.utils import (
-    exc_info_from_error,
-    event_from_exception,
     logger,
     ContextVar,
 )
 
+from typing import TYPE_CHECKING
 
-if False:
-    from typing import Union
+if TYPE_CHECKING:
     from typing import Any
-    from typing import Optional
+    from typing import Callable
+    from typing import ContextManager
     from typing import Dict
-    from typing import Tuple
+    from typing import Generator
     from typing import List
-    from typing import Callable
+    from typing import Optional
     from typing import overload
-    from contextlib import ContextManager
+    from typing import Tuple
+    from typing import Type
+    from typing import TypeVar
+    from typing import Union
+
+    from typing_extensions import Unpack
+
+    from sentry_sdk.scope import Scope
+    from sentry_sdk.client import BaseClient
     from sentry_sdk.integrations import Integration
+    from sentry_sdk._types import (
+        Event,
+        Hint,
+        Breadcrumb,
+        BreadcrumbHint,
+        ExcInfo,
+        LogLevelStr,
+        SamplingContext,
+    )
+    from sentry_sdk.tracing import TransactionKwargs
+
+    T = TypeVar("T")
+
 else:
 
     def overload(x):
+        # type: (T) -> T
         return x
 
 
-_local = ContextVar("sentry_current_hub")
-_initial_client = None
-
-
-def _should_send_default_pii():
-    # type: () -> bool
-    client = Hub.current.client
-    if not client:
-        return False
-    return client.options["send_default_pii"]
-
+class SentryHubDeprecationWarning(DeprecationWarning):
+    """
+    A custom deprecation warning to inform users that the Hub is deprecated.
+    """
 
-class _InitGuard(object):
-    def __init__(self, client):
-        self._client = client
+    _MESSAGE = (
+        "`sentry_sdk.Hub` is deprecated and will be removed in a future major release. "
+        "Please consult our 1.x to 2.x migration guide for details on how to migrate "
+        "`Hub` usage to the new API: "
+        "https://docs.sentry.io/platforms/python/migration/1.x-to-2.x"
+    )
 
-    def __enter__(self):
-        return self
+    def __init__(self, *_):
+        # type: (*object) -> None
+        super().__init__(self._MESSAGE)
 
-    def __exit__(self, exc_type, exc_value, tb):
-        c = self._client
-        if c is not None:
-            c.close()
 
+@contextmanager
+def _suppress_hub_deprecation_warning():
+    # type: () -> Generator[None, None, None]
+    """Utility function to suppress deprecation warnings for the Hub."""
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=SentryHubDeprecationWarning)
+        yield
 
-def init(*args, **kwargs):
-    """Initializes the SDK and optionally integrations.
 
-    This takes the same arguments as the client constructor.
-    """
-    global _initial_client
-    client = Client(*args, **kwargs)
-    Hub.current.bind_client(client)
-    rv = _InitGuard(client)
-    if client is not None:
-        _initial_client = weakref.ref(client)
-    return rv
+_local = ContextVar("sentry_current_hub")
 
 
 class HubMeta(type):
     @property
-    def current(self):
+    def current(cls):
         # type: () -> Hub
         """Returns the current instance of the hub."""
+        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
         rv = _local.get(None)
         if rv is None:
-            rv = Hub(GLOBAL_HUB)
+            with _suppress_hub_deprecation_warning():
+                # This will raise a deprecation warning; suppress it since we already warned above.
+                rv = Hub(GLOBAL_HUB)
             _local.set(rv)
         return rv
 
     @property
-    def main(self):
+    def main(cls):
+        # type: () -> Hub
         """Returns the main instance of the hub."""
+        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
         return GLOBAL_HUB
 
 
-class _HubManager(object):
-    def __init__(self, hub):
-        self._old = Hub.current
-        _local.set(hub)
-
-    def __exit__(self, exc_type, exc_value, tb):
-        _local.set(self._old)
-
-
-class _ScopeManager(object):
-    def __init__(self, hub):
-        self._hub = hub
-        self._original_len = len(hub._stack)
-        self._layer = hub._stack[-1]
-
-    def __enter__(self):
-        # type: () -> Scope
-        scope = self._layer[1]
-        assert scope is not None
-        return scope
-
-    def __exit__(self, exc_type, exc_value, tb):
-        current_len = len(self._hub._stack)
-        if current_len < self._original_len:
-            logger.error(
-                "Scope popped too soon. Popped %s scopes too many.",
-                self._original_len - current_len,
-            )
-            return
-        elif current_len > self._original_len:
-            logger.warning(
-                "Leaked %s scopes: %s",
-                current_len - self._original_len,
-                self._hub._stack[self._original_len :],
-            )
-
-        layer = self._hub._stack[self._original_len - 1]
-        del self._hub._stack[self._original_len - 1 :]
-
-        if layer[1] != self._layer[1]:
-            logger.error(
-                "Wrong scope found. Meant to pop %s, but popped %s.",
-                layer[1],
-                self._layer[1],
-            )
-        elif layer[0] != self._layer[0]:
-            warning = (
-                "init() called inside of pushed scope. This might be entirely "
-                "legitimate but usually occurs when initializing the SDK inside "
-                "a request handler or task/job function. Try to initialize the "
-                "SDK as early as possible instead."
-            )
-            logger.warning(warning)
-
-
 class Hub(with_metaclass(HubMeta)):  # type: ignore
-    """The hub wraps the concurrency management of the SDK.  Each thread has
+    """
+    .. deprecated:: 2.0.0
+        The Hub is deprecated. Its functionality will be merged into :py:class:`sentry_sdk.scope.Scope`.
+
+    The hub wraps the concurrency management of the SDK.  Each thread has
     its own hub but the hub might transfer with the flow of execution if
     context vars are available.
 
@@ -153,27 +127,65 @@ class Hub(with_metaclass(HubMeta)):  # type: ignore
     """
 
     _stack = None  # type: List[Tuple[Optional[Client], Scope]]
+    _scope = None  # type: Optional[Scope]
+
+    # Mypy doesn't pick up on the metaclass.
+
+    if TYPE_CHECKING:
+        current = None  # type: Hub
+        main = None  # type: Hub
+
+    def __init__(
+        self,
+        client_or_hub=None,  # type: Optional[Union[Hub, Client]]
+        scope=None,  # type: Optional[Any]
+    ):
+        # type: (...) -> None
+        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
+
+        current_scope = None
 
-    def __init__(self, client_or_hub=None, scope=None):
-        # type: (Union[Hub, Client], Optional[Any]) -> None
         if isinstance(client_or_hub, Hub):
-            hub = client_or_hub
-            client, other_scope = hub._stack[-1]
+            client = get_client()
             if scope is None:
-                scope = copy.copy(other_scope)
+                # hub cloning is going on, we use a fork of the current/isolation scope for context manager
+                scope = get_isolation_scope().fork()
+                current_scope = get_current_scope().fork()
         else:
-            client = client_or_hub
-        if scope is None:
-            scope = Scope()
+            client = client_or_hub  # type: ignore
+            get_global_scope().set_client(client)
 
-        self._stack = [(client, scope)]
+        if scope is None:  # so there is no Hub cloning going on
+            # just the current isolation scope is used for context manager
+            scope = get_isolation_scope()
+            current_scope = get_current_scope()
+
+        if current_scope is None:
+            # just the current current scope is used for context manager
+            current_scope = get_current_scope()
+
+        self._stack = [(client, scope)]  # type: ignore
         self._last_event_id = None  # type: Optional[str]
         self._old_hubs = []  # type: List[Hub]
 
+        self._old_current_scopes = []  # type: List[Scope]
+        self._old_isolation_scopes = []  # type: List[Scope]
+        self._current_scope = current_scope  # type: Scope
+        self._scope = scope  # type: Scope
+
     def __enter__(self):
         # type: () -> Hub
         self._old_hubs.append(Hub.current)
         _local.set(self)
+
+        current_scope = get_current_scope()
+        self._old_current_scopes.append(current_scope)
+        scope._current_scope.set(self._current_scope)
+
+        isolation_scope = get_isolation_scope()
+        self._old_isolation_scopes.append(isolation_scope)
+        scope._isolation_scope.set(self._scope)
+
         return self
 
     def __exit__(
@@ -186,231 +198,550 @@ class Hub(with_metaclass(HubMeta)):  # type: ignore
         old = self._old_hubs.pop()
         _local.set(old)
 
-    def run(self, callback):
-        """Runs a callback in the context of the hub.  Alternatively the
+        old_current_scope = self._old_current_scopes.pop()
+        scope._current_scope.set(old_current_scope)
+
+        old_isolation_scope = self._old_isolation_scopes.pop()
+        scope._isolation_scope.set(old_isolation_scope)
+
+    def run(
+        self,
+        callback,  # type: Callable[[], T]
+    ):
+        # type: (...) -> T
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+
+        Runs a callback in the context of the hub.  Alternatively the
         with statement can be used on the hub directly.
         """
         with self:
             return callback()
 
-    def get_integration(self, name_or_class):
-        # type: (Union[str, Integration]) -> Any
-        """Returns the integration for this hub by name or class.  If there
+    def get_integration(
+        self,
+        name_or_class,  # type: Union[str, Type[Integration]]
+    ):
+        # type: (...) -> Any
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.client._Client.get_integration` instead.
+
+        Returns the integration for this hub by name or class.  If there
         is no client bound or the client does not have that integration
         then `None` is returned.
 
         If the return value is not `None` the hub is guaranteed to have a
         client attached.
         """
-        if isinstance(name_or_class, str):
-            integration_name = name_or_class
-        elif name_or_class.identifier is not None:
-            integration_name = name_or_class.identifier
-        else:
-            raise ValueError("Integration has no name")
-
-        client = self._stack[-1][0]
-        if client is not None:
-            rv = client.integrations.get(integration_name)
-            if rv is not None:
-                return rv
-
-        initial_client = _initial_client
-        if initial_client is not None:
-            initial_client = initial_client()
-
-        if (
-            initial_client is not None
-            and initial_client is not client
-            and initial_client.integrations.get(name_or_class) is not None
-        ):
-            warning = (
-                "Integration %r attempted to run but it was only "
-                "enabled on init() but not the client that "
-                "was bound to the current flow.  Earlier versions of "
-                "the SDK would consider these integrations enabled but "
-                "this is no longer the case." % (name_or_class,)
-            )
-            warn(Warning(warning), stacklevel=3)
-            logger.warning(warning)
+        return get_client().get_integration(name_or_class)
 
     @property
     def client(self):
-        # type: () -> Optional[Client]
-        """Returns the current client on the hub."""
-        return self._stack[-1][0]
+        # type: () -> Optional[BaseClient]
+        """
+        .. deprecated:: 2.0.0
+            This property is deprecated and will be removed in a future release.
+            Please use :py:func:`sentry_sdk.api.get_client` instead.
+
+        Returns the current client on the hub.
+        """
+        client = get_client()
+
+        if not client.is_active():
+            return None
+
+        return client
+
+    @property
+    def scope(self):
+        # type: () -> Scope
+        """
+        .. deprecated:: 2.0.0
+            This property is deprecated and will be removed in a future release.
+            Returns the current scope on the hub.
+        """
+        return get_isolation_scope()
 
     def last_event_id(self):
-        """Returns the last event ID."""
+        # type: () -> Optional[str]
+        """
+        Returns the last event ID.
+
+        .. deprecated:: 1.40.5
+            This function is deprecated and will be removed in a future release. The functions `capture_event`, `capture_message`, and `capture_exception` return the event ID directly.
+        """
+        logger.warning(
+            "Deprecated: last_event_id is deprecated. This will be removed in the future. The functions `capture_event`, `capture_message`, and `capture_exception` return the event ID directly."
+        )
         return self._last_event_id
 
-    def bind_client(self, new):
-        """Binds a new client to the hub."""
-        top = self._stack[-1]
-        self._stack[-1] = (new, top[1])
-
-    def capture_event(self, event, hint=None):
-        # type: (Dict[str, Any], Dict[str, Any]) -> Optional[str]
-        """Captures an event.  The return value is the ID of the event.
-
-        The event is a dictionary following the Sentry v7/v8 protocol
-        specification.  Optionally an event hint dict can be passed that
-        is used by processors to extract additional information from it.
-        Typically the event hint object would contain exception information.
-        """
-        client, scope = self._stack[-1]
-        if client is not None:
-            rv = client.capture_event(event, hint, scope)
-            if rv is not None:
-                self._last_event_id = rv
-            return rv
-        return None
+    def bind_client(
+        self,
+        new,  # type: Optional[BaseClient]
+    ):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.set_client` instead.
 
-    def capture_message(self, message, level=None):
-        # type: (str, Optional[Any]) -> Optional[str]
-        """Captures a message.  The message is just a string.  If no level
-        is provided the default level is `info`.
+        Binds a new client to the hub.
         """
-        if self.client is None:
-            return None
-        if level is None:
-            level = "info"
-        return self.capture_event({"message": message, "level": level})
-
-    def capture_exception(self, error=None):
-        """Captures an exception.
-
-        The argument passed can be `None` in which case the last exception
-        will be reported, otherwise an exception object or an `exc_info`
-        tuple.
-        """
-        client = self.client
-        if client is None:
-            return
-        if error is None:
-            exc_info = sys.exc_info()
-        else:
-            exc_info = exc_info_from_error(error)
+        get_global_scope().set_client(new)
+
+    def capture_event(self, event, hint=None, scope=None, **scope_kwargs):
+        # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.capture_event` instead.
 
-        event, hint = event_from_exception(exc_info, client_options=client.options)
-        try:
-            return self.capture_event(event, hint=hint)
-        except Exception:
-            self._capture_internal_exception(sys.exc_info())
+        Captures an event.
+
+        Alias of :py:meth:`sentry_sdk.Scope.capture_event`.
+
+        :param event: A ready-made event that can be directly sent to Sentry.
+
+        :param hint: Contains metadata about the event that can be read from `before_send`, such as the original exception object or a HTTP request object.
+
+        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+
+        :param scope_kwargs: Optional data to apply to event.
+            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+        """
+        last_event_id = get_current_scope().capture_event(
+            event, hint, scope=scope, **scope_kwargs
+        )
+
+        is_transaction = event.get("type") == "transaction"
+        if last_event_id is not None and not is_transaction:
+            self._last_event_id = last_event_id
+
+        return last_event_id
+
+    def capture_message(self, message, level=None, scope=None, **scope_kwargs):
+        # type: (str, Optional[LogLevelStr], Optional[Scope], Any) -> Optional[str]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.capture_message` instead.
+
+        Captures a message.
+
+        Alias of :py:meth:`sentry_sdk.Scope.capture_message`.
+
+        :param message: The string to send as the message to Sentry.
+
+        :param level: If no level is provided, the default level is `info`.
+
+        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+
+        :param scope_kwargs: Optional data to apply to event.
+            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+
+        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.client._Client.capture_event`).
+        """
+        last_event_id = get_current_scope().capture_message(
+            message, level=level, scope=scope, **scope_kwargs
+        )
+
+        if last_event_id is not None:
+            self._last_event_id = last_event_id
+
+        return last_event_id
+
+    def capture_exception(self, error=None, scope=None, **scope_kwargs):
+        # type: (Optional[Union[BaseException, ExcInfo]], Optional[Scope], Any) -> Optional[str]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.capture_exception` instead.
+
+        Captures an exception.
+
+        Alias of :py:meth:`sentry_sdk.Scope.capture_exception`.
+
+        :param error: An exception to capture. If `None`, `sys.exc_info()` will be used.
+
+        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+
+        :param scope_kwargs: Optional data to apply to event.
+            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+            The `scope` and `scope_kwargs` parameters are mutually exclusive.
+
+        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.client._Client.capture_event`).
+        """
+        last_event_id = get_current_scope().capture_exception(
+            error, scope=scope, **scope_kwargs
+        )
 
-    def _capture_internal_exception(self, exc_info):
-        """Capture an exception that is likely caused by a bug in the SDK
-        itself."""
-        logger.error("Internal error in sentry_sdk", exc_info=exc_info)
+        if last_event_id is not None:
+            self._last_event_id = last_event_id
+
+        return last_event_id
 
     def add_breadcrumb(self, crumb=None, hint=None, **kwargs):
-        # type: (Dict[str, Any], Dict[str, Any], **Any) -> None
-        """Adds a breadcrumb.  The breadcrumbs are a dictionary with the
-        data as the sentry v7/v8 protocol expects.  `hint` is an optional
-        value that can be used by `before_breadcrumb` to customize the
-        breadcrumbs that are emitted.
-        """
-        client, scope = self._stack[-1]
-        if client is None:
-            logger.info("Dropped breadcrumb because no client bound")
-            return
-
-        crumb = dict(crumb or ())  # type: Dict[str, Any]
-        crumb.update(kwargs)
-        if not crumb:
-            return
-
-        hint = dict(hint or ())
-
-        if crumb.get("timestamp") is None:
-            crumb["timestamp"] = datetime.utcnow()
-        if crumb.get("type") is None:
-            crumb["type"] = "default"
-
-        original_crumb = crumb
-        if client.options["before_breadcrumb"] is not None:
-            crumb = client.options["before_breadcrumb"](crumb, hint)
-
-        if crumb is not None:
-            scope._breadcrumbs.append(crumb)
-        else:
-            logger.info("before breadcrumb dropped breadcrumb (%s)", original_crumb)
+        # type: (Optional[Breadcrumb], Optional[BreadcrumbHint], Any) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.add_breadcrumb` instead.
+
+        Adds a breadcrumb.
+
+        :param crumb: Dictionary with the data as the sentry v7/v8 protocol expects.
+
+        :param hint: An optional value that can be used by `before_breadcrumb`
+            to customize the breadcrumbs that are emitted.
+        """
+        get_isolation_scope().add_breadcrumb(crumb, hint, **kwargs)
+
+    def start_span(self, instrumenter=INSTRUMENTER.SENTRY, **kwargs):
+        # type: (str, Any) -> Span
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.start_span` instead.
+
+        Start a span whose parent is the currently active span or transaction, if any.
+
+        The return value is a :py:class:`sentry_sdk.tracing.Span` instance,
+        typically used as a context manager to start and stop timing in a `with`
+        block.
+
+        Only spans contained in a transaction are sent to Sentry. Most
+        integrations start a transaction at the appropriate time, for example
+        for every incoming HTTP request. Use
+        :py:meth:`sentry_sdk.start_transaction` to start a new transaction when
+        one is not already in progress.
+
+        For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Span`.
+        """
+        scope = get_current_scope()
+        return scope.start_span(instrumenter=instrumenter, **kwargs)
+
+    def start_transaction(
+        self,
+        transaction=None,
+        instrumenter=INSTRUMENTER.SENTRY,
+        custom_sampling_context=None,
+        **kwargs,
+    ):
+        # type: (Optional[Transaction], str, Optional[SamplingContext], Unpack[TransactionKwargs]) -> Union[Transaction, NoOpSpan]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.start_transaction` instead.
+
+        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.
 
-        max_breadcrumbs = client.options["max_breadcrumbs"]  # type: int
-        while len(scope._breadcrumbs) > max_breadcrumbs:
-            scope._breadcrumbs.popleft()
+        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.
+
+        For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Transaction`.
+        """
+        scope = get_current_scope()
+
+        # For backwards compatibility, we allow passing the scope as the hub.
+        # We need a major release to make this nice. (if someone searches the code: deprecated)
+        # Type checking disabled for this line because deprecated keys are not allowed in the type signature.
+        kwargs["hub"] = scope  # type: ignore
+
+        return scope.start_transaction(
+            transaction, instrumenter, custom_sampling_context, **kwargs
+        )
+
+    def continue_trace(self, environ_or_headers, op=None, name=None, source=None):
+        # type: (Dict[str, Any], Optional[str], Optional[str], Optional[str]) -> Transaction
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.continue_trace` instead.
 
-    @overload  # noqa
-    def push_scope(self):
-        # type: () -> ContextManager[Scope]
+        Sets the propagation context from environment or headers and returns a transaction.
+        """
+        return get_isolation_scope().continue_trace(
+            environ_or_headers=environ_or_headers, op=op, name=name, source=source
+        )
+
+    @overload
+    def push_scope(
+        self,
+        callback=None,  # type: Optional[None]
+    ):
+        # type: (...) -> ContextManager[Scope]
         pass
 
-    @overload  # noqa
-    def push_scope(self, callback):
-        # type: (Callable[[Scope], None]) -> None
+    @overload
+    def push_scope(  # noqa: F811
+        self,
+        callback,  # type: Callable[[Scope], None]
+    ):
+        # type: (...) -> None
         pass
 
-    def push_scope(self, callback=None):  # noqa
-        """Pushes a new layer on the scope stack. Returns a context manager
-        that should be used to pop the scope again.  Alternatively a callback
-        can be provided that is executed in the context of the scope.
+    def push_scope(  # noqa
+        self,
+        callback=None,  # type: Optional[Callable[[Scope], None]]
+        continue_trace=True,  # type: bool
+    ):
+        # type: (...) -> Optional[ContextManager[Scope]]
         """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+
+        Pushes a new layer on the scope stack.
 
+        :param callback: If provided, this method pushes a scope, calls
+            `callback`, and pops the scope again.
+
+        :returns: If no `callback` is provided, a context manager that should
+            be used to pop the scope again.
+        """
         if callback is not None:
             with self.push_scope() as scope:
                 callback(scope)
             return None
 
-        client, scope = self._stack[-1]
-        new_layer = (client, copy.copy(scope))
-        self._stack.append(new_layer)
-
         return _ScopeManager(self)
 
-    scope = push_scope
-
     def pop_scope_unsafe(self):
-        """Pops a scope layer from the stack. Try to use the context manager
-        `push_scope()` instead."""
+        # type: () -> Tuple[Optional[Client], Scope]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+
+        Pops a scope layer from the stack.
+
+        Try to use the context manager :py:meth:`push_scope` instead.
+        """
         rv = self._stack.pop()
         assert self._stack, "stack must have at least one layer"
         return rv
 
-    @overload  # noqa
-    def configure_scope(self):
-        # type: () -> ContextManager[Scope]
+    @overload
+    def configure_scope(
+        self,
+        callback=None,  # type: Optional[None]
+    ):
+        # type: (...) -> ContextManager[Scope]
         pass
 
-    @overload  # noqa
-    def configure_scope(self, callback):
-        # type: (Callable[[Scope], None]) -> None
+    @overload
+    def configure_scope(  # noqa: F811
+        self,
+        callback,  # type: Callable[[Scope], None]
+    ):
+        # type: (...) -> None
         pass
 
-    def configure_scope(self, callback=None):  # noqa
-        """Reconfigures the scope."""
+    def configure_scope(  # noqa
+        self,
+        callback=None,  # type: Optional[Callable[[Scope], None]]
+        continue_trace=True,  # type: bool
+    ):
+        # type: (...) -> Optional[ContextManager[Scope]]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+
+        Reconfigures the scope.
+
+        :param callback: If provided, call the callback with the current scope.
+
+        :returns: If no callback is provided, returns a context manager that returns the scope.
+        """
+        scope = get_isolation_scope()
+
+        if continue_trace:
+            scope.generate_propagation_context()
 
-        client, scope = self._stack[-1]
         if callback is not None:
-            if client is not None:
-                callback(scope)
+            # TODO: used to return None when client is None. Check if this changes behavior.
+            callback(scope)
 
             return None
 
         @contextmanager
         def inner():
-            if client is not None:
-                yield scope
-            else:
-                yield Scope()
+            # type: () -> Generator[Scope, None, None]
+            yield scope
 
         return inner()
 
-    def flush(self, timeout=None, callback=None):
-        """Alias for self.client.flush"""
-        client, scope = self._stack[-1]
-        if client is not None:
-            return client.flush(timeout=timeout, callback=callback)
+    def start_session(
+        self,
+        session_mode="application",  # type: str
+    ):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.start_session` instead.
+
+        Starts a new session.
+        """
+        get_isolation_scope().start_session(
+            session_mode=session_mode,
+        )
+
+    def end_session(self):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.end_session` instead.
+
+        Ends the current session if there is one.
+        """
+        get_isolation_scope().end_session()
+
+    def stop_auto_session_tracking(self):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.stop_auto_session_tracking` instead.
+
+        Stops automatic session tracking.
+
+        This temporarily session tracking for the current scope when called.
+        To resume session tracking call `resume_auto_session_tracking`.
+        """
+        get_isolation_scope().stop_auto_session_tracking()
 
+    def resume_auto_session_tracking(self):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.resume_auto_session_tracking` instead.
 
-GLOBAL_HUB = Hub()
+        Resumes automatic session tracking for the current scope if
+        disabled earlier.  This requires that generally automatic session
+        tracking is enabled.
+        """
+        get_isolation_scope().resume_auto_session_tracking()
+
+    def flush(
+        self,
+        timeout=None,  # type: Optional[float]
+        callback=None,  # type: Optional[Callable[[int, float], None]]
+    ):
+        # type: (...) -> None
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.client._Client.flush` instead.
+
+        Alias for :py:meth:`sentry_sdk.client._Client.flush`
+        """
+        return get_client().flush(timeout=timeout, callback=callback)
+
+    def get_traceparent(self):
+        # type: () -> Optional[str]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.get_traceparent` instead.
+
+        Returns the traceparent either from the active span or from the scope.
+        """
+        current_scope = get_current_scope()
+        traceparent = current_scope.get_traceparent()
+
+        if traceparent is None:
+            isolation_scope = get_isolation_scope()
+            traceparent = isolation_scope.get_traceparent()
+
+        return traceparent
+
+    def get_baggage(self):
+        # type: () -> Optional[str]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.get_baggage` instead.
+
+        Returns Baggage either from the active span or from the scope.
+        """
+        current_scope = get_current_scope()
+        baggage = current_scope.get_baggage()
+
+        if baggage is None:
+            isolation_scope = get_isolation_scope()
+            baggage = isolation_scope.get_baggage()
+
+        if baggage is not None:
+            return baggage.serialize()
+
+        return None
+
+    def iter_trace_propagation_headers(self, span=None):
+        # type: (Optional[Span]) -> Generator[Tuple[str, str], None, None]
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.iter_trace_propagation_headers` instead.
+
+        Return HTTP headers which allow propagation of trace data. Data taken
+        from the span representing the request, if available, or the current
+        span on the scope if not.
+        """
+        return get_current_scope().iter_trace_propagation_headers(
+            span=span,
+        )
+
+    def trace_propagation_meta(self, span=None):
+        # type: (Optional[Span]) -> str
+        """
+        .. deprecated:: 2.0.0
+            This function is deprecated and will be removed in a future release.
+            Please use :py:meth:`sentry_sdk.Scope.trace_propagation_meta` instead.
+
+        Return meta tags which should be injected into HTML templates
+        to allow propagation of trace information.
+        """
+        if span is not None:
+            logger.warning(
+                "The parameter `span` in trace_propagation_meta() is deprecated and will be removed in the future."
+            )
+
+        return get_current_scope().trace_propagation_meta(
+            span=span,
+        )
+
+
+with _suppress_hub_deprecation_warning():
+    # Suppress deprecation warning for the Hub here, since we still always
+    # import this module.
+    GLOBAL_HUB = Hub()
 _local.set(GLOBAL_HUB)
+
+
+# Circular imports
+from sentry_sdk import scope