chore: change how integrations are initialized

Author: untitaker

docs/flask.md

@@ -5,6 +5,7 @@
 from .transport import Transport
 from .consts import DEFAULT_OPTIONS, SDK_INFO
 from .stripping import strip_event, flatten_metadata
+from .integrations import get_integration
 
 
 NO_DSN = object()
@@ -30,12 +31,10 @@ def __init__(self, dsn=None, *args, **kwargs):
             self._transport = Transport(dsn)
             self._transport.start()
 
-        for integration in options.get("integrations", None) or ():
-            assert integration.identifier, "identifier of integration must be set"
-            assert isinstance(
-                integration.identifier, str
-            ), "identifier of integration must be a string"
-            integration.install(self)
+        for install_fn in options.get("integrations", None) or ():
+            if isinstance(install_fn, str):
+                install_fn = get_integration(install_fn)
+            install_fn(self)
 
     @property
     def dsn(self):

sentry_sdk/client.py

@@ -165,7 +165,9 @@ def pop_scope_unsafe(self):
         """Pops a scope layer from the stack. Try to use the context manager
         `push_scope()` instead."""
         self._pending_processors = []
-        return self._stack.pop()
+        rv = self._stack.pop()
+        assert self._stack
+        return rv
 
     @contextmanager
     def configure_scope(self):

sentry_sdk/hub.py

@@ -1,27 +1,40 @@
-class Integration(object):
-    """
-    A interface with an install hook for integrations to patch themselves
-    into their environment. Integrations don't really *need* to use this hook
-    if the idiomatic control flow of some framework mandates otherwise.
-    """
-
-    identifier = None
-
-    def install(self, client):
-        pass
-
-    @classmethod
-    def parse_environment(cls, environ):
-        client_options = {}
-        integration_options = {}
-        for key, value in environ.items():
-            if not key.startswith("SENTRY_"):
-                continue
-            key = key[len("SENTRY_") :].replace("-", "_").lower()
-            identifier_prefix = "%s_" % cls.identifier
-            if key.startswith(identifier_prefix):
-                integration_options[key[len(identifier_prefix) :]] = value
-            else:
-                client_options[key] = value
-
-        return client_options, integration_options
+_locked = False
+_integrations = {}
+
+
+def register_integration(identifier, integration=None):
+    def inner(integration):
+        if _locked:
+            raise ValueError("A client has already been initialized. "
+                             "Registration of integrations no longer possible")
+        if identifier in _integrations:
+            raise ValueError("Integration with that name already exists.")
+        _integrations[identifier] = integration
+
+    if integration is not None:
+        return inner(integration)
+    return inner
+
+
+def get_integration(identifier):
+    global _locked
+    _locked = True
+    return _integrations[identifier]
+
+
+@register_integration('django')
+def _django_integration(*a, **kw):
+    from .django import install
+    return install(*a, **kw)
+
+
+@register_integration('flask')
+def _flask_integration(*a, **kw):
+    from .flask import install
+    return install(*a, **kw)
+
+
+@register_integration('celery')
+def _celery_integration(*a, **kw):
+    from .celery import install
+    return install(*a, **kw)

sentry_sdk/integrations/__init__.py

@@ -1,14 +1,27 @@
 from __future__ import absolute_import
 
+from threading import Lock
+
 from celery.signals import task_failure, task_prerun, task_postrun
 
 from sentry_sdk import get_current_hub, configure_scope, capture_exception
 
 
-def install():
-    task_prerun.connect(_handle_task_prerun, weak=False)
-    task_postrun.connect(_handle_task_postrun, weak=False)
-    task_failure.connect(_process_failure_signal, weak=False)
+_installer_lock = Lock()
+_installed = False
+
+
+def install(client):
+    global _installed
+    with _installer_lock:
+        if _installed:
+            return
+
+        task_prerun.connect(_handle_task_prerun, weak=False)
+        task_postrun.connect(_handle_task_postrun, weak=False)
+        task_failure.connect(_process_failure_signal, weak=False)
+
+        _installed = True
 
 
 def _process_failure_signal(sender, task_id, einfo, **kw):

