import contextlib

import json

import os

import subprocess

import sys

import time

import warnings

from collections import Counter, defaultdict

from collections.abc import Mapping

from textwrap import dedent

from unittest import mock

import pytest

import sentry_sdk

from sentry_sdk import (

Client,

Hub,

add_breadcrumb,

capture_event,

capture_exception,

capture_message,

configure_scope,

set_tag,

start_transaction,

)

from sentry_sdk._compat import PY38

from sentry_sdk.consts import DEFAULT_MAX_BREADCRUMBS

from sentry_sdk.integrations.asyncio import AsyncioIntegration

from sentry_sdk.integrations.executing import ExecutingIntegration

from sentry_sdk.serializer import MAX_DATABAG_BREADTH

from sentry_sdk.spotlight import DEFAULT_SPOTLIGHT_URL

from sentry_sdk.transport import AsyncHttpTransport, Transport

from sentry_sdk.utils import capture_internal_exception

try:

import gevent # noqa: F401

running_under_gevent = True

except ImportError:

running_under_gevent = False

skip_under_gevent = pytest.mark.skipif(

running_under_gevent, reason="Async tests not compatible with gevent"

)

from typing import TYPE_CHECKING

if TYPE_CHECKING:

from collections.abc import Callable

from typing import Any, Optional, Union

from sentry_sdk._types import Event

maximum_python_312 = pytest.mark.skipif(

sys.version_info > (3, 12),

reason="Since Python 3.13, `FrameLocalsProxy` skips items of `locals()` that have non-`str` keys; this is a CPython implementation detail: https://github.com/python/cpython/blame/7b413952e817ae87bfda2ac85dd84d30a6ce743b/Objects/frameobject.c#L148",

)

PROXY_TESTCASES = [

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": "https://localhost/123",

"arg_https_proxy": None,

"expected_proxy_scheme": "https",

},

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": "https://localhost/123",

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": "https://localhost/123",

"expected_proxy_scheme": "https",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": None,

},

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": None,

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "https",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": None,

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": "",

"arg_https_proxy": "",

"expected_proxy_scheme": None,

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "https",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": None,

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": None,

"arg_https_proxy": "",

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": "",

"arg_https_proxy": None,

"expected_proxy_scheme": "https",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": None,

"arg_https_proxy": "",

"expected_proxy_scheme": None,

},

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": "https://localhost/123",

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

# NO_PROXY testcases

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": "http://localhost/123",

"env_https_proxy": None,

"env_no_proxy": "sentry.io,example.com",

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": None,

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": "https://localhost/123",

"env_no_proxy": "example.com,sentry.io",

"arg_http_proxy": None,

"arg_https_proxy": None,

"expected_proxy_scheme": None,

},

{

"dsn": "http://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"env_no_proxy": "sentry.io,example.com",

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": None,

"expected_proxy_scheme": "http",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"env_no_proxy": "sentry.io,example.com",

"arg_http_proxy": None,

"arg_https_proxy": "https://localhost/123",

"expected_proxy_scheme": "https",

},

{

"dsn": "https://foo@sentry.io/123",

"env_http_proxy": None,

"env_https_proxy": None,

"env_no_proxy": "sentry.io,example.com",

"arg_http_proxy": None,

"arg_https_proxy": "https://localhost/123",

"expected_proxy_scheme": "https",

"arg_proxy_headers": {"Test-Header": "foo-bar"},

},

]

SOCKS_PROXY_TESTCASES = [

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": "http://localhost/123",

"arg_https_proxy": None,

"should_be_socks_proxy": False,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": "socks4a://localhost/123",

"arg_https_proxy": None,

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": "socks4://localhost/123",

"arg_https_proxy": None,

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": "socks5h://localhost/123",

"arg_https_proxy": None,

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": "socks5://localhost/123",

"arg_https_proxy": None,

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": None,

"arg_https_proxy": "socks4a://localhost/123",

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": None,

"arg_https_proxy": "socks4://localhost/123",

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": None,

"arg_https_proxy": "socks5h://localhost/123",

"should_be_socks_proxy": True,

},

