chore: switch back to integration objects

untitaker · untitaker · commit 673ebcf0f66c · 2018-07-27T09:46:07.000+02:00
diff --git a/sentry_sdk/client.py b/sentry_sdk/client.py
@@ -5,7 +5,6 @@
 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()
@@ -31,15 +30,8 @@ def __init__(self, dsn=None, *args, **kwargs):
             self._transport = Transport(dsn)
             self._transport.start()
 
-        integrations = options.get("integrations", ["logging"]) or ()
-        if not isinstance(integrations, dict):
-            integrations = {name: {} for name in integrations}
-
-        for name, options in integrations.items():
-            install_fn = get_integration(name)
-            if options is None:
-                options = {}
-            install_fn(self, **options)
+        for integration in options.get("integrations", ["logging"]) or ():
+            integration(self)
 
     @property
     def dsn(self):
diff --git a/sentry_sdk/integrations/__init__.py b/sentry_sdk/integrations/__init__.py
@@ -1,52 +1,31 @@
-_locked = False
-_integrations = {}
+from __future__ import print_function
 
+import sys
+from threading import Lock
 
-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
+_installer_lock = Lock()
+_installed_integrations = {}
 
 
-def get_integration(identifier):
-    global _locked
-    _locked = True
-    return _integrations[identifier]
+class Integration(object):
+    identifier = None
 
+    def __init__(self, **kwargs):
+        """Initialize an integration."""
+        raise NotImplementedError()
 
-@register_integration("django")
-def _django_integration(*a, **kw):
-    from .django import install
+    def install(self, client):
+        raise NotImplementedError()
 
-    return install(*a, **kw)
+    def __call__(self, client):
+        assert self.identifier
+        with _installer_lock:
+            if self.identifier in _installed_integrations:
+                print("warning: %s integration for Sentry is already "
+                      "configured. Will ignore second configuration." % self.identifier,
+                      file=sys.stderr)
+                return
 
-
-@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)
-
-
-@register_integration("logging")
-def _logging_integration(*a, **kw):
-    from .logging import install
-
-    return install(*a, **kw)
+            self.install(client)
+            _installed_integrations[self.identifier] = self
diff --git a/sentry_sdk/integrations/celery.py b/sentry_sdk/integrations/celery.py
@@ -1,44 +1,40 @@
 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
 from sentry_sdk.hub import _internal_exceptions
 
-
-_installer_lock = Lock()
-_installed = False
+from . import Integration
 
 
-def install(client):
-    global _installed
-    with _installer_lock:
-        if _installed:
-            return
+class CeleryIntegration(Integration):
+    identifier = 'celery'
 
-        task_prerun.connect(_handle_task_prerun, weak=False)
-        task_postrun.connect(_handle_task_postrun, weak=False)
-        task_failure.connect(_process_failure_signal, weak=False)
+    def __init__(self):
+        pass
 
-        _installed = True
+    def install(self, client):
+        task_prerun.connect(self._handle_task_prerun, weak=False)
+        task_postrun.connect(self._handle_task_postrun, weak=False)
+        task_failure.connect(self._process_failure_signal, weak=False)
 
 
-def _process_failure_signal(sender, task_id, einfo, **kw):
-    if hasattr(sender, "throws") and isinstance(einfo.exception, sender.throws):
-        return
+    def _process_failure_signal(self, sender, task_id, einfo, **kw):
+        if hasattr(sender, "throws") and isinstance(einfo.exception,
+                                                    sender.throws):
+            return
 
-    capture_exception(einfo.exc_info)
+        capture_exception(einfo.exc_info)
 
 
-def _handle_task_prerun(sender, task, **kw):
-    with _internal_exceptions():
-        get_current_hub().push_scope()
+    def _handle_task_prerun(self, sender, task, **kw):
+        with _internal_exceptions():
+            get_current_hub().push_scope()
 
-        with configure_scope() as scope:
-            scope.transaction = task.name
+            with configure_scope() as scope:
+                scope.transaction = task.name
 
 
-def _handle_task_postrun(sender, task_id, task, **kw):
-    get_current_hub().pop_scope_unsafe()
+    def _handle_task_postrun(self, sender, task_id, task, **kw):
+        get_current_hub().pop_scope_unsafe()
diff --git a/sentry_sdk/integrations/django.py b/sentry_sdk/integrations/django.py
@@ -1,7 +1,5 @@
 from __future__ import absolute_import
 
-from threading import Lock
-
 from django.core import signals
 
 try:
@@ -12,6 +10,50 @@
 from sentry_sdk import get_current_hub, configure_scope, capture_exception
 from sentry_sdk.hub import _internal_exceptions
 from ._wsgi import RequestExtractor
+from . import Integration
+
+
+class DjangoIntegration(Integration):
+    identifier = 'django'
+
+    def __init__(self):
+        pass
+
+    def install(self, client):
+        from django.core.handlers.base import BaseHandler
+
+        make_event_processor = self._make_event_processor
+
+        old_get_response = BaseHandler.get_response
+
+        def sentry_patched_get_response(self, request):
+            with get_current_hub().push_scope():
+                get_current_hub().add_event_processor(
+                    lambda: make_event_processor(request)
+                )
+
+                with configure_scope() as scope:
+                    scope.transaction = resolve(request.path).func.__name__
+
+                return old_get_response(self, request)
+
+        BaseHandler.get_response = sentry_patched_get_response
+
+        signals.got_request_exception.connect(_got_request_exception)
+
+    def _make_event_processor(self, request):
+        def processor(event):
+            with _internal_exceptions():
+                DjangoRequestExtractor(request).extract_into_event(event)
+
+            # TODO: user info
+
+        return processor
+
+
+def _got_request_exception(request=None, **kwargs):
+    capture_exception()
+
 
 
 class DjangoRequestExtractor(RequestExtractor):
