747 lines
25 KiB
Python
747 lines
25 KiB
Python
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
|