{

"dsn": "https://foo@sentry.io/123",

"arg_http_proxy": None,

"arg_https_proxy": "socks5://localhost/123",

"should_be_socks_proxy": True,

},

]

class EnvelopeCapturedError(Exception):

pass

class _TestTransport(Transport):

def capture_envelope(self, envelope):

raise EnvelopeCapturedError(envelope)

def test_transport_option(monkeypatch):

if "SENTRY_DSN" in os.environ:

monkeypatch.delenv("SENTRY_DSN")

dsn = "https://foo@sentry.io/123"

dsn2 = "https://bar@sentry.io/124"

assert str(Client(dsn=dsn).dsn) == dsn

assert Client().dsn is None

monkeypatch.setenv("SENTRY_DSN", dsn)

transport = _TestTransport({"dsn": dsn2})

assert str(transport.parsed_dsn) == dsn2

assert str(Client(transport=transport).dsn) == dsn

@pytest.mark.parametrize("testcase", PROXY_TESTCASES)

@pytest.mark.parametrize(

"http2", [True, False] if sys.version_info >= (3, 8) else [False]

)

def test_proxy(monkeypatch, testcase, http2):

if testcase["env_http_proxy"] is not None:

monkeypatch.setenv("HTTP_PROXY", testcase["env_http_proxy"])

if testcase["env_https_proxy"] is not None:

monkeypatch.setenv("HTTPS_PROXY", testcase["env_https_proxy"])

if testcase.get("env_no_proxy") is not None:

monkeypatch.setenv("NO_PROXY", testcase["env_no_proxy"])

kwargs = {}

if http2:

kwargs["_experiments"] = {"transport_http2": True}

if testcase["arg_http_proxy"] is not None:

kwargs["http_proxy"] = testcase["arg_http_proxy"]

if testcase["arg_https_proxy"] is not None:

kwargs["https_proxy"] = testcase["arg_https_proxy"]

if testcase.get("arg_proxy_headers") is not None:

kwargs["proxy_headers"] = testcase["arg_proxy_headers"]

client = Client(testcase["dsn"], **kwargs)

proxy = getattr(

client.transport._pool,

"proxy",

getattr(client.transport._pool, "_proxy_url", None),

)

if testcase["expected_proxy_scheme"] is None:

assert proxy is None

else:

scheme = (

proxy.scheme.decode("ascii")

if isinstance(proxy.scheme, bytes)

else proxy.scheme

)

assert scheme == testcase["expected_proxy_scheme"]

if testcase.get("arg_proxy_headers") is not None:

proxy_headers = (

dict(

(k.decode("ascii"), v.decode("ascii"))

for k, v in client.transport._pool._proxy_headers

)

if http2

else client.transport._pool.proxy_headers

)

assert proxy_headers == testcase["arg_proxy_headers"]

@pytest.mark.parametrize("testcase", SOCKS_PROXY_TESTCASES)

@pytest.mark.parametrize(

"http2", [True, False] if sys.version_info >= (3, 8) else [False]

)

def test_socks_proxy(testcase, http2):

kwargs = {}

if http2:

kwargs["_experiments"] = {"transport_http2": True}

if testcase["arg_http_proxy"] is not None:

kwargs["http_proxy"] = testcase["arg_http_proxy"]

if testcase["arg_https_proxy"] is not None:

kwargs["https_proxy"] = testcase["arg_https_proxy"]

client = Client(testcase["dsn"], **kwargs)

assert ("socks" in str(type(client.transport._pool)).lower()) == testcase[

"should_be_socks_proxy"

], (

f"Expected {kwargs} to result in SOCKS == {testcase['should_be_socks_proxy']}"

f"but got {str(type(client.transport._pool))}"

)

def test_simple_transport(sentry_init):

events = []

sentry_init(transport=events.append)

capture_message("Hello World!")

assert events[0]["message"] == "Hello World!"

def test_ignore_errors(sentry_init, capture_events):

sentry_init(ignore_errors=[ZeroDivisionError])

events = capture_events()

class MyDivisionError(ZeroDivisionError):

pass

def e(exc):

try:

raise exc

except Exception:

capture_exception()

e(ZeroDivisionError())

