API Docs¶
- class sentry_sdk.Hub(client_or_hub=None, scope=None)[source]¶
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.
- capture_event(event, hint=None, scope=None, **scope_args)[source]¶
Captures an event.
Alias of
sentry_sdk.Client.capture_event()
.- Parameters:
scope_args (
Any
) – For supported **scope_args seesentry_sdk.Scope.update_from_kwargs()
.- Return type:
- capture_exception(error=None, scope=None, **scope_args)[source]¶
Captures an exception.
- Parameters:
error (
Union
[BaseException
,Tuple
[Optional
[Type
[BaseException
]],Optional
[BaseException
],Optional
[TracebackType
]],None
]) – An exception to catch. If None, sys.exc_info() will be used.scope_args (
Any
) – For supported **scope_args seesentry_sdk.Scope.update_from_kwargs()
.
- Return type:
- Returns:
An event_id if the SDK decided to send the event (see
sentry_sdk.Client.capture_event()
).
- capture_message(message, level=None, scope=None, **scope_args)[source]¶
Captures a message.
- Parameters:
message (
str
) – The string to send as the message.level (
Optional
[str
]) – If no level is provided, the default level is info.scope (
Optional
[Scope
]) – An optionalsentry_sdk.Scope
to use.scope_args (
Any
) – For supported **scope_args seesentry_sdk.Scope.update_from_kwargs()
.
- Return type:
- Returns:
An event_id if the SDK decided to send the event (see
sentry_sdk.Client.capture_event()
).
- continue_trace(environ_or_headers, op=None, name=None, source=None)[source]¶
Sets the propagation context from environment or headers and returns a transaction.
- Return type:
- get_integration(name_or_class)[source]¶
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 type:
- iter_trace_propagation_headers(span=None)[source]¶
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.
- pop_scope_unsafe()[source]¶
Pops a scope layer from the stack.
Try to use the context manager
push_scope()
instead.
- resume_auto_session_tracking()[source]¶
Resumes automatic session tracking for the current scope if disabled earlier. This requires that generally automatic session tracking is enabled.
- Return type:
- run(callback)[source]¶
Runs a callback in the context of the hub. Alternatively the with statement can be used on the hub directly.
- Return type:
TypeVar
(T
)
- start_span(span=None, instrumenter='sentry', **kwargs)[source]¶
Start a span whose parent is the currently active span or transaction, if any.
The return value is a
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
sentry_sdk.start_transaction()
to start a new transaction when one is not already in progress.For supported **kwargs see
sentry_sdk.tracing.Span
.- Return type:
- start_transaction(transaction=None, instrumenter='sentry', **kwargs)[source]¶
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
sentry_sdk.tracing.Transaction
.- Return type:
Union
[Transaction
,NoOpSpan
]
- class sentry_sdk.Scope[source]¶
The scope holds extra information that should be sent with all events that belong to it.
- add_attachment(bytes=None, filename=None, path=None, content_type=None, add_to_transactions=False)[source]¶
Adds an attachment to future events sent.
- Return type:
- add_error_processor(func, cls=None)[source]¶
Register a scope local error processor on the scope.
- Parameters:
func (
Callable
[[Dict
[str
,Any
],Tuple
[Optional
[Type
[BaseException
]],Optional
[BaseException
],Optional
[TracebackType
]]],Optional
[Dict
[str
,Any
]]]) – A callback that works similar to an event processor but is invoked with the original exception info triple as second argument.cls (
Optional
[Type
[BaseException
]]) – Optionally, only process exceptions of this type.
- Return type:
- apply_to_event(event, hint, options=None)[source]¶
Applies the information contained on the scope to the given event.
- property fingerprint¶
When set this overrides the default fingerprint.
- generate_propagation_context(incoming_data=None)[source]¶
Makes sure _propagation_context is set. If there is incoming_data overwrite existing _propagation_context. if there is no incoming_data create new _propagation_context, but do NOT overwrite if already existing.
- Return type:
- get_dynamic_sampling_context()[source]¶
Returns the Dynamic Sampling Context from the Propagation Context. If not existing, creates a new one.
- get_trace_context()[source]¶
Returns the Sentry “trace” context from the Propagation Context.
- Return type:
- get_traceparent()[source]¶
Returns the Sentry “sentry-trace” header (aka the traceparent) from the Propagation Context.
- iter_headers()[source]¶
Creates a generator which returns the sentry-trace and baggage headers from the Propagation Context.
- property level¶
When set this overrides the level. Deprecated in favor of set_level.
- set_new_propagation_context()[source]¶
Creates a new propagation context and sets it as _propagation_context. Overwriting existing one.
- Return type:
- set_transaction_name(name, source=None)[source]¶
Set the transaction name and optionally the transaction source.
- Return type:
- update_from_kwargs(user=None, level=None, extras=None, contexts=None, tags=None, fingerprint=None)[source]¶
Update the scope’s attributes.
- Return type:
- property user¶
When set a specific user is bound to the scope. Deprecated in favor of set_user.
- class sentry_sdk.Client(dsn=None, max_breadcrumbs=100, release=None, environment=None, server_name=None, shutdown_timeout=2, integrations=[], in_app_include=[], in_app_exclude=[], default_integrations=True, dist=None, transport=None, transport_queue_size=100, sample_rate=1.0, send_default_pii=False, http_proxy=None, https_proxy=None, ignore_errors=[], max_request_body_size='medium', before_send=None, before_breadcrumb=None, debug=None, attach_stacktrace=False, ca_certs=None, propagate_traces=True, traces_sample_rate=None, traces_sampler=None, profiles_sample_rate=None, profiles_sampler=None, profiler_mode=None, auto_enabling_integrations=True, auto_session_tracking=True, send_client_reports=True, _experiments={}, proxy_headers=None, instrumenter='sentry', before_send_transaction=None, project_root=None, enable_tracing=None, include_local_variables=True, include_source_context=True, trace_propagation_targets=['.*'], functions_to_trace=[], event_scrubber=None, max_value_length=1024, enable_backpressure_handling=True, error_sampler=None, enable_db_query_source=False, db_query_source_threshold_ms=100, spotlight=None)[source]¶
- class sentry_sdk.Transport(options=None)[source]¶
Baseclass for all transports.
A transport is used to send an event to sentry.
- capture_envelope(envelope)[source]¶
Send an envelope to Sentry.
Envelopes are a data container format that can hold any type of data submitted to Sentry. We use it for transactions and sessions, but regular “error” events should go through capture_event for backwards compat.
- Return type:
- capture_event(event)[source]¶
This gets invoked with the event dictionary when an event should be sent to sentry.
- Return type:
- class sentry_sdk.HttpTransport(options)[source]¶
The default HTTP transport.
- capture_envelope(envelope)[source]¶
Send an envelope to Sentry.
Envelopes are a data container format that can hold any type of data submitted to Sentry. We use it for transactions and sessions, but regular “error” events should go through capture_event for backwards compat.
- Return type:
- capture_event(event)[source]¶
This gets invoked with the event dictionary when an event should be sent to sentry.
- Return type:
- class sentry_sdk.tracing.Transaction(**kwargs: Any)[source]¶
The Transaction is the root element that holds all the spans for Sentry performance instrumentation.
- property containing_transaction: Transaction¶
The root element of the span tree. In the case of a transaction it is the transaction itself.
- finish(hub=None, end_timestamp=None)[source]¶
Finishes the transaction and sends it to Sentry. All finished spans in the transaction will also be sent to Sentry.
- Parameters:
- Return type:
- Returns:
The event ID if the transaction was sent to Sentry, otherwise None.
- get_baggage()[source]¶
Returns the
Baggage
associated with the Transaction.The first time a new baggage with Sentry items is made, it will be frozen.
- Return type:
Baggage
- set_context(key, value)[source]¶
Sets a context. Transactions can have multiple contexts and they should follow the format described in the “Contexts Interface” documentation.
- class sentry_sdk.tracing.Span(**kwargs: Any)[source]¶
A span holds timing information of a block of code. Spans can have multiple child spans thus forming a span tree.
- property containing_transaction: Transaction | None¶
The
Transaction
that this span belongs to. TheTransaction
is the root of the span tree, so one could also think of thisTransaction
as the “root span”.
- classmethod continue_from_environ(environ, **kwargs)[source]¶
Create a Transaction with the given params, then add in data pulled from the
sentry-trace
andbaggage
headers from the environ (if any) before returning the Transaction.This is different from
continue_from_headers()
in that it assumes header names in the formHTTP_HEADER_NAME
- such as you would get from a WSGI/ASGI environ - rather than the formheader-name
.
- classmethod continue_from_headers(headers, **kwargs)[source]¶
Create a transaction with the given params (including any data pulled from the
sentry-trace
andbaggage
headers).
- finish(hub=None, end_timestamp=None)[source]¶
Sets the end timestamp of the span. Additionally it also creates a breadcrumb from the span, if the span represents a database or HTTP request.
- Parameters:
- Return type:
- Returns:
Always
None
. The type isOptional[str]
to match the return value ofsentry_sdk.tracing.Transaction.finish()
.
- classmethod from_traceparent(traceparent, **kwargs)[source]¶
DEPRECATED: Use
sentry_sdk.tracing.Span.continue_from_headers()
.Create a
Transaction
with the given params, then add in data pulled from the givensentry-trace
header value before returning theTransaction
.- Return type:
- iter_headers()[source]¶
Creates a generator which returns the span’s
sentry-trace
andbaggage
headers. If the span’s containing transaction doesn’t yet have abaggage
value, this will cause one to be generated and stored.
- new_span(**kwargs)[source]¶
DEPRECATED: use
sentry_sdk.tracing.Span.start_child()
instead.- Return type:
- start_child(instrumenter='sentry', **kwargs)[source]¶
Start a sub-span from the current span or transaction.
Takes the same arguments as the initializer of
Span
. The trace id, sampling decision, transaction pointer, and span recorder are inherited from the current span/transaction.- Return type:
- class sentry_sdk.session.Session(sid=None, did=None, timestamp=None, started=None, duration=None, status=None, release=None, environment=None, user_agent=None, ip_address=None, errors=None, user=None, session_mode='application')[source]¶
- class sentry_sdk.attachments.Attachment(bytes=None, filename=None, path=None, content_type=None, add_to_transactions=False)[source]¶