feat: Added event hints and better exception handling

Author: mitsuhiko

sentry_sdk/api.py

@@ -1,4 +1,5 @@
 from .hub import Hub
+from .utils import EventHint
 from .client import Client, get_options
 from .integrations import setup_integrations
 
@@ -38,11 +39,7 @@ def _init_on_current(*args, **kwargs):
 
 
 from . import minimal as sentry_minimal
+from .minimal import *  # noqa
 
-__all__ = ["Hub", "Scope", "Client", "init"] + sentry_minimal.__all__
-
-
-for _key in sentry_minimal.__all__:
-    globals()[_key] = getattr(sentry_minimal, _key)
-    globals()[_key].__module__ = __name__
-del _key
+__all__ = ["Hub", "Scope", "Client", "EventHint", "init"]
+__all__ += sentry_minimal.__all__

sentry_sdk/client.py

@@ -11,7 +11,6 @@
     convert_types,
     handle_in_app,
     get_type_name,
-    pop_hidden_keys,
     Dsn,
 )
 from .transport import Transport
@@ -83,12 +82,12 @@ def disabled(cls):
         """Creates a guarnateed to be disabled client."""
         return cls(NO_DSN)
 
-    def _prepare_event(self, event, scope):
+    def _prepare_event(self, event, scope, hint=None):
         if event.get("timestamp") is None:
             event["timestamp"] = datetime.utcnow()
 
         if scope is not None:
-            event = scope.apply_to_event(event)
+            event = scope.apply_to_event(event, hint)
             if event is None:
                 return
 
@@ -111,16 +110,14 @@ def _prepare_event(self, event, scope):
             event = before_send(event)
 
         if event is not None:
-            pop_hidden_keys(event)
             event = flatten_metadata(event)
             event = convert_types(event)
 
         return event
 
-    def _is_ignored_error(self, event):
-        exc_info = event.get("__sentry_exc_info")
-
-        if not exc_info or exc_info[0] is None:
+    def _is_ignored_error(self, event, hint=None):
+        exc_info = hint and hint.exc_info or None
+        if exc_info is None:
             return False
 
         type_name = get_type_name(exc_info[0])
@@ -138,27 +135,27 @@ def _is_ignored_error(self, event):
 
         return False
 
-    def _should_capture(self, event, scope=None):
+    def _should_capture(self, event, scope=None, hint=None):
         if (
             self.options["sample_rate"] < 1.0
             and random.random() >= self.options["sample_rate"]
         ):
             return False
 
-        if self._is_ignored_error(event):
+        if self._is_ignored_error(event, hint):
             return False
 
         return True
 
-    def capture_event(self, event, scope=None):
+    def capture_event(self, event, scope=None, hint=None):
         """Captures an event."""
         if self._transport is None:
             return
         rv = event.get("event_id")
         if rv is None:
             event["event_id"] = rv = uuid.uuid4().hex
-        if self._should_capture(event, scope):
-            event = self._prepare_event(event, scope)
+        if self._should_capture(event, scope, hint):
+            event = self._prepare_event(event, scope, hint)
             if event is not None:
                 self._transport.capture_event(event)
         return True

sentry_sdk/hub.py

@@ -15,7 +15,7 @@ def _internal_exceptions():
     try:
         yield
     except Exception:
-        Hub.current.capture_internal_exception()
+        Hub.current.capture_internal_exception(sys.exc_info())
 
 
 def _get_client_options():
@@ -99,11 +99,11 @@ def bind_client(self, new):
         top = self._stack[-1]
         self._stack[-1] = (new, top[1])
 
-    def capture_event(self, event):
+    def capture_event(self, event, hint=None):
         """Captures an event."""
         client, scope = self._stack[-1]
         if client is not None:
-            return client.capture_event(event, scope)
+            return client.capture_event(event, scope, hint)
 
     def capture_message(self, message, level=None):
         """Captures a message."""
@@ -123,15 +123,15 @@ def capture_exception(self, error=None):
         else:
             exc_info = exc_info_from_error(error)
 
-        event = event_from_exception(
+        event, hint = event_from_exception(
             exc_info, with_locals=client.options["with_locals"]
         )
         try:
-            return self.capture_event(event)
+            return self.capture_event(event, hint=hint)
         except Exception:
-            self.capture_internal_exception()
+            self.capture_internal_exception(sys.exc_info())
 
-    def capture_internal_exception(self, error=None):
+    def capture_internal_exception(self, exc_info):
         """Capture an exception that is likely caused by a bug in the SDK
         itself."""
         pass

sentry_sdk/integrations/logging.py

@@ -64,9 +64,10 @@ def _emit(self, record):
                 return
 
             with _internal_exceptions():
+                hint = None
                 # exc_info might be None or (None, None, None)
-                if record.exc_info and all(record.exc_info):
-                    event = event_from_exception(
+                if record.exc_info is not None and record.exc_info[0] is not None:
+                    event, hint = event_from_exception(
                         record.exc_info, with_locals=hub.client.options["with_locals"]
                     )
                 else:
@@ -79,7 +80,7 @@ def _emit(self, record):
                     "params": record.args,
                 }
 
-                capture_event(event)
+                capture_event(event, hint=hint)
 
         with _internal_exceptions():
             add_breadcrumb(self._breadcrumb_from_record(record))

sentry_sdk/minimal.py

@@ -10,10 +10,10 @@ def public(f):
 
 
 @public
-def capture_event(event):
+def capture_event(event, hint=None):
     hub = Hub.current
     if hub is not None:
-        return hub.capture_event(event)
+        return hub.capture_event(event, hint)
 
 
 @public

sentry_sdk/scope.py

@@ -57,10 +57,22 @@ def clear(self):
     def add_event_processor(self, func):
         self._event_processors.append(func)
 
-    def add_error_processor(self, func):
+    def add_error_processor(self, func, cls=None):
+        if cls is not None:
+            real_func = func
+
+            def func(event, exc_info):
+                try:
+                    is_inst = isinstance(exc_info[1], cls)
+                except Exception:
+                    is_inst = False
+                if is_inst:
+                    return real_func(event, exc_info)
+                return event
+
         self._error_processors.append(func)
 
-    def apply_to_event(self, event):
+    def apply_to_event(self, event, hint=None):
         event.setdefault("breadcrumbs", []).extend(self._breadcrumbs)
         if event.get("user") is None and "user" in self._data:
             event["user"] = self._data["user"]
@@ -84,8 +96,8 @@ def apply_to_event(self, event):
         if contexts:
             event.setdefault("contexts", {}).update(contexts)
 
-        exc_info = event.get("__sentry_exc_info", None)
-        if exc_info and exc_info[0] is not None:
+        if hint is not None and hint.exc_info is not None:
+            exc_info = hint.exc_info
             for processor in self._error_processors:
                 event = processor(event, exc_info)
                 if event is None:

sentry_sdk/utils.py

@@ -15,6 +15,24 @@ def to_timestamp(value):
     return (value - epoch).total_seconds()
 
 
+class EventHint(object):
+    """Extra information for an event that can be used during processing."""
+
+    def __init__(self, exc_info=None):
+        self.exc_info = exc_info
+
+    @classmethod
+    def with_exc_info(cls, exc_info=None):
+        """Creates a hint with the exc info filled in."""
+        if exc_info is None:
+            exc_info = sys.exc_info()
+        else:
+            exc_info = exc_info_from_error(exc_info)
+        if exc_info[0] is None:
+            exc_info = None
+        return cls(exc_info=exc_info)
+
+
 class BadDsn(ValueError):
     """Raised on invalid DSNs."""
 
@@ -383,11 +401,14 @@ def exc_info_from_error(error):
 
 def event_from_exception(exc_info, with_locals=False, processors=None):
     exc_info = exc_info_from_error(exc_info)
-    return {
-        "level": "error",
-        "exception": {"values": exceptions_from_error_tuple(exc_info, with_locals)},
-        "__sentry_exc_info": exc_info,
-    }
+    hint = EventHint.with_exc_info(exc_info)
+    return (
+        {
+            "level": "error",
+            "exception": {"values": exceptions_from_error_tuple(exc_info, with_locals)},
+        },
+        hint,
+    )
 
 
 def _module_in_set(name, set):
@@ -458,10 +479,6 @@ def strip_frame(frame):
     return frame, ({"vars": meta} if meta is not None else None)
 
 
-def pop_hidden_keys(event):
-    event.pop("__sentry_exc_info", None)
-
-
 def convert_types(obj):
     if isinstance(obj, datetime):
         return obj.strftime("%Y-%m-%dT%H:%M:%SZ")

tests/conftest.py

@@ -5,6 +5,7 @@
 import pytest
 
 import sentry_sdk
+from sentry_sdk._compat import reraise
 from sentry_sdk.client import Transport
 
 SEMAPHORE = "./checkouts/semaphore/target/debug/semaphore"
@@ -15,10 +16,8 @@
 
 @pytest.fixture(autouse=True)
 def reraise_internal_exceptions(monkeypatch):
-    def capture_internal_exception(error=None):
-        if not error:
-            raise
-        raise error
+    def capture_internal_exception(exc_info):
+        reraise(*exc_info)
 
     monkeypatch.setattr(
         sentry_sdk.get_current_hub(),
@@ -97,3 +96,20 @@ def close(self):
         pass
 
     dsn = "LOL"
+
+
+@pytest.fixture
+def capture_events(monkeypatch):
+    def inner():
+        events = []
+        test_client = sentry_sdk.Hub.current.client
+        old_capture_event = test_client._transport.capture_event
+
+        def append(event):
+            events.append(event)
+            return old_capture_event(event)
+
+        monkeypatch.setattr(test_client._transport, "capture_event", append)
+        return events
+
+    return inner

tests/integrations/conftest.py

@@ -23,20 +23,3 @@ def capture_exception(error=None):
         return errors
 
     return inner
-
-
-@pytest.fixture
-def capture_events(monkeypatch):
-    def inner():
-        events = []
-        test_client = sentry_sdk.Hub.current.client
-        old_capture_event = test_client._transport.capture_event
-
-        def append(event):
-            events.append(event)
-            return old_capture_event(event)
-
-        monkeypatch.setattr(test_client._transport, "capture_event", append)
-        return events
-
-    return inner

tests/test_basics.py

@@ -0,0 +1,23 @@
+from sentry_sdk import configure_scope, capture_exception
+
+
+def test_processors(sentry_init, capture_events):
+    sentry_init()
+    events = capture_events()
+
+    with configure_scope() as scope:
+
+        def error_processor(event, exc_info):
+            event["exception"]["values"][0]["value"] += " whatever"
+            return event
+
+        scope.add_error_processor(error_processor, ValueError)
+
+    try:
+        raise ValueError("aha!")
+    except Exception:
+        capture_exception()
+
+    event, = events
+
+    assert event["exception"]["values"][0]["value"] == "aha! whatever"