e(MyDivisionError())

e(ValueError())

assert len(events) == 1

assert events[0]["exception"]["values"][0]["type"] == "ValueError"

def test_include_local_variables_enabled(sentry_init, capture_events):

sentry_init(include_local_variables=True)

events = capture_events()

try:

1 / 0

except Exception:

capture_exception()

(event,) = events

assert all(

frame["vars"]

for frame in event["exception"]["values"][0]["stacktrace"]["frames"]

)

def test_include_local_variables_disabled(sentry_init, capture_events):

sentry_init(include_local_variables=False)

events = capture_events()

try:

1 / 0

except Exception:

capture_exception()

(event,) = events

assert all(

"vars" not in frame

for frame in event["exception"]["values"][0]["stacktrace"]["frames"]

)

def test_include_source_context_enabled(sentry_init, capture_events):

sentry_init(include_source_context=True)

events = capture_events()

try:

1 / 0

except Exception:

capture_exception()

(event,) = events

frame = event["exception"]["values"][0]["stacktrace"]["frames"][0]

assert "post_context" in frame

assert "pre_context" in frame

assert "context_line" in frame

def test_include_source_context_disabled(sentry_init, capture_events):

sentry_init(include_source_context=False)

events = capture_events()

try:

1 / 0

except Exception:

capture_exception()

(event,) = events

frame = event["exception"]["values"][0]["stacktrace"]["frames"][0]

assert "post_context" not in frame

assert "pre_context" not in frame

assert "context_line" not in frame

@pytest.mark.parametrize("integrations", [[], [ExecutingIntegration()]])

def test_function_names(sentry_init, capture_events, integrations):

sentry_init(integrations=integrations)

events = capture_events()

def foo():

try:

bar()

except Exception:

capture_exception()

def bar():

1 / 0

foo()

(event,) = events

(thread,) = event["exception"]["values"]

functions = [x["function"] for x in thread["stacktrace"]["frames"]]

if integrations:

assert functions == [

"test_function_names.<locals>.foo",

"test_function_names.<locals>.bar",

]

else:

assert functions == ["foo", "bar"]

def test_attach_stacktrace_enabled(sentry_init, capture_events):

sentry_init(attach_stacktrace=True)

events = capture_events()

def foo():

bar()

def bar():

capture_message("HI")

foo()

(event,) = events

(thread,) = event["threads"]["values"]

functions = [x["function"] for x in thread["stacktrace"]["frames"]]

assert functions[-2:] == ["foo", "bar"]

def test_attach_stacktrace_enabled_no_locals(sentry_init, capture_events):

sentry_init(attach_stacktrace=True, include_local_variables=False)

events = capture_events()

def foo():

bar()

def bar():

capture_message("HI")

foo()

(event,) = events

(thread,) = event["threads"]["values"]

local_vars = [x.get("vars") for x in thread["stacktrace"]["frames"]]

assert local_vars[-2:] == [None, None]

def test_attach_stacktrace_in_app(sentry_init, capture_events):

sentry_init(attach_stacktrace=True, in_app_exclude=["_pytest"])

events = capture_events()

capture_message("hi")

(event,) = events

(thread,) = event["threads"]["values"]

frames = thread["stacktrace"]["frames"]

pytest_frames = [f for f in frames if f["module"].startswith("_pytest")]

assert pytest_frames

assert all(f["in_app"] is False for f in pytest_frames)

def test_attach_stacktrace_disabled(sentry_init, capture_events):

sentry_init(attach_stacktrace=False)

events = capture_events()

capture_message("HI")

(event,) = events

assert "threads" not in event

def test_attach_stacktrace_transaction(sentry_init, capture_events):

sentry_init(traces_sample_rate=1.0, attach_stacktrace=True)

events = capture_events()

with start_transaction(name="transaction"):

pass

(event,) = events

assert "threads" not in event

def test_capture_event_works(sentry_init):

sentry_init(transport=_TestTransport())

pytest.raises(EnvelopeCapturedError, lambda: capture_event({}))

pytest.raises(EnvelopeCapturedError, lambda: capture_event({}))

@pytest.mark.parametrize("num_messages", [10, 20])

