def _init_on_hub(hub, args, kwargs):
options = get_options(*args, **kwargs)
client = Client(options)
hub.bind_client(client)
setup_integrations(options["integrations"] or [],
with_defaults=options["default_integrations"])
return _InitGuard(client)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
assert sentry_sdk.Hub.main.client is None
options = settings.SENTRY_SDK_CONFIG
internal_transport = InternalTransport()
upstream_transport = None
if options.get('dsn'):
upstream_transport = make_transport(get_options(options))
def capture_event(event):
internal_transport.capture_event(event)
if upstream_transport is not None:
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
sentry_sdk.init(integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
],
transport=capture_event,
**options)
def sentry_js():
if sentry_client:
return {
'environment': settings.ENVIRONMENT,
'app_git_commit': settings.APP_GIT_COMMIT,
'sentry_dsn': sentry_client.get_options().get('dsn')
}
else:
return {'sentry_dsn': ''}
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
# if this flag is set then the internal transport is disabled. This is useful
# for local testing in case the real python SDK behavior should be enforced.
if not sdk_options.pop("disable_internal_transport", False):
internal_transport = InternalTransport()
upstream_transport = None
if sdk_options.get("dsn"):
upstream_transport = make_transport(get_options(sdk_options))
def capture_event(event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"):
return
# Make sure we log to upstream when available first
if upstream_transport is not None:
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
internal_transport.capture_event(event)
sdk_options["transport"] = capture_event
sentry_sdk.init(integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
],
traceparent_v2=True,
**sdk_options)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = settings.SENTRY_SDK_CONFIG
internal_transport = InternalTransport()
upstream_transport = None
if sdk_options.get('dsn'):
upstream_transport = make_transport(get_options(sdk_options))
def capture_event(event):
if (event.get('type') == 'transaction' and options.get(
'transaction-events.force-disable-internal-project')):
return
# Make sure we log to upstream when available first
if upstream_transport is not None:
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
internal_transport.capture_event(event)
sentry_sdk.init(integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
],
transport=capture_event,
traceparent_v2=True,
**sdk_options)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
assert sentry_sdk.Hub.main.client is None
options = settings.SENTRY_SDK_CONFIG
internal_transport = InternalTransport()
upstream_transport = None
if options.get('dsn'):
upstream_transport = make_transport(get_options(options))
def capture_event(event):
# Make sure we log to upstream when available first
if upstream_transport is not None:
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
internal_transport.capture_event(event)
sentry_sdk.init(
integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
],
transport=capture_event,
**options
)
def configure_sdk():
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.redis import RedisIntegration
from sentry_sdk.integrations.threading import ThreadingIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
relay_dsn = sdk_options.pop("relay_dsn", None)
internal_project_key = get_project_key()
upstream_dsn = sdk_options.pop("dsn", None)
sdk_options["traces_sampler"] = traces_sampler
sdk_options["release"] = (f"backend@{sdk_options['release']}"
if "release" in sdk_options else None)
sdk_options["send_client_reports"] = True
if upstream_dsn:
transport = make_transport(get_options(dsn=upstream_dsn,
**sdk_options))
upstream_transport = patch_transport_for_instrumentation(
transport, "upstream")
else:
upstream_transport = None
if relay_dsn:
transport = make_transport(get_options(dsn=relay_dsn, **sdk_options))
relay_transport = patch_transport_for_instrumentation(
transport, "relay")
elif internal_project_key and internal_project_key.dsn_private:
transport = make_transport(
get_options(dsn=internal_project_key.dsn_private, **sdk_options))
relay_transport = patch_transport_for_instrumentation(
transport, "relay")
else:
relay_transport = None
_override_on_full_queue(relay_transport,
"internal.uncaptured.events.relay")
_override_on_full_queue(upstream_transport,
"internal.uncaptured.events.upstream")
class MultiplexingTransport(sentry_sdk.transport.Transport):
def capture_envelope(self, envelope):
# Temporarily capture envelope counts to compare to ingested
# transactions.
metrics.incr("internal.captured.events.envelopes")
transaction = envelope.get_transaction_event()
if transaction:
metrics.incr("internal.captured.events.transactions")
# Assume only transactions get sent via envelopes
if options.get(
"transaction-events.force-disable-internal-project"):
return
self._capture_anything("capture_envelope", envelope)
def capture_event(self, event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"):
return
self._capture_anything("capture_event", event)
def _capture_anything(self, method_name, *args, **kwargs):
# Upstream should get the event first because it is most isolated from
# the this sentry installation.
if upstream_transport:
metrics.incr("internal.captured.events.upstream")
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
getattr(upstream_transport, method_name)(*args, **kwargs)
if relay_transport and options.get(
"store.use-relay-dsn-sample-rate") == 1:
# If this is a envelope ensure envelope and it's items are distinct references
if method_name == "capture_envelope":
args_list = list(args)
envelope = args_list[0]
relay_envelope = copy.copy(envelope)
relay_envelope.items = envelope.items.copy()
args = [relay_envelope, *args_list[1:]]
if is_current_event_safe():
metrics.incr("internal.captured.events.relay")
getattr(relay_transport, method_name)(*args, **kwargs)
else:
metrics.incr(
"internal.uncaptured.events.relay",
skip_internal=False,
tags={"reason": "unsafe"},
)
sentry_sdk.init(
transport=MultiplexingTransport(),
integrations=[
DjangoAtomicIntegration(),
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
RedisIntegration(),
ThreadingIntegration(propagate_hub=True),
],
**sdk_options,
)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.redis import RedisIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
relay_dsn = sdk_options.pop("relay_dsn", None)
internal_project_key = get_project_key()
upstream_dsn = sdk_options.pop("dsn", None)
sdk_options["traces_sampler"] = traces_sampler
if upstream_dsn:
upstream_transport = make_transport(get_options(dsn=upstream_dsn, **sdk_options))
else:
upstream_transport = None
if relay_dsn:
relay_transport = make_transport(get_options(dsn=relay_dsn, **sdk_options))
elif internal_project_key and internal_project_key.dsn_private:
relay_transport = make_transport(
get_options(dsn=internal_project_key.dsn_private, **sdk_options)
)
else:
relay_transport = None
_override_on_full_queue(relay_transport, "internal.uncaptured.events.relay")
_override_on_full_queue(upstream_transport, "internal.uncaptured.events.upstream")
class MultiplexingTransport(sentry_sdk.transport.Transport):
def capture_envelope(self, envelope):
# Temporarily capture envelope counts to compare to ingested
# transactions.
metrics.incr("internal.captured.events.envelopes")
transaction = envelope.get_transaction_event()
# Temporarily also capture counts for one specific transaction to check ingested amount
if (
transaction
and transaction.get("transaction")
== "/api/0/organizations/{organization_slug}/issues/"
):
metrics.incr("internal.captured.events.envelopes.issues")
# Assume only transactions get sent via envelopes
if options.get("transaction-events.force-disable-internal-project"):
return
self._capture_anything("capture_envelope", envelope)
def capture_event(self, event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"
):
return
self._capture_anything("capture_event", event)
def _capture_anything(self, method_name, *args, **kwargs):
# Upstream should get the event first because it is most isolated from
# the this sentry installation.
if upstream_transport:
metrics.incr("internal.captured.events.upstream")
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
getattr(upstream_transport, method_name)(*args, **kwargs)
if relay_transport and options.get("store.use-relay-dsn-sample-rate") == 1:
if is_current_event_safe():
metrics.incr("internal.captured.events.relay")
getattr(relay_transport, method_name)(*args, **kwargs)
else:
metrics.incr(
"internal.uncaptured.events.relay",
skip_internal=False,
tags={"reason": "unsafe"},
)
sentry_sdk.init(
transport=MultiplexingTransport(),
integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
RedisIntegration(),
],
**sdk_options,
)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.redis import RedisIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
relay_dsn = sdk_options.pop("relay_dsn", None)
internal_project_key = get_project_key()
upstream_dsn = sdk_options.pop("dsn", None)
if upstream_dsn:
upstream_transport = make_transport(
get_options(dsn=upstream_dsn, **sdk_options))
else:
upstream_transport = None
if relay_dsn:
relay_transport = make_transport(
get_options(dsn=relay_dsn, **sdk_options))
elif internal_project_key and internal_project_key.dsn_private:
relay_transport = make_transport(
get_options(dsn=internal_project_key.dsn_private, **sdk_options))
else:
relay_transport = None
def capture_event(event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"):
return
# Upstream should get the event first because it is most isolated from
# the this sentry installation.
if upstream_transport:
metrics.incr("internal.captured.events.upstream")
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
if relay_transport and options.get(
"store.use-relay-dsn-sample-rate") == 1:
if is_current_event_safe():
metrics.incr("internal.captured.events.relay")
relay_transport.capture_event(event)
else:
metrics.incr("internal.uncaptured.events.relay",
skip_internal=False)
if event.get("type") != "transaction":
sdk_logger.warn("internal-error.unsafe-stacktrace.relay")
sentry_sdk.init(transport=capture_event,
integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
RedisIntegration(),
],
traceparent_v2=True,
**sdk_options)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
# if this flag is set then the internal transport is disabled. This is useful
# for local testing in case the real python SDK behavior should be enforced.
#
# Make sure to pop all options that would be invalid for the SDK here
disable_internal_transport = sdk_options.pop("disable_internal_transport",
False)
relay_dsn = sdk_options.pop("relay_dsn", None)
upstream_dsn = sdk_options.pop("dsn", None)
if upstream_dsn:
upstream_transport = make_transport(
get_options(dsn=upstream_dsn, **sdk_options))
else:
upstream_transport = None
if not disable_internal_transport:
internal_transport = InternalTransport()
else:
internal_transport = None
if relay_dsn:
relay_transport = make_transport(
get_options(dsn=relay_dsn, **sdk_options))
else:
relay_transport = None
def capture_event(event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"):
return
# Upstream should get the event first because it is most isolated from
# the this sentry installation.
if upstream_transport:
metrics.incr("internal.captured.events.upstream")
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
upstream_transport.capture_event(event)
if relay_transport:
rate = options.get("store.use-relay-dsn-sample-rate")
if rate and random.random() < rate:
# Record this before calling `is_current_event_safe` to make
# numbers comparable to InternalTransport
metrics.incr("internal.captured.events.relay")
if is_current_event_safe():
relay_transport.capture_event(event)
else:
metrics.incr("internal.uncaptured.events.relay",
skip_internal=False)
sdk_logger.warn("internal-error.unsafe-stacktrace.relay")
return
if internal_transport:
metrics.incr("internal.captured.events.internal")
internal_transport.capture_event(event)
sentry_sdk.init(transport=capture_event,
integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
],
traceparent_v2=True,
**sdk_options)
def configure_sdk():
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.django import DjangoIntegration
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.redis import RedisIntegration
assert sentry_sdk.Hub.main.client is None
sdk_options = dict(settings.SENTRY_SDK_CONFIG)
relay_dsn = sdk_options.pop("relay_dsn", None)
internal_project_key = get_project_key()
upstream_dsn = sdk_options.pop("dsn", None)
if upstream_dsn:
upstream_transport = make_transport(
get_options(dsn=upstream_dsn, **sdk_options))
else:
upstream_transport = None
if relay_dsn:
relay_transport = make_transport(
get_options(dsn=relay_dsn, **sdk_options))
elif internal_project_key and internal_project_key.dsn_private:
relay_transport = make_transport(
get_options(dsn=internal_project_key.dsn_private, **sdk_options))
else:
relay_transport = None
class MultiplexingTransport(sentry_sdk.transport.Transport):
def capture_envelope(self, envelope):
# Assume only transactions get sent via envelopes
if options.get(
"transaction-events.force-disable-internal-project"):
return
self._capture_anything("capture_envelope", envelope)
def capture_event(self, event):
if event.get("type") == "transaction" and options.get(
"transaction-events.force-disable-internal-project"):
return
self._capture_anything("capture_event", event)
def _capture_anything(self, method_name, *args, **kwargs):
# Upstream should get the event first because it is most isolated from
# the this sentry installation.
if upstream_transport:
metrics.incr("internal.captured.events.upstream")
# TODO(mattrobenolt): Bring this back safely.
# from sentry import options
# install_id = options.get('sentry:install-id')
# if install_id:
# event.setdefault('tags', {})['install-id'] = install_id
getattr(upstream_transport, method_name)(*args, **kwargs)
if relay_transport and options.get(
"store.use-relay-dsn-sample-rate") == 1:
if is_current_event_safe():
metrics.incr("internal.captured.events.relay")
getattr(relay_transport, method_name)(*args, **kwargs)
else:
metrics.incr("internal.uncaptured.events.relay",
skip_internal=False)
sentry_sdk.init(transport=MultiplexingTransport(),
integrations=[
DjangoIntegration(),
CeleryIntegration(),
LoggingIntegration(event_level=None),
RustInfoIntegration(),
RedisIntegration(),
],
traceparent_v2=True,
**sdk_options)
