feat: integration config draft

Author: untitaker

sentry_sdk/client.py

@@ -30,6 +30,11 @@ 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)
+
     @property
     def dsn(self):
         """The DSN that created this event."""

sentry_sdk/consts.py

@@ -9,6 +9,7 @@
     "environment": None,
     "server_name": DEFAULT_SERVER_NAME,
     "drain_timeout": 2.0,
+    "integrations": []
 }
 
 SDK_INFO = {"name": "sentry-python", "version": VERSION}

sentry_sdk/integrations/__init__.py

@@ -0,0 +1,27 @@
+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

sentry_sdk/integrations/django/__init__.py

@@ -10,8 +10,9 @@
 except ImportError:
     from django.core.urlresolvers import resolve
 
-from sentry_sdk import get_current_hub, configure_scope, capture_exception
+from sentry_sdk import get_current_hub, configure_scope, capture_exception, init
 from .._wsgi import RequestExtractor
+from .. import Integration
 
 
 try:
@@ -108,7 +109,16 @@ def _install():
     with _installer_lock:
         if _installed:
             return
-        _install_impl()
+
+        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)
         _installed = True
 
 
@@ -120,17 +130,24 @@ def _install_impl():
         middleware_attr = "MIDDLEWARE_CLASSES"
 
     # make sure to get an empty tuple when attr is None
-    middleware = getattr(settings, middleware_attr, ()) or ()
+    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] + list(middleware))
+    setattr(settings, middleware_attr, [MIDDLEWARE_NAME] + middleware)
 
     signals.request_finished.connect(_request_finished)
     signals.got_request_exception.connect(_got_request_exception)
 
 
+class DjangoIntegration(Integration):
+    identifier  = 'django'
+
+    def install(self, client):
+        _install_impl()
+
+
 try:
     # Django >= 1.7
     from django.apps import AppConfig

sentry_sdk/integrations/flask.py

@@ -1,7 +1,8 @@
 from __future__ import absolute_import
 
-from sentry_sdk import capture_exception, configure_scope, get_current_hub
+from sentry_sdk import capture_exception, configure_scope, get_current_hub, init
 from ._wsgi import RequestExtractor
+from . import Integration
 
 try:
     from flask_login import current_user
@@ -13,7 +14,7 @@
 
 
 class FlaskSentry(object):
-    def __init__(self, app=None, **options):
+    def __init__(self, app=None):
         self.app = app
         if app is not None:
             self.init_app(app, **options)
@@ -22,18 +23,33 @@ def init_app(self, app, setup_logger=True):
         if not hasattr(app, "extensions"):
             app.extensions = {}
         elif app.extensions.get(__name__, None):
-            raise RuntimeError("Sentry registration is already registered")
+            raise RuntimeError("Sentry extension is already registered")
         app.extensions[__name__] = True
 
-        appcontext_pushed.connect(self._push_appctx, sender=app)
-        app.teardown_appcontext(self._pop_appctx)
-        got_request_exception.connect(self._capture_exception, sender=app)
-        app.before_request(self._before_request)
+        client_options, integration_options = \
+            FlaskIntegration.parse_environment(app.config)
+        integration = FlaskIntegration(app, **integration_options)
+        client_options.setdefault('integrations', []).append(integration)
+        init(**client_options)
 
-        if setup_logger:
-            from .logging import HANDLER
 
-            app.logger.addHandler(HANDLER)
+class FlaskIntegration(Integration):
+    identifier = "flask"
+
+    def __init__(self, app, setup_logger=True):
+        self._app = app
+        self._setup_logger = setup_logger
+
+    def install(self, client=None):
+        appcontext_pushed.connect(self._push_appctx, sender=self._app)
+        self._app.teardown_appcontext(self._pop_appctx)
+        got_request_exception.connect(self._capture_exception,
+                                      sender=self._app)
+        self._app.before_request(self._before_request)
+
+        if self._setup_logger:
+            from .logging import HANDLER
+            self._app.logger.addHandler(HANDLER)
 
     def _push_appctx(self, *args, **kwargs):
         get_current_hub().push_scope()

sentry_sdk/transport.py

@@ -30,7 +30,7 @@ def _make_pool():
 
 
 def send_event(event, auth):
-    body = zlib.compress(json.dumps(event.get_json()).encode("utf-8"))
+    body = zlib.compress(json.dumps(event).encode("utf-8"))
     response = _pool.request(
         "POST",
         auth.store_api_url,

tests/integrations/conftest.py

@@ -5,15 +5,6 @@
 from sentry_sdk.client import Client, Transport
 
 
-class TestClient(Client):
-    def __init__(self):
-        pass
-
-    dsn = "LOL"
-    options = dict(DEFAULT_OPTIONS)
-    _transport = None
-
-
 class TestTransport(Transport):
     def __init__(self):
         pass
@@ -24,11 +15,20 @@ def start(self):
     def close(self):
         pass
 
+    def capture_event(self, event):
+        pass
+
+    dsn = 'LOL'
 
-test_client = TestClient()
 
-sentry_sdk.init()
-sentry_sdk.get_current_hub().bind_client(test_client)
+@pytest.fixture(autouse=True)
+def test_client():
+    client = sentry_sdk.get_current_hub().client
+    if not client:
+        client = Client()
+        sentry_sdk.get_current_hub().bind_client(client)
+    client._transport = TestTransport()
+    return client
 
 
 @pytest.fixture(autouse=True)
@@ -57,7 +57,7 @@ def capture_exception(error=None):
 
 
 @pytest.fixture
-def capture_events(monkeypatch):
+def capture_events(test_client, monkeypatch):
     events = []
     monkeypatch.setattr(test_client, "_transport", TestTransport())
     monkeypatch.setattr(test_client._transport, "capture_event", events.append)

tests/integrations/django/myapp/settings.py

@@ -31,6 +31,8 @@
 # SECURITY WARNING: keep the secret key used in production secret!
 SECRET_KEY = "u95e#xr$t3!vdux)fj11!*q*^w^^r#kiyrvt3kjui-t_k%m3op"
 
+SENTRY_FOO = 'yes'
+
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = True