feat: Deep vars

untitaker · untitaker · commit 1a84076b686e · 2019-02-04T17:57:05.000+01:00
diff --git a/sentry_sdk/events.py b/sentry_sdk/events.py
@@ -0,0 +1,32 @@
+def _filter_none(value):
+    if value is not None:
+        yield value
+
+
+def _iter_values(values):
+    if isinstance(values, list):
+        return values
+    elif isinstance(values, dict):
+        return values.get("values") or ()
+    else:
+        return ()
+
+
+def iter_stacktraces(event):
+    x = event.get("stacktrace")
+    if x is not None:
+        yield x
+
+    exception_values = event.get("exception")
+    if exception_values is not None:
+        for exception in _iter_values(exception_values):
+            x = exception.get("stacktrace")
+            if x is not None:
+                yield x
+
+    thread_values = event.get("threads")
+    if thread_values is not None:
+        for exception in _iter_values(thread_values):
+            x = exception.get("stacktrace")
+            if x is not None:
+                yield x
diff --git a/sentry_sdk/integrations/deep_vars.py b/sentry_sdk/integrations/deep_vars.py
@@ -0,0 +1,62 @@
+from sentry_sdk.utils import add_global_repr_processor, safe_repr
+from sentry_sdk.scope import add_global_event_processor
+from sentry_sdk.events import iter_stacktraces
+
+from sentry_sdk.integrations import Integration
+
+
+class DeepVarsIntegration(Integration):
+    identifier = "deep_vars"
+
+    @staticmethod
+    def setup_once():
+        add_global_repr_processor(_deep_vars_repr)
+        add_global_event_processor(_deep_vars_processor)
+
+
+class DeepVar(object):
+    __slots__ = ("obj", "fields")
+
+    def __init__(self, obj, fields):
+        self.obj = obj
+        self.fields = fields
+
+
+def _deep_vars_repr(obj, hint):
+    if type(obj) in (list, dict, str, float, bool):
+        return NotImplemented
+
+    try:
+        return DeepVar(
+            obj, {k: safe_repr(obj.__dict__[k]) for k in dir(obj) if k in obj.__dict__}
+        )
+    except Exception:
+        pass
+
+    return NotImplemented
+
+
+def _deep_vars_processor(event, hint):
+    for stacktrace in iter_stacktraces(event):
+        _process_stacktrace(stacktrace)
+
+    return event
+
+
+def _process_stacktrace(stacktrace):
+    for frame in stacktrace.get("frames") or ():
+        vars = frame.get("vars")
+        if not vars:
+            continue
+
+        new_vars = {}
+
+        for key, value in vars.items():
+            if isinstance(value, DeepVar):
+                for key2, value2 in value.fields.items():
+                    new_vars["{}.{}".format(key, key2)] = value2
+                new_vars[key] = safe_repr(value.obj)
+            else:
+                new_vars[key] = value
+
+        frame["vars"] = new_vars
diff --git a/tests/integrations/deep_vars/test_basic.py b/tests/integrations/deep_vars/test_basic.py
@@ -0,0 +1,33 @@
+from sentry_sdk import capture_exception
+from sentry_sdk.integrations.deep_vars import DeepVarsIntegration
+
+
+def test_basic(sentry_init, capture_events):
+    sentry_init(integrations=[DeepVarsIntegration()])
+    events = capture_events()
+
+    class Foo(object):
+        y = 2
+
+        @property
+        def bogus(self):
+            1 / 0
+
+    try:
+        foo = Foo()
+        foo.x = 2
+
+        1 / 0
+
+    except Exception:
+        capture_exception()
+
+    event, = events
+
+    exception, = event["exception"]["values"]
+
+    assert exception["type"] == "ZeroDivisionError"
+    frame, = exception["stacktrace"]["frames"]
+
+    assert "Foo" in frame["vars"]["foo"]
+    assert frame["vars"]["foo.x"] == "2"
