feat: Automatically instrument ASGI HTTP requests in Django Channels (#496)

* feat: Automatically instrument ASGI HTTP requests in Django Channels

* fix: Add mitigation for potential source of memory leaks

* fix: Prevent double-applying of asgi/wsgi middleware

Author: untitaker

sentry_sdk/integrations/asgi.py

@@ -10,10 +10,27 @@
 from sentry_sdk._types import MYPY
 from sentry_sdk.hub import Hub, _should_send_default_pii
 from sentry_sdk.integrations._wsgi_common import _filter_headers
-from sentry_sdk.utils import transaction_from_function
+from sentry_sdk.utils import ContextVar, event_from_exception, transaction_from_function
 
 if MYPY:
     from typing import Dict
+    from typing import Any
+
+
+_asgi_middleware_applied = ContextVar("sentry_asgi_middleware_applied")
+
+
+def _capture_exception(hub, exc):
+    # type: (Hub, Any) -> None
+
+    # Check client here as it might have been unset while streaming response
+    if hub.client is not None:
+        event, hint = event_from_exception(
+            exc,
+            client_options=hub.client.options,
+            mechanism={"type": "asgi", "handled": False},
+        )
+        hub.capture_event(event, hint=hint)
 
 
 class SentryAsgiMiddleware:
@@ -35,20 +52,31 @@ async def run_asgi2(receive, send):
             return self._run_app(scope, lambda: self.app(scope, receive, send))
 
     async def _run_app(self, scope, callback):
-        hub = Hub.current
-        with Hub(hub) as hub:
-            with hub.configure_scope() as sentry_scope:
-                sentry_scope._name = "asgi"
-                sentry_scope.transaction = scope.get("path") or "unknown asgi request"
-
-                processor = functools.partial(self.event_processor, asgi_scope=scope)
-                sentry_scope.add_event_processor(processor)
-
-            try:
-                await callback()
-            except Exception as exc:
-                hub.capture_exception(exc)
-                raise exc from None
+        if _asgi_middleware_applied.get(False):
+            return await callback()
+
+        _asgi_middleware_applied.set(True)
+        try:
+            hub = Hub(Hub.current)
+            with hub:
+                with hub.configure_scope() as sentry_scope:
+                    sentry_scope._name = "asgi"
+                    sentry_scope.transaction = (
+                        scope.get("path") or "unknown asgi request"
+                    )
+
+                    processor = functools.partial(
+                        self.event_processor, asgi_scope=scope
+                    )
+                    sentry_scope.add_event_processor(processor)
+
+                try:
+                    await callback()
+                except Exception as exc:
+                    _capture_exception(hub, exc)
+                    raise exc from None
+        finally:
+            _asgi_middleware_applied.set(False)
 
     def event_processor(self, event, hint, asgi_scope):
         request_info = event.setdefault("request", {})

sentry_sdk/integrations/django/__init__.py

@@ -9,6 +9,7 @@
 from django.core import signals  # type: ignore
 
 from sentry_sdk._types import MYPY
+from sentry_sdk.utils import HAS_REAL_CONTEXTVARS
 
 if MYPY:
     from typing import Any
@@ -101,9 +102,9 @@ def sentry_patched_wsgi_handler(self, environ, start_response):
             if Hub.current.get_integration(DjangoIntegration) is None:
                 return old_app(self, environ, start_response)
 
-            return SentryWsgiMiddleware(lambda *a, **kw: old_app(self, *a, **kw))(
-                environ, start_response
-            )
+            bound_old_app = old_app.__get__(self, WSGIHandler)
+
+            return SentryWsgiMiddleware(bound_old_app)(environ, start_response)
 
         WSGIHandler.__call__ = sentry_patched_wsgi_handler
 
@@ -211,6 +212,7 @@ def _django_queryset_repr(value, hint):
                 id(value),
             )
 
+        _patch_channels()
         patch_django_middlewares()
 
 
@@ -271,6 +273,38 @@ def sentry_patched_drf_initial(self, request, *args, **kwargs):
                 APIView.initial = sentry_patched_drf_initial
 
 
