feat: deduplication of exceptions

Author: untitaker

sentry_sdk/client.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 
-from .utils import Dsn
+from .utils import Dsn, SkipEvent
 from .transport import Transport
 from .consts import DEFAULT_OPTIONS, SDK_INFO
 from .stripping import strip_event, flatten_metadata
@@ -65,7 +65,10 @@ def capture_event(self, event, scope=None):
         """Captures an event."""
         if self._transport is None:
             return
-        event = self._prepare_event(event, scope)
+        try:
+            event = self._prepare_event(event, scope)
+        except SkipEvent:
+            return
         self._transport.capture_event(event)
 
     def drain_events(self, timeout=None):

sentry_sdk/hub.py

@@ -4,12 +4,7 @@
 
 from ._compat import with_metaclass
 from .scope import Scope
-from .utils import (
-    exceptions_from_error_tuple,
-    create_event,
-    skip_internal_frames,
-    ContextVar,
-)
+from .utils import Event, skip_internal_frames, ContextVar, DefaultEventProcessor
 
 
 _local = ContextVar("sentry_current_hub")
@@ -99,7 +94,7 @@ def capture_message(self, message, level=None):
             return
         if level is None:
             level = "info"
-        event = create_event()
+        event = Event()
         event["message"] = message
         if level is not None:
             event["level"] = level
@@ -129,13 +124,9 @@ def capture_exception(self, error=None):
         if tb is not None:
             tb = skip_internal_frames(tb)
 
-        event = create_event()
+        event = Event()
         try:
-            event["exception"] = {
-                "values": exceptions_from_error_tuple(
-                    exc_type, exc_value, tb, client.options["with_locals"]
-                )
-            }
+            event.set_exception(exc_type, exc_value, tb, client.options["with_locals"])
             return self.capture_event(event)
         except Exception:
             self.capture_internal_exception()
@@ -159,8 +150,7 @@ def add_breadcrumb(self, crumb):
 
     def add_event_processor(self, factory):
         """Registers a new event processor with the top scope."""
-        if self._stack[1][0] is not None:
-            self._pending_processors.append(factory)
+        self._pending_processors.append(factory)
 
     def push_scope(self):
         """Pushes a new layer on the scope stack. Returns a context manager
@@ -191,3 +181,4 @@ def _flush_event_processors(self):
 
 
 GLOBAL_HUB = Hub()
+GLOBAL_HUB.add_event_processor(DefaultEventProcessor)

sentry_sdk/integrations/flask.py

@@ -13,12 +13,12 @@
 
 
 class FlaskSentry(object):
-    def __init__(self, app=None):
+    def __init__(self, app=None, **options):
         self.app = app
         if app is not None:
-            self.init_app(app)
+            self.init_app(app, **options)
 
-    def init_app(self, app):
+    def init_app(self, app, setup_logger=True):
         if not hasattr(app, "extensions"):
             app.extensions = {}
         elif app.extensions.get(__name__, None):
@@ -30,6 +30,11 @@ def init_app(self, app):
         got_request_exception.connect(self._capture_exception, sender=app)
         app.before_request(self._before_request)
 
+        if setup_logger:
+            from .logging import HANDLER
+
+            app.logger.addHandler(HANDLER)
+
     def _push_appctx(self, *args, **kwargs):
         get_current_hub().push_scope()
         _app_ctx_stack.top._sentry_app_scope_pushed = True

sentry_sdk/integrations/logging.py

@@ -5,12 +5,7 @@
 import logging
 
 from sentry_sdk import get_current_hub, capture_event, add_breadcrumb
-from sentry_sdk.utils import (
-    to_string,
-    create_event,
-    exceptions_from_error_tuple,
-    skip_internal_frames,
-)
+from sentry_sdk.utils import to_string, Event, skip_internal_frames
 
 
 class SentryHandler(logging.Handler, object):
@@ -35,19 +30,19 @@ def _breadcrumb_from_record(self, record):
     def _emit(self, record):
         add_breadcrumb(self._breadcrumb_from_record(record))
 
-        if not self._should_create_event(record):
+        if not self._should_Event(record):
             return
 
         if not self.can_record(record):
             print(to_string(record.message), file=sys.stderr)
             return
 
-        event = create_event()
+        event = Event()
 
         # exc_info might be None or (None, None, None)
         if record.exc_info and all(record.exc_info):
             exc_type, exc_value, tb = record.exc_info
-            event["exception"] = exceptions_from_error_tuple(
+            event.set_exception(
                 exc_type,
                 exc_value,
                 skip_internal_frames(tb),
@@ -64,7 +59,7 @@ def _emit(self, record):
     def _logging_to_event_level(self, levelname):
         return {"critical": "fatal"}.get(levelname.lower(), levelname.lower())
 
-    def _should_create_event(self, record):
+    def _should_Event(self, record):
         # TODO: make configurable
         if record.levelno in (logging.ERROR, logging.CRITICAL):
             return True

sentry_sdk/transport.py

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

sentry_sdk/utils.py

@@ -240,10 +240,10 @@ def safe_repr(value):
 def object_to_json(obj):
     def _walk(obj, depth):
         if depth < 4:
-            if isinstance(obj, Sequence):
+            if isinstance(obj, Sequence) and not isinstance(obj, (bytes, text_type)):
                 return [_walk(x, depth + 1) for x in obj]
             if isinstance(obj, Mapping):
-                return {safe_repr(k): _walk(v, depth + 1) for k, v in obj.items()}
+                return {safe_str(k): _walk(v, depth + 1) for k, v in obj.items()}
         return safe_repr(obj)
 
     return _walk(obj, 0)
@@ -315,12 +315,63 @@ def exceptions_from_error_tuple(exc_type, exc_value, tb, with_locals=True):
     return rv
 
 
-def create_event():
-    return {
-        "event_id": uuid.uuid4().hex,
-        "timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "level": "error",
-    }
+class Event(Mapping):
+    __slots__ = ("_data", "_exc_value")
+
+    def __init__(self):
+        self._data = {
+            "event_id": uuid.uuid4().hex,
+            "timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "level": "error",
+        }
+        self._exc_value = None
+
+    def get_json(self):
+        return self._data
+
+    def set_exception(self, exc_type, exc_value, tb, with_locals):
+        self["exception"] = {
+            "values": exceptions_from_error_tuple(exc_type, exc_value, tb, with_locals)
+        }
+        self._exc_value = exc_value
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def get(self, *a, **kw):
+        return self._data.get(*a, **kw)
+
+    def setdefault(self, *a, **kw):
+        return self._data.setdefault(*a, **kw)
+
+    def __setitem__(self, key, value):
+        self._data[key] = value
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
+
+
+class DefaultEventProcessor(object):
+    def __init__(self):
+        self._most_recent_exception = None
+
+    def __call__(self, event):
+        if event._exc_value is None:
+            return
+        if self._most_recent_exception is event._exc_value:
+            raise SkipEvent()
+        self._most_recent_exception = event._exc_value
+
+
+class SkipEvent(Exception):
+    """Risen from an event processor to indicate that the event should be
+    ignored and not be reported."""
 
 
 def to_string(value):

tests/integrations/flask/test_flask.py

@@ -1,5 +1,6 @@
 import json
 import pytest
+import logging
 
 from io import BytesIO
 
@@ -21,6 +22,7 @@ def app():
     app = Flask(__name__)
     app.config["TESTING"] = True
     app.secret_key = "haha"
+    app.logger.setLevel(logging.DEBUG)
 
     login_manager.init_app(app)
 
@@ -249,3 +251,19 @@ def index():
         "": {"len": 0, "rem": [["!filecontent", "x", 0, 0]]}
     }
     assert not event["request"]["data"]["file"]
+
+
+def test_errors_not_reported_twice(capture_events, app):
+    @app.route("/")
+    def index():
+        try:
+            1 / 0
+        except Exception as e:
+            app.logger.exception(e)
+            raise e
+
+    client = app.test_client()
+    with pytest.raises(ZeroDivisionError):
+        client.get("/")
+
+    assert len(capture_events) == 1