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

sentry_sdk/hub.py

@@ -1,739 +0,0 @@
-import warnings
-from contextlib import contextmanager
-
-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.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 (
-    logger,
-    ContextVar,
-)
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Any
-    from typing import Callable
-    from typing import ContextManager
-    from typing import Dict
-    from typing import Generator
-    from typing import List
-    from typing import Optional
-    from typing import overload
-    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
-
-
-class SentryHubDeprecationWarning(DeprecationWarning):
-    """
-    A custom deprecation warning to inform users that the Hub is deprecated.
-    """
-
-    _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 __init__(self, *_):
-        # type: (*object) -> None
-        super().__init__(self._MESSAGE)
-
-
-@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
-
-
-_local = ContextVar("sentry_current_hub")
-
-
-class HubMeta(type):
-    @property
-    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:
-            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(cls):
-        # type: () -> Hub
-        """Returns the main instance of the hub."""
-        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
-        return GLOBAL_HUB
-
-
-class Hub(with_metaclass(HubMeta)):  # type: ignore
-    """
-    .. 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.
-
-    If the hub is used with a with statement it's temporarily activated.
-    """
-
-    _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
-
-        if isinstance(client_or_hub, Hub):
-            client = get_client()
-            if scope is None:
-                # 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  # type: ignore
-            get_global_scope().set_client(client)
-
-        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__(
-        self,
-        exc_type,  # type: Optional[type]
-        exc_value,  # type: Optional[BaseException]
-        tb,  # type: Optional[Any]
-    ):
-        # type: (...) -> None
-        old = self._old_hubs.pop()
-        _local.set(old)
-
-        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, 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.
-        """
-        return get_client().get_integration(name_or_class)
-
-    @property
-    def client(self):
-        # 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):
-        # 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  # 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.
-
-        Binds a new client to the hub.
-        """
-        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.
-
-        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
-        )
-
-        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: (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.
-
-        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.
-
-        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
-    def push_scope(  # noqa: F811
-        self, callback  # type: Callable[[Scope], None]
-    ):
-        # type: (...) -> None
-        pass
-
-    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
-
-        return _ScopeManager(self)
-
-    def pop_scope_unsafe(self):
-        # 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
-    def configure_scope(
-        self, callback=None  # type: Optional[None]
-    ):
-        # type: (...) -> ContextManager[Scope]
-        pass
-
-    @overload
-    def configure_scope(  # noqa: F811
-        self, callback  # type: Callable[[Scope], None]
-    ):
-        # type: (...) -> None
-        pass
-
-    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()
-
-        if callback is not None:
-            # TODO: used to return None when client is None. Check if this changes behavior.
-            callback(scope)
-
-            return None
-
-        @contextmanager
-        def inner():
-            # type: () -> Generator[Scope, None, None]
-            yield scope
-
-        return inner()
-
-    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.
-
-        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