@pytest.mark.parametrize(

"http2", [True, False] if sys.version_info >= (3, 8) else [False]

)

def test_atexit(tmpdir, monkeypatch, num_messages, http2):

if http2:

options = '_experiments={"transport_http2": True}'

transport = "Http2Transport"

else:

options = ""

transport = "HttpTransport"

app = tmpdir.join("app.py")

app.write(

dedent(

"""

import time

from sentry_sdk import init, transport, capture_message

def capture_envelope(self, envelope):

time.sleep(0.1)

event = envelope.get_event() or dict()

message = event.get("message", "")

print(message)

transport.{transport}.capture_envelope = capture_envelope

init("http://foobar@localhost/123", shutdown_timeout={num_messages}, {options})

for _ in range({num_messages}):

capture_message("HI")

""".format(transport=transport, options=options, num_messages=num_messages)

)

)

start = time.time()

output = subprocess.check_output([sys.executable, str(app)])

end = time.time()

# Each message takes at least 0.1 seconds to process

assert int(end - start) >= num_messages / 10

assert output.count(b"HI") == num_messages

def test_configure_scope_available(

sentry_init, request, monkeypatch, suppress_deprecation_warnings

):

"""

Test that scope is configured if client is configured

This test can be removed once configure_scope and the Hub are removed.

"""

sentry_init()

with configure_scope() as scope:

assert scope is Hub.current.scope

scope.set_tag("foo", "bar")

calls = []

def callback(scope):

calls.append(scope)

scope.set_tag("foo", "bar")

assert configure_scope(callback) is None

assert len(calls) == 1

assert calls[0] is Hub.current.scope

@pytest.mark.tests_internal_exceptions

def test_client_debug_option_enabled(sentry_init, caplog):

sentry_init(debug=True)

capture_internal_exception((ValueError, ValueError("OK"), None))

assert "OK" in caplog.text

@pytest.mark.tests_internal_exceptions

@pytest.mark.parametrize("with_client", (True, False))

def test_client_debug_option_disabled(with_client, sentry_init, caplog):

if with_client:

sentry_init()

capture_internal_exception((ValueError, ValueError("OK"), None))

assert "OK" not in caplog.text

def test_weird_chars(sentry_init, capture_events):

sentry_init()

events = capture_events()

capture_message("föö".encode("latin1"))

(event,) = events

assert json.loads(json.dumps(event)) == event

def test_nan(sentry_init, capture_events):

sentry_init()

events = capture_events()

try:

# should_repr_strings=False

set_tag("mynan", float("nan"))

# should_repr_strings=True

nan = float("nan") # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

frames = event["exception"]["values"][0]["stacktrace"]["frames"]

(frame,) = frames

assert frame["vars"]["nan"] == "nan"

assert event["tags"]["mynan"] == "nan"

def test_cyclic_frame_vars(sentry_init, capture_events):

sentry_init()

events = capture_events()

try:

a = {}

a["a"] = a

1 / 0

except Exception:

capture_exception()

(event,) = events

assert event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"] == {

"a": "<cyclic>"

}

def test_cyclic_data(sentry_init, capture_events):

sentry_init()

events = capture_events()

data = {}

data["is_cyclic"] = data

other_data = ""

data["not_cyclic"] = other_data

data["not_cyclic2"] = other_data

sentry_sdk.get_isolation_scope().set_extra("foo", data)

capture_message("hi")

(event,) = events

data = event["extra"]["foo"]

assert data == {"not_cyclic2": "", "not_cyclic": "", "is_cyclic": "<cyclic>"}

def test_databag_depth_stripping(sentry_init, capture_events):

sentry_init()

events = capture_events()

value = ["a"]

for _ in range(100000):

value = [value]

del events[:]

try:

a = value # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

stacktrace_frame = event["exception"]["values"][0]["stacktrace"]["frames"][0]

a_var = stacktrace_frame["vars"]["a"]

assert type(a_var) == list

assert len(a_var) == 1 and type(a_var[0]) == list

first_level_list = a_var[0]

assert type(first_level_list) == list

assert len(first_level_list) == 1

second_level_list = first_level_list[0]

