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)