fix event recursion (#210)

* reproduce infinite recursion between integrations

* avoid creating new events while processing one

* fix a bug in older pyramid versions getting authenticated_userid

* blackify

* add comment

* use a decorator to pull out logic

* fix: Formatting

Author: mmerickel

sentry_sdk/client.py

@@ -156,6 +156,9 @@ def _is_ignored_error(self, event, hint=None):
         return False
 
     def _should_capture(self, event, hint, scope=None):
+        if scope is not None and not scope._should_capture:
+            return False
+
         if (
             self.options["sample_rate"] < 1.0
             and random.random() >= self.options["sample_rate"]

sentry_sdk/integrations/pyramid.py

@@ -5,6 +5,7 @@
 import weakref
 
 from pyramid.httpexceptions import HTTPException
+from pyramid.request import Request
 
 from sentry_sdk.hub import Hub, _should_send_default_pii
 from sentry_sdk.utils import capture_internal_exceptions, event_from_exception
@@ -15,6 +16,17 @@
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 
 
+if getattr(Request, "authenticated_userid", None):
+
+    def authenticated_userid(request):
+        return request.authenticated_userid
+
+
+else:
+    # bw-compat for pyramid < 1.5
+    from pyramid.security import authenticated_userid
+
+
 class PyramidIntegration(Integration):
     identifier = "pyramid"
 
@@ -142,7 +154,7 @@ def event_processor(event, hint):
             with capture_internal_exceptions():
                 user_info = event.setdefault("user", {})
                 if "id" not in user_info:
-                    user_info["id"] = request.authenticated_userid
+                    user_info["id"] = authenticated_userid(request)
 
         return event
 

sentry_sdk/scope.py

@@ -1,5 +1,6 @@
 from copy import copy
 from collections import deque
+from functools import wraps
 from itertools import chain
 
 from sentry_sdk.utils import logger, capture_internal_exceptions
@@ -16,6 +17,20 @@ def _attr_setter(fn):
     return property(fset=fn, doc=fn.__doc__)
 
 
+def _disable_capture(fn):
+    @wraps(fn)
+    def wrapper(self, *args, **kwargs):
+        if not self._should_capture:
+            return
+        try:
+            self._should_capture = False
+            return fn(self, *args, **kwargs)
+        finally:
+            self._should_capture = True
+
+    return wrapper
+
+
 class Scope(object):
     """The scope holds extra information that should be sent with all
     events that belong to it.
@@ -33,6 +48,7 @@ class Scope(object):
         "_breadcrumbs",
         "_event_processors",
         "_error_processors",
+        "_should_capture",
     )
 
     def __init__(self):
@@ -99,6 +115,8 @@ def clear(self):
 
         self._breadcrumbs = deque()
 
+        self._should_capture = True
+
     def add_event_processor(self, func):
         """"Register a scope local event processor on the scope.
 
@@ -126,6 +144,7 @@ def func(event, exc_info):
 
         self._error_processors.append(func)
 
+    @_disable_capture
     def apply_to_event(self, event, hint=None):
         """Applies the information contained on the scope to the given event."""
 
@@ -189,6 +208,8 @@ def __copy__(self):
         rv._event_processors = list(self._event_processors)
         rv._error_processors = list(self._error_processors)
 
+        rv._should_capture = self._should_capture
+
         return rv
 
     def __repr__(self):

tests/integrations/pyramid/test_pyramid.py

@@ -2,8 +2,11 @@
 
 from io import BytesIO
 
+import logging
+
 import pytest
 
+from pyramid.authorization import ACLAuthorizationPolicy
 import pyramid.testing
 
 from pyramid.response import Response
@@ -239,3 +242,32 @@ def error_handler(err, request):
 
     exception, = event2["exception"]["values"]
     assert exception["type"] == "ZeroDivisionError"
+
+
+def test_error_in_authenticated_userid(
+    sentry_init, pyramid_config, capture_events, route, get_client
+):
+    from sentry_sdk.integrations.logging import LoggingIntegration
+
+    sentry_init(
+        send_default_pii=True,
+        integrations=[
+            PyramidIntegration(),
+            LoggingIntegration(event_level=logging.ERROR),
+        ],
+    )
+    logger = logging.getLogger("test_pyramid")
+
+    class AuthenticationPolicy(object):
+        def authenticated_userid(self, request):
+            logger.error("failed to identify user")
+
+    pyramid_config.set_authorization_policy(ACLAuthorizationPolicy())
+    pyramid_config.set_authentication_policy(AuthenticationPolicy())
+
+    events = capture_events()
+
+    client = get_client()
+    client.get("/message")
+
+    assert len(events) == 1