sentry_sdk/integrations/celery.py

@@ -12,7 +12,6 @@
 
 from sentry_sdk import get_current_hub, configure_scope, capture_exception, init
 from .._wsgi import RequestExtractor
-from .. import Integration
 
 
 try:
@@ -93,74 +92,54 @@ def _got_request_exception(request=None, **kwargs):
     capture_exception()
 
 
-MIDDLEWARE_NAME = "sentry_sdk.integrations.django.SentryMiddleware"
-
-CONFLICTING_MIDDLEWARE = (
-    "raven.contrib.django.middleware.SentryMiddleware",
-    "raven.contrib.django.middleware.SentryLogMiddleware",
-) + (MIDDLEWARE_NAME,)
+MIDDLEWARE_NAME = __name__ + ".SentryMiddleware"
 
 _installer_lock = Lock()
 _installed = False
 
 
-def _install():
+def install(client):
     global _installed
     with _installer_lock:
         if _installed:
             return
 
-        client_options, integration_options = DjangoIntegration.parse_environment(
-            dict((key, getattr(settings, key)) for key in dir(settings))
-        )
-
-        client_options.setdefault("integrations", []).append(
-            DjangoIntegration(**integration_options)
-        )
-
-        init(**client_options)
+        _install_impl()
         _installed = True
 
 
 def _install_impl():
-    # default settings.MIDDLEWARE is None
-    if getattr(settings, "MIDDLEWARE", None):
-        middleware_attr = "MIDDLEWARE"
-    else:
-        middleware_attr = "MIDDLEWARE_CLASSES"
+    old_getattr = settings.__getattr__
 
-    # make sure to get an empty tuple when attr is None
-    middleware = list(getattr(settings, middleware_attr, ()) or ())
-    conflicts = set(CONFLICTING_MIDDLEWARE).intersection(set(middleware))
-    if conflicts:
-        raise RuntimeError("Other sentry-middleware already registered: %s" % conflicts)
-
-    setattr(settings, middleware_attr, [MIDDLEWARE_NAME] + middleware)
-
-    signals.request_finished.connect(_request_finished)
-    signals.got_request_exception.connect(_got_request_exception)
+    # When `sentry_sdk.init` is called, the settings object may or may not be
+    # initialized. So we need to lazily merge the array values.
 
+    def sentry_patched_getattr(self, key):
+        if key in ("MIDDLEWARE", "MIDDLEWARE_CLASSES"):
+            try:
+                rv = old_getattr(key)
+            except AttributeError:
+                rv = []
 
-class DjangoIntegration(Integration):
-    identifier = "django"
 
-    def install(self, client):
-        _install_impl()
+            rv = type(rv)([MIDDLEWARE_NAME]) + rv
+        elif key == "INSTALLED_APPS":
+            try:
+                rv = old_getattr(key)
+            except AttributeError:
+                rv = []
 
+            rv = type(rv)([__name__]) + rv
+        else:
+            rv = old_getattr(key)
 
-try:
-    # Django >= 1.7
-    from django.apps import AppConfig
-except ImportError:
-    _install()
-else:
+        # fix cache set by old_getattr
+        if key in self.__dict__:
+            self.__dict__[key] = rv
+        return rv
 
-    class SentryConfig(AppConfig):
-        name = "sentry_sdk.integrations.django"
-        label = "sentry_sdk_integrations_django"
-        verbose_name = "Sentry"
 
-        def ready(self):
-            _install()
+    type(settings).__getattr__ = sentry_patched_getattr
 
-    default_app_config = "sentry_sdk.integrations.django.SentryConfig"
+    signals.request_finished.connect(_request_finished)
+    signals.got_request_exception.connect(_got_request_exception)