+def _patch_channels():
+    try:
+        from channels.http import AsgiHandler  # type: ignore
+    except ImportError:
+        return
+
+    if not HAS_REAL_CONTEXTVARS:
+        # We better have contextvars or we're going to leak state between
+        # requests.
+        raise RuntimeError(
+            "We detected that you are using Django channels 2.0. To get proper "
+            "instrumentation for ASGI requests, the Sentry SDK requires "
+            "Python 3.7+ or the aiocontextvars package from PyPI."
+        )
+
+    from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
+
+    old_app = AsgiHandler.__call__
+
+    def sentry_patched_asgi_handler(self, receive, send):
+        if Hub.current.get_integration(DjangoIntegration) is None:
+            return old_app(receive, send)
+
+        middleware = SentryAsgiMiddleware(
+            lambda _scope: old_app.__get__(self, AsgiHandler)
+        )
+
+        return middleware(self.scope)(receive, send)
+
+    AsgiHandler.__call__ = sentry_patched_asgi_handler
+
+
 def _make_event_processor(weak_request, integration):
     # type: (Callable[[], WSGIRequest], DjangoIntegration) -> Callable
     def event_processor(event, hint):

sentry_sdk/integrations/wsgi.py

@@ -2,7 +2,11 @@
 import sys
 
 from sentry_sdk.hub import Hub, _should_send_default_pii
-from sentry_sdk.utils import capture_internal_exceptions, event_from_exception
+from sentry_sdk.utils import (
+    ContextVar,
+    capture_internal_exceptions,
+    event_from_exception,
+)
 from sentry_sdk._compat import PY2, reraise, iteritems
 from sentry_sdk.tracing import Span
 from sentry_sdk.integrations._wsgi_common import _filter_headers
@@ -26,6 +30,9 @@
     E = TypeVar("E")
 
 
+_wsgi_middleware_applied = ContextVar("sentry_wsgi_middleware_applied")
+
+
 if PY2:
 
     def wsgi_decoding_dance(s, charset="utf-8", errors="replace"):
@@ -83,27 +90,36 @@ def __init__(self, app):
 
     def __call__(self, environ, start_response):
         # type: (Dict[str, str], Callable) -> _ScopedResponse
-        hub = Hub(Hub.current)
-
-        with hub:
-            with capture_internal_exceptions():
-                with hub.configure_scope() as scope:
-                    scope.clear_breadcrumbs()
-                    scope._name = "wsgi"
-                    scope.add_event_processor(_make_wsgi_event_processor(environ))
-
-            span = Span.continue_from_environ(environ)
-            span.op = "http.server"
-            span.transaction = "generic WSGI request"
-
-            with hub.start_span(span) as span:
-                try:
-                    rv = self.app(
-                        environ,
-                        functools.partial(_sentry_start_response, start_response, span),
-                    )
-                except BaseException:
-                    reraise(*_capture_exception(hub))
+        if _wsgi_middleware_applied.get(False):
+            return self.app(environ, start_response)
+
+        _wsgi_middleware_applied.set(True)
+        try:
+            hub = Hub(Hub.current)
+
+            with hub:
+                with capture_internal_exceptions():
+                    with hub.configure_scope() as scope:
+                        scope.clear_breadcrumbs()
+                        scope._name = "wsgi"
+                        scope.add_event_processor(_make_wsgi_event_processor(environ))
+
+                span = Span.continue_from_environ(environ)
+                span.op = "http.server"
+                span.transaction = "generic WSGI request"
+
+                with hub.start_span(span) as span:
+                    try:
+                        rv = self.app(
+                            environ,
+                            functools.partial(
+                                _sentry_start_response, start_response, span
+                            ),
+                        )
+                    except BaseException:
+                        reraise(*_capture_exception(hub))
+        finally:
+            _wsgi_middleware_applied.set(False)
 
         return _ScopedResponse(hub, rv)
 

sentry_sdk/scope.py

@@ -195,6 +195,13 @@ def add_event_processor(
 
         :param func: This function behaves like `before_send.`
         """
+        if len(self._event_processors) > 20:
+            logger.warning(
+                "Too many event processors on scope! Clearing list to free up some memory: %r",
+                self._event_processors,
+            )
+            del self._event_processors[:]
+
         self._event_processors.append(func)
 
     def add_error_processor(

tests/integrations/django/channels/test_channels.py

@@ -3,6 +3,7 @@
 
 from channels.testing import HttpCommunicator
 
+from sentry_sdk import capture_message
 from sentry_sdk.integrations.django import DjangoIntegration
 
 from tests.integrations.django.myapp.asgi import application
@@ -32,3 +33,7 @@ async def test_basic(sentry_init, capture_events):
         "query_string": "test=query",
         "url": "/view-exc",
     }
+
+    capture_message("hi")
+    event = events[-1]
+    assert "request" not in event

tests/integrations/django/myapp/asgi.py

@@ -12,8 +12,4 @@
 )
 
 django.setup()
-
-from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
-
 application = get_default_application()
-application = SentryAsgiMiddleware(application)