fix(django): restore process_exception to capture view exceptions

Restores the process_exception method that was removed in v6.7.5 (PR #328),
which broke exception capture from Django views and downstream middleware.

Django converts view exceptions into responses before they propagate through
the middleware stack's __call__ method, so the context manager's exception
handler never sees them. Django provides these exceptions via the
process_exception hook instead.

Changes:
- Add process_exception method to capture exceptions from views and downstream
  middleware with proper request context and tags
- Add tests verifying process_exception behavior and settings (capture_exceptions,
  request_filter)
- Update version to 6.7.11
- Update CHANGELOG to accurately reflect the fix

Context:
- v6.7.4 and earlier: no process_exception - exceptions not captured (#286)
- v6.7.4 fix: added process_exception - worked correctly
- v6.7.5 (PR #328): removed process_exception when adding async - broke again (#329)
- v6.7.10 (PR #348): attempted fix but didn't restore process_exception - still broken
- v6.7.11 (this fix): restores process_exception - fixes #329

Fixes #329

Author: webjunkie

CHANGELOG.md

@@ -1,7 +1,11 @@
+# 6.7.11 - 2025-10-24
+
+- fix(django): Restore process_exception method to capture view and downstream middleware exceptions (fixes #329)
+
 # 6.7.10 - 2025-10-24
 
 - fix(django): Make middleware truly hybrid - compatible with both sync (WSGI) and async (ASGI) Django stacks without breaking sync-only deployments
-- fix(django): Exception capture works correctly via context manager (addresses #329)
+- Note: v6.7.10 did not fully fix exception capture - see v6.7.11
 
 # 6.7.9 - 2025-10-22
 

posthog/integrations/django.py

@@ -220,3 +220,33 @@ async def __acall__(self, request):
                 contexts.tag(k, v)
 
             return await self.get_response(request)
+
+    def process_exception(self, request, exception):
+        # type: (HttpRequest, Exception) -> None
+        """
+        Process exceptions from views and downstream middleware.
+
+        Django converts view exceptions into responses before they propagate through
+        the middleware stack, so the context manager in __call__ never sees them.
+        This method is called by Django's exception handling to provide middleware
+        access to exceptions.
+
+        Note: Django's process_exception is always synchronous, even for async views.
+        """
+        if self.request_filter and not self.request_filter(request):
+            return
+
+        if not self.capture_exceptions:
+            return
+
+        # Create context with request tags for exception capture
+        with contexts.new_context(self.capture_exceptions, client=self.client):
+            for k, v in self.extract_tags(request).items():
+                contexts.tag(k, v)
+
+            # Capture exception with context tags
+            if self.client:
+                self.client.capture_exception(exception)
+            else:
+                from posthog import capture_exception
+                capture_exception(exception)

posthog/test/integrations/test_middleware.py

@@ -276,6 +276,59 @@ def raise_exception(request):
         self.assertIsInstance(captured_exception, ValueError)
         self.assertEqual(str(captured_exception), "Test exception")
 
+    def test_process_exception_captures_view_exceptions(self):
+        """Test that process_exception captures exceptions from views"""
+        mock_client = Mock()
+
+        get_response = Mock(return_value=Mock())
+        middleware = PosthogContextMiddleware(get_response)
+        middleware.client = mock_client
+
+        request = MockRequest()
+        exception = ValueError("View exception")
+
+        # Call process_exception directly (Django does this)
+        middleware.process_exception(request, exception)
+
+        # Verify exception was captured
+        mock_client.capture_exception.assert_called_once_with(exception)
+
+    def test_process_exception_respects_capture_exceptions_setting(self):
+        """Test that process_exception respects POSTHOG_MW_CAPTURE_EXCEPTIONS=False"""
+        mock_client = Mock()
+
+        get_response = Mock(return_value=Mock())
+        middleware = PosthogContextMiddleware(get_response)
+        middleware.client = mock_client
+        middleware.capture_exceptions = False
+
+        request = MockRequest()
+        exception = ValueError("View exception")
+
+        # Call process_exception
+        middleware.process_exception(request, exception)
+
+        # Should NOT capture when disabled
+        mock_client.capture_exception.assert_not_called()
+
+    def test_process_exception_respects_request_filter(self):
+        """Test that process_exception respects request filter"""
+        mock_client = Mock()
+
+        get_response = Mock(return_value=Mock())
+        middleware = PosthogContextMiddleware(get_response)
+        middleware.client = mock_client
+        middleware.request_filter = lambda req: False  # Filter out all requests
+
+        request = MockRequest()
+        exception = ValueError("View exception")
+
+        # Call process_exception
+        middleware.process_exception(request, exception)
+
+        # Should NOT capture when filtered
+        mock_client.capture_exception.assert_not_called()
+
 
 class TestPosthogContextMiddlewareAsync(unittest.TestCase):
     """Test asynchronous middleware behavior"""

posthog/version.py

@@ -1,4 +1,4 @@
-VERSION = "6.7.10"
+VERSION = "6.7.11"
 
 if __name__ == "__main__":
     print(VERSION, end="")  # noqa: T201