@@ -41,52 +83,3 @@ def files(self):
 
     def size_of_file(self, file):
         return file.size
-
-
-_installer_lock = Lock()
-_installed = False
-
-
-def install(client):
-    global _installed
-    with _installer_lock:
-        if _installed:
-            return
-
-        _install_impl()
-        _installed = True
-
-
-def _install_impl():
-    from django.core.handlers.base import BaseHandler
-
-    old_get_response = BaseHandler.get_response
-
-    def sentry_patched_get_response(self, request):
-        with get_current_hub().push_scope():
-            get_current_hub().add_event_processor(
-                lambda: _make_event_processor(request)
-            )
-
-            with configure_scope() as scope:
-                scope.transaction = resolve(request.path).func.__name__
-
-            return old_get_response(self, request)
-
-    BaseHandler.get_response = sentry_patched_get_response
-
-    signals.got_request_exception.connect(_got_request_exception)
-
-
-def _make_event_processor(request):
-    def processor(event):
-        with _internal_exceptions():
-            DjangoRequestExtractor(request).extract_into_event(event)
-
-        # TODO: user info
-
-    return processor
-
-
-def _got_request_exception(request=None, **kwargs):
-    capture_exception()
diff --git a/sentry_sdk/integrations/flask.py b/sentry_sdk/integrations/flask.py
@@ -1,10 +1,9 @@
 from __future__ import absolute_import
 
-from threading import Lock
-
 from sentry_sdk import capture_exception, get_current_hub
 from sentry_sdk.hub import _internal_exceptions
 from ._wsgi import RequestExtractor
+from . import Integration
 
 try:
     from flask_login import current_user
@@ -19,22 +18,17 @@
 )
 
 
-_installer_lock = Lock()
-_installed = False
-
+class FlaskIntegration(Integration):
+    identifier = "flask"
 
-def install(client):
-    global _installed
-    with _installer_lock:
-        if _installed:
-            return
+    def __init__(self):
+        pass
 
+    def install(self, client):
         appcontext_pushed.connect(_push_appctx)
         appcontext_tearing_down.connect(_pop_appctx)
         got_request_exception.connect(_capture_exception)
 
-        _installed = True
-
 
 def _push_appctx(*args, **kwargs):
     get_current_hub().push_scope()
diff --git a/sentry_sdk/integrations/logging.py b/sentry_sdk/integrations/logging.py
@@ -3,37 +3,30 @@
 
 import sys
 import logging
-from threading import Lock
 
 from sentry_sdk import get_current_hub, capture_event, add_breadcrumb
 from sentry_sdk.utils import to_string, Event, skip_internal_frames
 from sentry_sdk.hub import _internal_exceptions
 
+from . import Integration
 
-_installer_lock = Lock()
-_installed = False
-_master_handler = None
 
+class LoggingIntegration(Integration):
+    identifier = 'logging'
+    def __init__(self, level=logging.INFO, event_level=None):
+        self._handler = SentryHandler(level=level, event_level=event_level)
 
-def install(client, level=logging.INFO, event_level=None):
-    global _installed
-    global _master_handler
-    with _installer_lock:
-        if _installed:
-            return
-
-        _master_handler = SentryHandler(level=level, event_level=event_level)
+    def install(self, client):
+        handler = self._handler
 
         old_callhandlers = logging.Logger.callHandlers
 
         def sentry_patched_callhandlers(self, record):
-            _master_handler.handle(record)
+            handler.handle(record)
             return old_callhandlers(self, record)
 
         logging.Logger.callHandlers = sentry_patched_callhandlers
 
-        _installed = True
-
 
 class SentryHandler(logging.Handler, object):
     def __init__(self, level, event_level):
diff --git a/tests/integrations/celery/test_celery.py b/tests/integrations/celery/test_celery.py
@@ -2,12 +2,14 @@
 
 pytest.importorskip("celery")
 
+from sentry_sdk.integrations.celery import CeleryIntegration
+
 from celery import Celery
 
 
 @pytest.fixture
 def celery(sentry_init):
-    sentry_init(integrations=["celery"])
+    sentry_init(integrations=[CeleryIntegration()])
     celery = Celery(__name__)
     celery.conf.CELERY_ALWAYS_EAGER = True
     return celery
diff --git a/tests/integrations/django/myapp/settings.py b/tests/integrations/django/myapp/settings.py
@@ -13,6 +13,8 @@
 import os
 import sentry_sdk
 
+from sentry_sdk.integrations.django import DjangoIntegration
+
 
 try:
     # Django >= 1.10
@@ -129,4 +131,6 @@ def process_response(self, request, response):
 
 STATIC_URL = "/static/"
 
-sentry_sdk.get_current_hub().bind_client(sentry_sdk.Client(integrations=["django"]))
+sentry_sdk.get_current_hub().bind_client(sentry_sdk.Client(integrations=[
+    DjangoIntegration()
+]))
diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py
diff --git a/tests/integrations/logging/test_logging.py b/tests/integrations/logging/test_logging.py