assert type(second_level_list) == list

assert len(second_level_list) == 1

third_level_list = second_level_list[0]

assert type(third_level_list) == list

assert len(third_level_list) == 1

inner_value_repr = third_level_list[0]

assert type(inner_value_repr) == str

def test_databag_string_stripping(sentry_init, capture_events):

sentry_init(max_value_length=1024)

events = capture_events()

del events[:]

try:

a = "A" * 10240 # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

assert len(json.dumps(event)) < 10240

def test_databag_breadth_stripping(sentry_init, capture_events):

sentry_init()

events = capture_events()

del events[:]

try:

a = ["a"] * 1000000 # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

assert (

len(event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"])

== MAX_DATABAG_BREADTH

)

assert len(json.dumps(event)) < 10000

def test_chained_exceptions(sentry_init, capture_events):

sentry_init()

events = capture_events()

try:

try:

raise ValueError()

except Exception:

1 / 0

except Exception:

capture_exception()

(event,) = events

e1, e2 = event["exception"]["values"]

# This is the order all other SDKs send chained exceptions in. Including

# Raven-Python.

assert e1["type"] == "ValueError"

assert e2["type"] == "ZeroDivisionError"

@pytest.mark.tests_internal_exceptions

def test_broken_mapping(sentry_init, capture_events):

sentry_init()

events = capture_events()

class C(Mapping):

def broken(self, *args, **kwargs):

raise Exception("broken")

__getitem__ = broken

__setitem__ = broken

__delitem__ = broken

__iter__ = broken

__len__ = broken

def __repr__(self):

return "broken"

try:

a = C() # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

assert (

event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"]

== "<failed to serialize, use init(debug=True) to see error logs>"

)

def test_mapping_sends_exception(sentry_init, capture_events):

sentry_init()

events = capture_events()

class C(Mapping):

def __iter__(self):

try:

1 / 0

except ZeroDivisionError:

capture_exception()

yield "hi"

def __len__(self):

"""List length"""

return 1

def __getitem__(self, ii):

"""Get a list item"""

if ii == "hi":

return "hi"

raise KeyError()

try:

a = C() # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

assert event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"] == {

"hi": "'hi'"

}

def test_object_sends_exception(sentry_init, capture_events):

sentry_init()

events = capture_events()

class C:

def __repr__(self):

try:

1 / 0

except ZeroDivisionError:

capture_exception()

return "hi, i am a repr"

try:

a = C() # noqa

1 / 0

except Exception:

capture_exception()

(event,) = events

assert (

event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"]

== "hi, i am a repr"

)

def test_errno_errors(sentry_init, capture_events):

sentry_init()

events = capture_events()

class FooError(Exception):

errno = 69

capture_exception(FooError())

(event,) = events

(exception,) = event["exception"]["values"]

assert exception["mechanism"]["meta"]["errno"]["number"] == 69

@maximum_python_312

def test_non_string_variables(sentry_init, capture_events):

"""There is some extremely terrible code in the wild that

inserts non-strings as variable names into `locals()`."""

sentry_init()

events = capture_events()

try:

locals()[42] = True

1 / 0

except ZeroDivisionError:

capture_exception()

(event,) = events

(exception,) = event["exception"]["values"]

assert exception["type"] == "ZeroDivisionError"

(frame,) = exception["stacktrace"]["frames"]

assert frame["vars"]["42"] == "True"

def test_dict_changed_during_iteration(sentry_init, capture_events):

"""

Some versions of Bottle modify the WSGI environment inside of this __repr__

impl: https://github.com/bottlepy/bottle/blob/0.12.16/bottle.py#L1386

See https://github.com/getsentry/sentry-python/pull/298 for discussion

"""

sentry_init(send_default_pii=True)

events = capture_events()

class TooSmartClass:

def __init__(self, environ):

self.environ = environ

def __repr__(self):

if "my_representation" in self.environ:

return self.environ["my_representation"]

self.environ["my_representation"] = "<This is me>"

return self.environ["my_representation"]

try:

environ = {}

environ["a"] = TooSmartClass(environ)

1 / 0

except ZeroDivisionError:

capture_exception()