[0-9]+(?:\.[0-9]+)*) # release segment
+ (?P # pre-release
+ [-_\.]?
+ (?P(a|b|c|rc|alpha|beta|pre|preview))
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ (?P # post release
+ (?:-(?P[0-9]+))
+ |
+ (?:
+ [-_\.]?
+ (?Ppost|rev|r)
+ [-_\.]?
+ (?P[0-9]+)?
+ )
+ )?
+ (?P # dev release
+ [-_\.]?
+ (?Pdev)
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ )
+ (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
+ """
+
+ pattern = re.compile(
+ r"^\s*" + VERSION_PATTERN + r"\s*$",
+ re.VERBOSE | re.IGNORECASE,
+ )
+
+ try:
+ release = pattern.match(version).groupdict()["release"] # type: ignore
+ release_tuple = tuple(map(int, release.split(".")[:3])) # type: Tuple[int, ...]
+ except (TypeError, ValueError, AttributeError):
+ return None
+
+ return release_tuple
+
+
+if PY37:
+
+ def nanosecond_time():
+ # type: () -> int
+ return time.perf_counter_ns()
+
+elif PY33:
+
+ def nanosecond_time():
+ # type: () -> int
+ return int(time.perf_counter() * 1e9)
+
+else:
+
+ def nanosecond_time():
+ # type: () -> int
+ raise AttributeError
+
+
+if PY2:
+
+ def now():
+ # type: () -> float
+ return time.time()
+
+else:
+
+ def now():
+ # type: () -> float
+ return time.perf_counter()
diff --git a/sentry_sdk/worker.py b/sentry_sdk/worker.py
index a06fb8f0d1..ca0ca28d94 100644
--- a/sentry_sdk/worker.py
+++ b/sentry_sdk/worker.py
@@ -3,13 +3,13 @@
from time import sleep, time
from sentry_sdk._compat import check_thread_support
-from sentry_sdk._queue import Queue, Full
+from sentry_sdk._queue import Queue, FullError
from sentry_sdk.utils import logger
from sentry_sdk.consts import DEFAULT_QUEUE_SIZE
-from sentry_sdk._types import MYPY
+from sentry_sdk._types import TYPE_CHECKING
-if MYPY:
+if TYPE_CHECKING:
from typing import Any
from typing import Optional
from typing import Callable
@@ -81,7 +81,7 @@ def kill(self):
if self._thread:
try:
self._queue.put_nowait(_TERMINATOR)
- except Full:
+ except FullError:
logger.debug("background worker queue full, kill failed")
self._thread = None
@@ -114,7 +114,7 @@ def submit(self, callback):
try:
self._queue.put_nowait(callback)
return True
- except Full:
+ except FullError:
return False
def _target(self):
diff --git a/setup.py b/setup.py
index 9488b790ca..26c3a9e84d 100644
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@ def get_file_text(file_name):
setup(
name="sentry-sdk",
- version="1.5.8",
+ version="1.25.1",
author="Sentry Team and Contributors",
author_email="hello@sentry.io",
url="https://github.com/getsentry/sentry-python",
@@ -36,17 +36,24 @@ def get_file_text(file_name):
# PEP 561
package_data={"sentry_sdk": ["py.typed"]},
zip_safe=False,
- license="BSD",
- install_requires=["urllib3>=1.10.0", "certifi"],
+ license="MIT",
+ install_requires=[
+ 'urllib3>=1.25.7; python_version<="3.4"',
+ 'urllib3>=1.26.9; python_version=="3.5"',
+ 'urllib3>=1.26.11; python_version >="3.6"',
+ "certifi",
+ ],
extras_require={
- "flask": ["flask>=0.11", "blinker>=1.1"],
+ "flask": ["flask>=0.11", "blinker>=1.1", "markupsafe"],
"quart": ["quart>=0.16.1", "blinker>=1.1"],
"bottle": ["bottle>=0.12.13"],
"falcon": ["falcon>=1.4"],
"django": ["django>=1.8"],
"sanic": ["sanic>=0.8"],
"celery": ["celery>=3"],
+ "huey": ["huey>=2"],
"beam": ["apache-beam>=2.12"],
+ "arq": ["arq>=0.23"],
"rq": ["rq>=0.6"],
"aiohttp": ["aiohttp>=3.5"],
"tornado": ["tornado>=5"],
@@ -55,6 +62,13 @@ def get_file_text(file_name):
"pure_eval": ["pure_eval", "executing", "asttokens"],
"chalice": ["chalice>=1.16.0"],
"httpx": ["httpx>=0.16.0"],
+ "starlette": ["starlette>=0.19.1"],
+ "starlite": ["starlite>=1.48"],
+ "fastapi": ["fastapi>=0.79.0"],
+ "pymongo": ["pymongo>=3.1"],
+ "opentelemetry": ["opentelemetry-distro>=0.35b0"],
+ "grpcio": ["grpcio>=1.21.1"],
+ "loguru": ["loguru>=0.5"],
},
classifiers=[
"Development Status :: 5 - Production/Stable",
diff --git a/test-requirements.txt b/test-requirements.txt
index ea8333ca16..662ac4bd53 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -1,15 +1,14 @@
+pip # always use newest pip
+mock ; python_version<'3.3'
pytest<7
+pytest-cov==2.8.1
pytest-forked<=1.4.0
+pytest-localserver==0.5.0
pytest-watch==4.2.0
tox==3.7.0
-Werkzeug
-pytest-localserver==0.5.0
-pytest-cov==2.8.1
jsonschema==3.2.0
pyrsistent==0.16.0 # TODO(py3): 0.17.0 requires python3, see https://github.com/tobgu/pyrsistent/issues/205
-mock # for testing under python < 3.3
-
-gevent
-
executing
asttokens
+responses
+ipdb
diff --git a/tests/conftest.py b/tests/conftest.py
index 692a274d71..d9d88067dc 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,5 +1,7 @@
-import os
import json
+import os
+import socket
+from threading import Thread
import pytest
import jsonschema
@@ -14,10 +16,23 @@
except ImportError:
eventlet = None
+try:
+ # Python 2
+ import BaseHTTPServer
+
+ HTTPServer = BaseHTTPServer.HTTPServer
+ BaseHTTPRequestHandler = BaseHTTPServer.BaseHTTPRequestHandler
+except Exception:
+ # Python 3
+ from http.server import BaseHTTPRequestHandler, HTTPServer
+
+
import sentry_sdk
-from sentry_sdk._compat import reraise, string_types, iteritems
-from sentry_sdk.transport import Transport
+from sentry_sdk._compat import iteritems, reraise, string_types
from sentry_sdk.envelope import Envelope
+from sentry_sdk.integrations import _installed_integrations # noqa: F401
+from sentry_sdk.profiler import teardown_profiler
+from sentry_sdk.transport import Transport
from sentry_sdk.utils import capture_internal_exceptions
from tests import _warning_recorder, _warning_recorder_mgr
@@ -39,7 +54,6 @@
def benchmark():
return lambda x: x()
-
else:
del pytest_benchmark
@@ -55,7 +69,7 @@ def _capture_internal_exception(self, exc_info):
@request.addfinalizer
def _():
- # rerasise the errors so that this just acts as a pass-through (that
+ # reraise the errors so that this just acts as a pass-through (that
# happens to keep track of the errors which pass through it)
for e in errors:
reraise(*e)
@@ -143,11 +157,11 @@ def check_string_keys(map):
def check_envelope(envelope):
with capture_internal_exceptions():
- # Assert error events are sent without envelope to server, for compat.
- # This does not apply if any item in the envelope is an attachment.
- if not any(x.type == "attachment" for x in envelope.items):
- assert not any(item.data_category == "error" for item in envelope.items)
- assert not any(item.get_event() is not None for item in envelope.items)
+ # There used to be a check here for errors are not sent in envelopes.
+ # We changed the behaviour to send errors in envelopes when tracing is enabled.
+ # This is checked in test_client.py::test_sending_events_with_tracing
+ # and test_client.py::test_sending_events_with_no_tracing
+ pass
def inner(client):
monkeypatch.setattr(
@@ -166,6 +180,17 @@ def inner(event):
return inner
+@pytest.fixture
+def reset_integrations():
+ """
+ Use with caution, sometimes we really need to start
+ with a clean slate to ensure monkeypatching works well,
+ but this also means some other stuff will be monkeypatched twice.
+ """
+ global _installed_integrations
+ _installed_integrations.clear()
+
+
@pytest.fixture
def sentry_init(monkeypatch_test_transport, request):
def inner(*a, **kw):
@@ -286,20 +311,21 @@ def flush(timeout=None, callback=None):
monkeypatch.setattr(test_client.transport, "capture_event", append)
monkeypatch.setattr(test_client, "flush", flush)
- return EventStreamReader(events_r)
+ return EventStreamReader(events_r, events_w)
return inner
class EventStreamReader(object):
- def __init__(self, file):
- self.file = file
+ def __init__(self, read_file, write_file):
+ self.read_file = read_file
+ self.write_file = write_file
def read_event(self):
- return json.loads(self.file.readline().decode("utf-8"))
+ return json.loads(self.read_file.readline().decode("utf-8"))
def read_flush(self):
- assert self.file.readline() == b"flush\n"
+ assert self.read_file.readline() == b"flush\n"
# scope=session ensures that fixture is run earlier
@@ -389,7 +415,7 @@ def __init__(self, substring):
try:
# the `unicode` type only exists in python 2, so if this blows up,
# we must be in py3 and have the `bytes` type
- self.valid_types = (str, unicode) # noqa
+ self.valid_types = (str, unicode)
except NameError:
self.valid_types = (str, bytes)
@@ -543,3 +569,36 @@ def __ne__(self, test_obj):
return not self.__eq__(test_obj)
return ObjectDescribedBy
+
+
+@pytest.fixture
+def teardown_profiling():
+ yield
+ teardown_profiler()
+
+
+class MockServerRequestHandler(BaseHTTPRequestHandler):
+ def do_GET(self): # noqa: N802
+ # Process an HTTP GET request and return a response with an HTTP 200 status.
+ self.send_response(200)
+ self.end_headers()
+ return
+
+
+def get_free_port():
+ s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
+ s.bind(("localhost", 0))
+ _, port = s.getsockname()
+ s.close()
+ return port
+
+
+def create_mock_http_server():
+ # Start a mock server to test outgoing http requests
+ mock_server_port = get_free_port()
+ mock_server = HTTPServer(("localhost", mock_server_port), MockServerRequestHandler)
+ mock_server_thread = Thread(target=mock_server.serve_forever)
+ mock_server_thread.setDaemon(True)
+ mock_server_thread.start()
+
+ return mock_server_port
diff --git a/tests/integrations/aiohttp/test_aiohttp.py b/tests/integrations/aiohttp/test_aiohttp.py
index 5c590bcdfa..a43df6ecb2 100644
--- a/tests/integrations/aiohttp/test_aiohttp.py
+++ b/tests/integrations/aiohttp/test_aiohttp.py
@@ -7,6 +7,7 @@
from aiohttp.client import ServerDisconnectedError
from aiohttp.web_request import Request
+from sentry_sdk import capture_message
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
try:
@@ -15,7 +16,8 @@
import mock # python < 3.3
-async def test_basic(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_basic(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
@@ -55,7 +57,8 @@ async def hello(request):
}
-async def test_post_body_not_read(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_post_body_not_read(sentry_init, aiohttp_client, capture_events):
from sentry_sdk.integrations.aiohttp import BODY_NOT_READ_MESSAGE
sentry_init(integrations=[AioHttpIntegration()])
@@ -84,7 +87,8 @@ async def hello(request):
assert request["data"] == BODY_NOT_READ_MESSAGE
-async def test_post_body_read(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_post_body_read(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
body = {"some": "value"}
@@ -112,7 +116,8 @@ async def hello(request):
assert request["data"] == json.dumps(body)
-async def test_403_not_captured(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_403_not_captured(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
@@ -130,8 +135,9 @@ async def hello(request):
assert not events
+@pytest.mark.asyncio
async def test_cancelled_error_not_captured(
- sentry_init, aiohttp_client, loop, capture_events
+ sentry_init, aiohttp_client, capture_events
):
sentry_init(integrations=[AioHttpIntegration()])
@@ -152,7 +158,8 @@ async def hello(request):
assert not events
-async def test_half_initialized(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_half_initialized(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
sentry_init()
@@ -171,7 +178,8 @@ async def hello(request):
assert events == []
-async def test_tracing(sentry_init, aiohttp_client, loop, capture_events):
+@pytest.mark.asyncio
+async def test_tracing(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()], traces_sample_rate=1.0)
async def hello(request):
@@ -195,18 +203,32 @@ async def hello(request):
)
+@pytest.mark.asyncio
@pytest.mark.parametrize(
- "transaction_style,expected_transaction",
+ "url,transaction_style,expected_transaction,expected_source",
[
(
+ "/message",
"handler_name",
"tests.integrations.aiohttp.test_aiohttp.test_transaction_style..hello",
+ "component",
+ ),
+ (
+ "/message",
+ "method_and_path_pattern",
+ "GET /{var}",
+ "route",
),
- ("method_and_path_pattern", "GET /{var}"),
],
)
async def test_transaction_style(
- sentry_init, aiohttp_client, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ aiohttp_client,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
):
sentry_init(
integrations=[AioHttpIntegration(transaction_style=transaction_style)],
@@ -222,20 +244,22 @@ async def hello(request):
events = capture_events()
client = await aiohttp_client(app)
- resp = await client.get("/1")
+ resp = await client.get(url)
assert resp.status == 200
(event,) = events
assert event["type"] == "transaction"
assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
+@pytest.mark.asyncio
async def test_traces_sampler_gets_request_object_in_sampling_context(
sentry_init,
aiohttp_client,
DictionaryContaining, # noqa:N803
- ObjectDescribedBy, # noqa:N803
+ ObjectDescribedBy,
):
traces_sampler = mock.Mock()
sentry_init(
@@ -261,3 +285,145 @@ async def kangaroo_handler(request):
}
)
)
+
+
+@pytest.mark.asyncio
+async def test_has_trace_if_performance_enabled(
+ sentry_init, aiohttp_client, capture_events
+):
+ sentry_init(integrations=[AioHttpIntegration()], traces_sample_rate=1.0)
+
+ async def hello(request):
+ capture_message("It's a good day to try dividing by 0")
+ 1 / 0
+
+ app = web.Application()
+ app.router.add_get("/", hello)
+
+ events = capture_events()
+
+ client = await aiohttp_client(app)
+ resp = await client.get("/")
+ assert resp.status == 500
+
+ msg_event, error_event, transaction_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ == msg_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_has_trace_if_performance_disabled(
+ sentry_init, aiohttp_client, capture_events
+):
+ sentry_init(integrations=[AioHttpIntegration()])
+
+ async def hello(request):
+ capture_message("It's a good day to try dividing by 0")
+ 1 / 0
+
+ app = web.Application()
+ app.router.add_get("/", hello)
+
+ events = capture_events()
+
+ client = await aiohttp_client(app)
+ resp = await client.get("/")
+ assert resp.status == 500
+
+ msg_event, error_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ error_event["contexts"]["trace"]["trace_id"]
+ == msg_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+@pytest.mark.asyncio
+async def test_trace_from_headers_if_performance_enabled(
+ sentry_init, aiohttp_client, capture_events
+):
+ sentry_init(integrations=[AioHttpIntegration()], traces_sample_rate=1.0)
+
+ async def hello(request):
+ capture_message("It's a good day to try dividing by 0")
+ 1 / 0
+
+ app = web.Application()
+ app.router.add_get("/", hello)
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ client = await aiohttp_client(app)
+ resp = await client.get("/", headers={"sentry-trace": sentry_trace_header})
+ assert resp.status == 500
+
+ msg_event, error_event, transaction_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert transaction_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
+@pytest.mark.asyncio
+async def test_trace_from_headers_if_performance_disabled(
+ sentry_init, aiohttp_client, capture_events
+):
+ sentry_init(integrations=[AioHttpIntegration()])
+
+ async def hello(request):
+ capture_message("It's a good day to try dividing by 0")
+ 1 / 0
+
+ app = web.Application()
+ app.router.add_get("/", hello)
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ client = await aiohttp_client(app)
+ resp = await client.get("/", headers={"sentry-trace": sentry_trace_header})
+ assert resp.status == 500
+
+ msg_event, error_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
diff --git a/tests/integrations/arq/__init__.py b/tests/integrations/arq/__init__.py
new file mode 100644
index 0000000000..f0b4712255
--- /dev/null
+++ b/tests/integrations/arq/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("arq")
diff --git a/tests/integrations/arq/test_arq.py b/tests/integrations/arq/test_arq.py
new file mode 100644
index 0000000000..d7e0e8af85
--- /dev/null
+++ b/tests/integrations/arq/test_arq.py
@@ -0,0 +1,159 @@
+import pytest
+
+from sentry_sdk import start_transaction
+from sentry_sdk.integrations.arq import ArqIntegration
+
+from arq.connections import ArqRedis
+from arq.jobs import Job
+from arq.utils import timestamp_ms
+from arq.worker import Retry, Worker
+
+from fakeredis.aioredis import FakeRedis
+
+
+@pytest.fixture(autouse=True)
+def patch_fakeredis_info_command():
+ from fakeredis._fakesocket import FakeSocket
+
+ if not hasattr(FakeSocket, "info"):
+ from fakeredis._commands import command
+ from fakeredis._helpers import SimpleString
+
+ @command((SimpleString,), name="info")
+ def info(self, section):
+ return section
+
+ FakeSocket.info = info
+
+
+@pytest.fixture
+def init_arq(sentry_init):
+ def inner(functions, allow_abort_jobs=False):
+ sentry_init(
+ integrations=[ArqIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ )
+
+ server = FakeRedis()
+ pool = ArqRedis(pool_or_conn=server.connection_pool)
+ return pool, Worker(
+ functions, redis_pool=pool, allow_abort_jobs=allow_abort_jobs
+ )
+
+ return inner
+
+
+@pytest.mark.asyncio
+async def test_job_result(init_arq):
+ async def increase(ctx, num):
+ return num + 1
+
+ increase.__qualname__ = increase.__name__
+
+ pool, worker = init_arq([increase])
+
+ job = await pool.enqueue_job("increase", 3)
+
+ assert isinstance(job, Job)
+
+ await worker.run_job(job.job_id, timestamp_ms())
+ result = await job.result()
+ job_result = await job.result_info()
+
+ assert result == 4
+ assert job_result.result == 4
+
+
+@pytest.mark.asyncio
+async def test_job_retry(capture_events, init_arq):
+ async def retry_job(ctx):
+ if ctx["job_try"] < 2:
+ raise Retry
+
+ retry_job.__qualname__ = retry_job.__name__
+
+ pool, worker = init_arq([retry_job])
+
+ job = await pool.enqueue_job("retry_job")
+
+ events = capture_events()
+
+ await worker.run_job(job.job_id, timestamp_ms())
+
+ event = events.pop(0)
+ assert event["contexts"]["trace"]["status"] == "aborted"
+ assert event["transaction"] == "retry_job"
+ assert event["tags"]["arq_task_id"] == job.job_id
+ assert event["extra"]["arq-job"]["retry"] == 1
+
+ await worker.run_job(job.job_id, timestamp_ms())
+
+ event = events.pop(0)
+ assert event["contexts"]["trace"]["status"] == "ok"
+ assert event["transaction"] == "retry_job"
+ assert event["tags"]["arq_task_id"] == job.job_id
+ assert event["extra"]["arq-job"]["retry"] == 2
+
+
+@pytest.mark.parametrize("job_fails", [True, False], ids=["error", "success"])
+@pytest.mark.asyncio
+async def test_job_transaction(capture_events, init_arq, job_fails):
+ async def division(_, a, b=0):
+ return a / b
+
+ division.__qualname__ = division.__name__
+
+ pool, worker = init_arq([division])
+
+ events = capture_events()
+
+ job = await pool.enqueue_job("division", 1, b=int(not job_fails))
+ await worker.run_job(job.job_id, timestamp_ms())
+
+ if job_fails:
+ error_event = events.pop(0)
+ assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
+ assert error_event["exception"]["values"][0]["mechanism"]["type"] == "arq"
+
+ (event,) = events
+ assert event["type"] == "transaction"
+ assert event["transaction"] == "division"
+ assert event["transaction_info"] == {"source": "task"}
+
+ if job_fails:
+ assert event["contexts"]["trace"]["status"] == "internal_error"
+ else:
+ assert event["contexts"]["trace"]["status"] == "ok"
+
+ assert "arq_task_id" in event["tags"]
+ assert "arq_task_retry" in event["tags"]
+
+ extra = event["extra"]["arq-job"]
+ assert extra["task"] == "division"
+ assert extra["args"] == [1]
+ assert extra["kwargs"] == {"b": int(not job_fails)}
+ assert extra["retry"] == 1
+
+
+@pytest.mark.asyncio
+async def test_enqueue_job(capture_events, init_arq):
+ async def dummy_job(_):
+ pass
+
+ pool, _ = init_arq([dummy_job])
+
+ events = capture_events()
+
+ with start_transaction() as transaction:
+ await pool.enqueue_job("dummy_job")
+
+ (event,) = events
+
+ assert event["contexts"]["trace"]["trace_id"] == transaction.trace_id
+ assert event["contexts"]["trace"]["span_id"] == transaction.span_id
+
+ assert len(event["spans"])
+ assert event["spans"][0]["op"] == "queue.submit.arq"
+ assert event["spans"][0]["description"] == "dummy_job"
diff --git a/tests/integrations/asgi/__init__.py b/tests/integrations/asgi/__init__.py
index c89ddf99a8..1fb057c1fc 100644
--- a/tests/integrations/asgi/__init__.py
+++ b/tests/integrations/asgi/__init__.py
@@ -1,3 +1,4 @@
import pytest
-pytest.importorskip("starlette")
+asyncio = pytest.importorskip("asyncio")
+pytest_asyncio = pytest.importorskip("pytest_asyncio")
diff --git a/tests/integrations/asgi/test_asgi.py b/tests/integrations/asgi/test_asgi.py
index 5383b1a308..d51293af75 100644
--- a/tests/integrations/asgi/test_asgi.py
+++ b/tests/integrations/asgi/test_asgi.py
@@ -1,321 +1,369 @@
-from collections import Counter
import sys
+from collections import Counter
+
import pytest
-from sentry_sdk import Hub, capture_message, last_event_id
import sentry_sdk
-from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
-from starlette.applications import Starlette
-from starlette.responses import PlainTextResponse
-from starlette.testclient import TestClient
-from starlette.websockets import WebSocket
+from sentry_sdk import capture_message
+from sentry_sdk.integrations.asgi import SentryAsgiMiddleware, _looks_like_asgi3
-try:
- from unittest import mock # python 3.3 and above
-except ImportError:
- import mock # python < 3.3
+async_asgi_testclient = pytest.importorskip("async_asgi_testclient")
+from async_asgi_testclient import TestClient
-@pytest.fixture
-def app():
- app = Starlette()
+minimum_python_36 = pytest.mark.skipif(
+ sys.version_info < (3, 6), reason="ASGI is only supported in Python >= 3.6"
+)
- @app.route("/sync-message")
- def hi(request):
- capture_message("hi", level="error")
- return PlainTextResponse("ok")
- @app.route("/async-message")
- async def hi2(request):
- capture_message("hi", level="error")
- return PlainTextResponse("ok")
+@pytest.fixture
+def asgi3_app():
+ async def app(scope, receive, send):
+ if (
+ scope["type"] == "http"
+ and "route" in scope
+ and scope["route"] == "/trigger/error"
+ ):
+ 1 / 0
+
+ await send(
+ {
+ "type": "http.response.start",
+ "status": 200,
+ "headers": [
+ [b"content-type", b"text/plain"],
+ ],
+ }
+ )
- app.add_middleware(SentryAsgiMiddleware)
+ await send(
+ {
+ "type": "http.response.body",
+ "body": b"Hello, world!",
+ }
+ )
return app
-@pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher")
-def test_sync_request_data(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
-
- client = TestClient(app)
- response = client.get("/sync-message?foo=bar", headers={"Foo": "ä"})
-
- assert response.status_code == 200
-
- (event,) = events
- assert event["transaction"] == "tests.integrations.asgi.test_asgi.app..hi"
- assert event["request"]["env"] == {"REMOTE_ADDR": "testclient"}
- assert set(event["request"]["headers"]) == {
- "accept",
- "accept-encoding",
- "connection",
- "host",
- "user-agent",
- "foo",
- }
- assert event["request"]["query_string"] == "foo=bar"
- assert event["request"]["url"].endswith("/sync-message")
- assert event["request"]["method"] == "GET"
+@pytest.fixture
+def asgi3_app_with_error():
+ async def app(scope, receive, send):
+ await send(
+ {
+ "type": "http.response.start",
+ "status": 200,
+ "headers": [
+ [b"content-type", b"text/plain"],
+ ],
+ }
+ )
- # Assert that state is not leaked
- events.clear()
- capture_message("foo")
- (event,) = events
+ 1 / 0
- assert "request" not in event
- assert "transaction" not in event
+ await send(
+ {
+ "type": "http.response.body",
+ "body": b"Hello, world!",
+ }
+ )
+ return app
-def test_async_request_data(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
- client = TestClient(app)
- response = client.get("/async-message?foo=bar")
+@pytest.fixture
+def asgi3_app_with_error_and_msg():
+ async def app(scope, receive, send):
+ await send(
+ {
+ "type": "http.response.start",
+ "status": 200,
+ "headers": [
+ [b"content-type", b"text/plain"],
+ ],
+ }
+ )
- assert response.status_code == 200
+ capture_message("Let's try dividing by 0")
+ 1 / 0
- (event,) = events
- assert event["transaction"] == "tests.integrations.asgi.test_asgi.app..hi2"
- assert event["request"]["env"] == {"REMOTE_ADDR": "testclient"}
- assert set(event["request"]["headers"]) == {
- "accept",
- "accept-encoding",
- "connection",
- "host",
- "user-agent",
- }
- assert event["request"]["query_string"] == "foo=bar"
- assert event["request"]["url"].endswith("/async-message")
- assert event["request"]["method"] == "GET"
+ await send(
+ {
+ "type": "http.response.body",
+ "body": b"Hello, world!",
+ }
+ )
- # Assert that state is not leaked
- events.clear()
- capture_message("foo")
- (event,) = events
+ return app
- assert "request" not in event
- assert "transaction" not in event
+@pytest.fixture
+def asgi3_ws_app():
+ def message():
+ capture_message("Some message to the world!")
+ raise ValueError("Oh no")
-def test_errors(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
+ async def app(scope, receive, send):
+ await send(
+ {
+ "type": "websocket.send",
+ "text": message(),
+ }
+ )
- @app.route("/error")
- def myerror(request):
- raise ValueError("oh no")
+ return app
- client = TestClient(app, raise_server_exceptions=False)
- response = client.get("/error")
- assert response.status_code == 500
+@minimum_python_36
+def test_invalid_transaction_style(asgi3_app):
+ with pytest.raises(ValueError) as exp:
+ SentryAsgiMiddleware(asgi3_app, transaction_style="URL")
- (event,) = events
assert (
- event["transaction"]
- == "tests.integrations.asgi.test_asgi.test_errors..myerror"
- )
- (exception,) = event["exception"]["values"]
-
- assert exception["type"] == "ValueError"
- assert exception["value"] == "oh no"
- assert any(
- frame["filename"].endswith("tests/integrations/asgi/test_asgi.py")
- for frame in exception["stacktrace"]["frames"]
+ str(exp.value)
+ == "Invalid value for transaction_style: URL (must be in ('endpoint', 'url'))"
)
-def test_websocket(sentry_init, capture_events, request):
- sentry_init(debug=True, send_default_pii=True)
-
- # Bind client to main thread because context propagation for the websocket
- # client does not work.
- Hub.main.bind_client(Hub.current.client)
- request.addfinalizer(lambda: Hub.main.bind_client(None))
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_capture_transaction(
+ sentry_init,
+ asgi3_app,
+ capture_events,
+):
+ sentry_init(send_default_pii=True, traces_sample_rate=1.0)
+ app = SentryAsgiMiddleware(asgi3_app)
+
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/?somevalue=123")
+
+ (transaction_event,) = events
+
+ assert transaction_event["type"] == "transaction"
+ assert transaction_event["transaction"] == "generic ASGI request"
+ assert transaction_event["contexts"]["trace"]["op"] == "http.server"
+ assert transaction_event["request"] == {
+ "headers": {
+ "host": "localhost",
+ "remote-addr": "127.0.0.1",
+ "user-agent": "ASGI-Test-Client",
+ },
+ "method": "GET",
+ "query_string": "somevalue=123",
+ "url": "http://localhost/",
+ }
- events = capture_events()
- from starlette.testclient import TestClient
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_capture_transaction_with_error(
+ sentry_init,
+ asgi3_app_with_error,
+ capture_events,
+ DictionaryContaining, # noqa: N803
+):
+ sentry_init(send_default_pii=True, traces_sample_rate=1.0)
+ app = SentryAsgiMiddleware(asgi3_app_with_error)
+
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/")
+
+ (error_event, transaction_event) = events
+
+ assert error_event["transaction"] == "generic ASGI request"
+ assert error_event["contexts"]["trace"]["op"] == "http.server"
+ assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
+ assert error_event["exception"]["values"][0]["value"] == "division by zero"
+ assert error_event["exception"]["values"][0]["mechanism"]["handled"] is False
+ assert error_event["exception"]["values"][0]["mechanism"]["type"] == "asgi"
+
+ assert transaction_event["type"] == "transaction"
+ assert transaction_event["contexts"]["trace"] == DictionaryContaining(
+ error_event["contexts"]["trace"]
+ )
+ assert transaction_event["contexts"]["trace"]["status"] == "internal_error"
+ assert transaction_event["transaction"] == error_event["transaction"]
+ assert transaction_event["request"] == error_event["request"]
- def message():
- capture_message("hi")
- raise ValueError("oh no")
- async def app(scope, receive, send):
- assert scope["type"] == "websocket"
- websocket = WebSocket(scope, receive=receive, send=send)
- await websocket.accept()
- await websocket.send_text(message())
- await websocket.close()
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_has_trace_if_performance_enabled(
+ sentry_init,
+ asgi3_app_with_error_and_msg,
+ capture_events,
+):
+ sentry_init(traces_sample_rate=1.0)
+ app = SentryAsgiMiddleware(asgi3_app_with_error_and_msg)
- app = SentryAsgiMiddleware(app)
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/")
- client = TestClient(app)
- with client.websocket_connect("/") as websocket:
- with pytest.raises(ValueError):
- websocket.receive_text()
+ msg_event, error_event, transaction_event = events
- msg_event, error_event = events
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
- assert msg_event["message"] == "hi"
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
- (exc,) = error_event["exception"]["values"]
- assert exc["type"] == "ValueError"
- assert exc["value"] == "oh no"
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
assert (
- msg_event["request"]
- == error_event["request"]
- == {
- "env": {"REMOTE_ADDR": "testclient"},
- "headers": {
- "accept": "*/*",
- "accept-encoding": "gzip, deflate",
- "connection": "upgrade",
- "host": "testserver",
- "sec-websocket-key": "testserver==",
- "sec-websocket-version": "13",
- "user-agent": "testclient",
- },
- "method": None,
- "query_string": None,
- "url": "ws://testserver/",
- }
+ error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ == msg_event["contexts"]["trace"]["trace_id"]
)
-def test_starlette_last_event_id(app, sentry_init, capture_events, request):
- sentry_init(send_default_pii=True)
- events = capture_events()
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_has_trace_if_performance_disabled(
+ sentry_init,
+ asgi3_app_with_error_and_msg,
+ capture_events,
+):
+ sentry_init()
+ app = SentryAsgiMiddleware(asgi3_app_with_error_and_msg)
- @app.route("/handlederror")
- def handlederror(request):
- raise ValueError("oh no")
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/")
- @app.exception_handler(500)
- def handler(*args, **kwargs):
- return PlainTextResponse(last_event_id(), status_code=500)
+ msg_event, error_event = events
- client = TestClient(SentryAsgiMiddleware(app), raise_server_exceptions=False)
- response = client.get("/handlederror")
- assert response.status_code == 500
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
- (event,) = events
- assert response.content.strip().decode("ascii") == event["event_id"]
- (exception,) = event["exception"]["values"]
- assert exception["type"] == "ValueError"
- assert exception["value"] == "oh no"
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
-def test_transaction(app, sentry_init, capture_events):
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_trace_from_headers_if_performance_enabled(
+ sentry_init,
+ asgi3_app_with_error_and_msg,
+ capture_events,
+):
sentry_init(traces_sample_rate=1.0)
- events = capture_events()
-
- @app.route("/tricks/kangaroo")
- def kangaroo_handler(request):
- return PlainTextResponse("dogs are great")
-
- client = TestClient(app)
- client.get("/tricks/kangaroo")
-
- event = events[0]
- assert event["type"] == "transaction"
- assert (
- event["transaction"]
- == "tests.integrations.asgi.test_asgi.test_transaction..kangaroo_handler"
- )
+ app = SentryAsgiMiddleware(asgi3_app_with_error_and_msg)
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
-def test_traces_sampler_gets_scope_in_sampling_context(
- app, sentry_init, DictionaryContaining # noqa: N803
-):
- traces_sampler = mock.Mock()
- sentry_init(traces_sampler=traces_sampler)
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/", headers={"sentry-trace": sentry_trace_header})
- @app.route("/tricks/kangaroo")
- def kangaroo_handler(request):
- return PlainTextResponse("dogs are great")
+ msg_event, error_event, transaction_event = events
- client = TestClient(app)
- client.get("/tricks/kangaroo")
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
- traces_sampler.assert_any_call(
- DictionaryContaining(
- {
- # starlette just uses a dictionary to hold the scope
- "asgi_scope": DictionaryContaining(
- {"method": "GET", "path": "/tricks/kangaroo"}
- )
- }
- )
- )
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
-def test_x_forwarded_for(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert transaction_event["contexts"]["trace"]["trace_id"] == trace_id
- client = TestClient(app)
- response = client.get("/sync-message", headers={"X-Forwarded-For": "testproxy"})
- assert response.status_code == 200
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_trace_from_headers_if_performance_disabled(
+ sentry_init,
+ asgi3_app_with_error_and_msg,
+ capture_events,
+):
+ sentry_init()
+ app = SentryAsgiMiddleware(asgi3_app_with_error_and_msg)
- (event,) = events
- assert event["request"]["env"] == {"REMOTE_ADDR": "testproxy"}
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app) as client:
+ events = capture_events()
+ await client.get("/", headers={"sentry-trace": sentry_trace_header})
-def test_x_forwarded_for_multiple_entries(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
+ msg_event, error_event = events
- client = TestClient(app)
- response = client.get(
- "/sync-message", headers={"X-Forwarded-For": "testproxy1,testproxy2,testproxy3"}
- )
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
- assert response.status_code == 200
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
- (event,) = events
- assert event["request"]["env"] == {"REMOTE_ADDR": "testproxy1"}
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_websocket(sentry_init, asgi3_ws_app, capture_events, request):
+ sentry_init(debug=True, send_default_pii=True)
-def test_x_real_ip(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
events = capture_events()
- client = TestClient(app)
- response = client.get("/sync-message", headers={"X-Real-IP": "1.2.3.4"})
+ asgi3_ws_app = SentryAsgiMiddleware(asgi3_ws_app)
- assert response.status_code == 200
+ scope = {
+ "type": "websocket",
+ "endpoint": asgi3_app,
+ "client": ("127.0.0.1", 60457),
+ "route": "some_url",
+ "headers": [
+ ("accept", "*/*"),
+ ],
+ }
- (event,) = events
- assert event["request"]["env"] == {"REMOTE_ADDR": "1.2.3.4"}
+ with pytest.raises(ValueError):
+ async with TestClient(asgi3_ws_app, scope=scope) as client:
+ async with client.websocket_connect("/ws") as ws:
+ await ws.receive_text()
+ msg_event, error_event = events
-def test_auto_session_tracking_with_aggregates(app, sentry_init, capture_envelopes):
- """
- Test for correct session aggregates in auto session tracking.
- """
+ assert msg_event["message"] == "Some message to the world!"
- @app.route("/dogs/are/great/")
- @app.route("/trigger/an/error/")
- def great_dogs_handler(request):
- if request["path"] != "/dogs/are/great/":
- 1 / 0
- return PlainTextResponse("dogs are great")
+ (exc,) = error_event["exception"]["values"]
+ assert exc["type"] == "ValueError"
+ assert exc["value"] == "Oh no"
- sentry_init(traces_sample_rate=1.0)
- envelopes = capture_envelopes()
- app = SentryAsgiMiddleware(app)
- client = TestClient(app, raise_server_exceptions=False)
- client.get("/dogs/are/great/")
- client.get("/dogs/are/great/")
- client.get("/trigger/an/error/")
+@minimum_python_36
+@pytest.mark.asyncio
+async def test_auto_session_tracking_with_aggregates(
+ sentry_init, asgi3_app, capture_envelopes
+):
+ sentry_init(send_default_pii=True, traces_sample_rate=1.0)
+ app = SentryAsgiMiddleware(asgi3_app)
+
+ scope = {
+ "endpoint": asgi3_app,
+ "client": ("127.0.0.1", 60457),
+ }
+ with pytest.raises(ZeroDivisionError):
+ envelopes = capture_envelopes()
+ async with TestClient(app, scope=scope) as client:
+ scope["route"] = "/some/fine/url"
+ await client.get("/some/fine/url")
+ scope["route"] = "/some/fine/url"
+ await client.get("/some/fine/url")
+ scope["route"] = "/trigger/error"
+ await client.get("/trigger/error")
sentry_sdk.flush()
@@ -323,12 +371,220 @@ def great_dogs_handler(request):
for envelope in envelopes:
count_item_types[envelope.items[0].type] += 1
- assert count_item_types["transaction"] == 3
+ assert count_item_types["transaction"] == 4
assert count_item_types["event"] == 1
assert count_item_types["sessions"] == 1
- assert len(envelopes) == 5
+ assert len(envelopes) == 6
session_aggregates = envelopes[-1].items[0].payload.json["aggregates"]
- assert session_aggregates[0]["exited"] == 2
+ assert session_aggregates[0]["exited"] == 3
assert session_aggregates[0]["crashed"] == 1
assert len(session_aggregates) == 1
+
+
+@minimum_python_36
+@pytest.mark.parametrize(
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ (
+ "/message",
+ "url",
+ "generic ASGI request",
+ "route",
+ ),
+ (
+ "/message",
+ "endpoint",
+ "tests.integrations.asgi.test_asgi.asgi3_app_with_error..app",
+ "component",
+ ),
+ ],
+)
+@pytest.mark.asyncio
+async def test_transaction_style(
+ sentry_init,
+ asgi3_app_with_error,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
+):
+ sentry_init(send_default_pii=True, traces_sample_rate=1.0)
+ app = SentryAsgiMiddleware(
+ asgi3_app_with_error, transaction_style=transaction_style
+ )
+
+ scope = {
+ "endpoint": asgi3_app_with_error,
+ "route": url,
+ "client": ("127.0.0.1", 60457),
+ }
+
+ with pytest.raises(ZeroDivisionError):
+ async with TestClient(app, scope=scope) as client:
+ events = capture_events()
+ await client.get(url)
+
+ (_, transaction_event) = events
+
+ assert transaction_event["transaction"] == expected_transaction
+ assert transaction_event["transaction_info"] == {"source": expected_source}
+
+
+def mock_asgi2_app():
+ pass
+
+
+class MockAsgi2App:
+ def __call__():
+ pass
+
+
+class MockAsgi3App(MockAsgi2App):
+ def __await__():
+ pass
+
+ async def __call__():
+ pass
+
+
+@minimum_python_36
+def test_looks_like_asgi3(asgi3_app):
+ # branch: inspect.isclass(app)
+ assert _looks_like_asgi3(MockAsgi3App)
+ assert not _looks_like_asgi3(MockAsgi2App)
+
+ # branch: inspect.isfunction(app)
+ assert _looks_like_asgi3(asgi3_app)
+ assert not _looks_like_asgi3(mock_asgi2_app)
+
+ # breanch: else
+ asgi3 = MockAsgi3App()
+ assert _looks_like_asgi3(asgi3)
+ asgi2 = MockAsgi2App()
+ assert not _looks_like_asgi3(asgi2)
+
+
+@minimum_python_36
+def test_get_ip_x_forwarded_for():
+ headers = [
+ (b"x-forwarded-for", b"8.8.8.8"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "8.8.8.8"
+
+ # x-forwarded-for overrides x-real-ip
+ headers = [
+ (b"x-forwarded-for", b"8.8.8.8"),
+ (b"x-real-ip", b"10.10.10.10"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "8.8.8.8"
+
+ # when multiple x-forwarded-for headers are, the first is taken
+ headers = [
+ (b"x-forwarded-for", b"5.5.5.5"),
+ (b"x-forwarded-for", b"6.6.6.6"),
+ (b"x-forwarded-for", b"7.7.7.7"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "5.5.5.5"
+
+
+@minimum_python_36
+def test_get_ip_x_real_ip():
+ headers = [
+ (b"x-real-ip", b"10.10.10.10"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "10.10.10.10"
+
+ # x-forwarded-for overrides x-real-ip
+ headers = [
+ (b"x-forwarded-for", b"8.8.8.8"),
+ (b"x-real-ip", b"10.10.10.10"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "8.8.8.8"
+
+
+@minimum_python_36
+def test_get_ip():
+ # if now headers are provided the ip is taken from the client.
+ headers = []
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "127.0.0.1"
+
+ # x-forwarded-for header overides the ip from client
+ headers = [
+ (b"x-forwarded-for", b"8.8.8.8"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "8.8.8.8"
+
+ # x-real-for header overides the ip from client
+ headers = [
+ (b"x-real-ip", b"10.10.10.10"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ ip = middleware._get_ip(scope)
+ assert ip == "10.10.10.10"
+
+
+@minimum_python_36
+def test_get_headers():
+ headers = [
+ (b"x-real-ip", b"10.10.10.10"),
+ (b"some_header", b"123"),
+ (b"some_header", b"abc"),
+ ]
+ scope = {
+ "client": ("127.0.0.1", 60457),
+ "headers": headers,
+ }
+ middleware = SentryAsgiMiddleware({})
+ headers = middleware._get_headers(scope)
+ assert headers == {
+ "x-real-ip": "10.10.10.10",
+ "some_header": "123, abc",
+ }
diff --git a/tests/integrations/asgi/test_fastapi.py b/tests/integrations/asgi/test_fastapi.py
deleted file mode 100644
index 518b8544b2..0000000000
--- a/tests/integrations/asgi/test_fastapi.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import sys
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from sentry_sdk import capture_message
-from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
-
-
-@pytest.fixture
-def app():
- app = FastAPI()
-
- @app.get("/users/{user_id}")
- async def get_user(user_id: str):
- capture_message("hi", level="error")
- return {"user_id": user_id}
-
- app.add_middleware(SentryAsgiMiddleware, transaction_style="url")
-
- return app
-
-
-@pytest.mark.skipif(sys.version_info < (3, 7), reason="requires python3.7 or higher")
-def test_fastapi_transaction_style(sentry_init, app, capture_events):
- sentry_init(send_default_pii=True)
- events = capture_events()
-
- client = TestClient(app)
- response = client.get("/users/rick")
-
- assert response.status_code == 200
-
- (event,) = events
- assert event["transaction"] == "/users/{user_id}"
- assert event["request"]["env"] == {"REMOTE_ADDR": "testclient"}
- assert event["request"]["url"].endswith("/users/rick")
- assert event["request"]["method"] == "GET"
-
- # Assert that state is not leaked
- events.clear()
- capture_message("foo")
- (event,) = events
-
- assert "request" not in event
- assert "transaction" not in event
diff --git a/tests/integrations/asyncio/__init__.py b/tests/integrations/asyncio/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/integrations/asyncio/test_asyncio_py3.py b/tests/integrations/asyncio/test_asyncio_py3.py
new file mode 100644
index 0000000000..98106ed01f
--- /dev/null
+++ b/tests/integrations/asyncio/test_asyncio_py3.py
@@ -0,0 +1,172 @@
+import asyncio
+import sys
+
+import pytest
+
+import sentry_sdk
+from sentry_sdk.consts import OP
+from sentry_sdk.integrations.asyncio import AsyncioIntegration
+
+
+minimum_python_37 = pytest.mark.skipif(
+ sys.version_info < (3, 7), reason="Asyncio tests need Python >= 3.7"
+)
+
+
+async def foo():
+ await asyncio.sleep(0.01)
+
+
+async def bar():
+ await asyncio.sleep(0.01)
+
+
+async def boom():
+ 1 / 0
+
+
+@pytest.fixture(scope="session")
+def event_loop(request):
+ """Create an instance of the default event loop for each test case."""
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
+
+
+@minimum_python_37
+@pytest.mark.asyncio
+async def test_create_task(
+ sentry_init,
+ capture_events,
+ event_loop,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ integrations=[
+ AsyncioIntegration(),
+ ],
+ )
+
+ events = capture_events()
+
+ with sentry_sdk.start_transaction(name="test_transaction_for_create_task"):
+ with sentry_sdk.start_span(op="root", description="not so important"):
+ tasks = [event_loop.create_task(foo()), event_loop.create_task(bar())]
+ await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
+
+ sentry_sdk.flush()
+
+ (transaction_event,) = events
+
+ assert transaction_event["spans"][0]["op"] == "root"
+ assert transaction_event["spans"][0]["description"] == "not so important"
+
+ assert transaction_event["spans"][1]["op"] == OP.FUNCTION
+ assert transaction_event["spans"][1]["description"] == "foo"
+ assert (
+ transaction_event["spans"][1]["parent_span_id"]
+ == transaction_event["spans"][0]["span_id"]
+ )
+
+ assert transaction_event["spans"][2]["op"] == OP.FUNCTION
+ assert transaction_event["spans"][2]["description"] == "bar"
+ assert (
+ transaction_event["spans"][2]["parent_span_id"]
+ == transaction_event["spans"][0]["span_id"]
+ )
+
+
+@minimum_python_37
+@pytest.mark.asyncio
+async def test_gather(
+ sentry_init,
+ capture_events,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ integrations=[
+ AsyncioIntegration(),
+ ],
+ )
+
+ events = capture_events()
+
+ with sentry_sdk.start_transaction(name="test_transaction_for_gather"):
+ with sentry_sdk.start_span(op="root", description="not so important"):
+ await asyncio.gather(foo(), bar(), return_exceptions=True)
+
+ sentry_sdk.flush()
+
+ (transaction_event,) = events
+
+ assert transaction_event["spans"][0]["op"] == "root"
+ assert transaction_event["spans"][0]["description"] == "not so important"
+
+ assert transaction_event["spans"][1]["op"] == OP.FUNCTION
+ assert transaction_event["spans"][1]["description"] == "foo"
+ assert (
+ transaction_event["spans"][1]["parent_span_id"]
+ == transaction_event["spans"][0]["span_id"]
+ )
+
+ assert transaction_event["spans"][2]["op"] == OP.FUNCTION
+ assert transaction_event["spans"][2]["description"] == "bar"
+ assert (
+ transaction_event["spans"][2]["parent_span_id"]
+ == transaction_event["spans"][0]["span_id"]
+ )
+
+
+@minimum_python_37
+@pytest.mark.asyncio
+async def test_exception(
+ sentry_init,
+ capture_events,
+ event_loop,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ integrations=[
+ AsyncioIntegration(),
+ ],
+ )
+
+ events = capture_events()
+
+ with sentry_sdk.start_transaction(name="test_exception"):
+ with sentry_sdk.start_span(op="root", description="not so important"):
+ tasks = [event_loop.create_task(boom()), event_loop.create_task(bar())]
+ await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
+
+ sentry_sdk.flush()
+
+ (error_event, _) = events
+
+ assert error_event["transaction"] == "test_exception"
+ assert error_event["contexts"]["trace"]["op"] == "function"
+ assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
+ assert error_event["exception"]["values"][0]["value"] == "division by zero"
+ assert error_event["exception"]["values"][0]["mechanism"]["handled"] is False
+ assert error_event["exception"]["values"][0]["mechanism"]["type"] == "asyncio"
+
+
+@minimum_python_37
+@pytest.mark.asyncio
+async def test_task_result(sentry_init):
+ sentry_init(
+ integrations=[
+ AsyncioIntegration(),
+ ],
+ )
+
+ async def add(a, b):
+ return a + b
+
+ result = await asyncio.create_task(add(1, 2))
+ assert result == 3, result
diff --git a/tests/integrations/aws_lambda/client.py b/tests/integrations/aws_lambda/client.py
index 784a4a9006..d8e430f3d7 100644
--- a/tests/integrations/aws_lambda/client.py
+++ b/tests/integrations/aws_lambda/client.py
@@ -25,11 +25,9 @@ def build_no_code_serverless_function_and_layer(
sdk by creating a layer containing the Python-sdk, and then creating a func
that uses that layer
"""
- from scripts.build_awslambda_layer import (
- build_packaged_zip,
- )
+ from scripts.build_aws_lambda_layer import build_layer_dir
- build_packaged_zip(dest_abs_path=tmpdir, dest_zip_filename="serverless-ball.zip")
+ build_layer_dir(dest_abs_path=tmpdir)
with open(os.path.join(tmpdir, "serverless-ball.zip"), "rb") as serverless_zip:
response = client.publish_layer_version(
diff --git a/tests/integrations/aws_lambda/test_aws.py b/tests/integrations/aws_lambda/test_aws.py
index c9084beb14..f042125c99 100644
--- a/tests/integrations/aws_lambda/test_aws.py
+++ b/tests/integrations/aws_lambda/test_aws.py
@@ -25,8 +25,6 @@
boto3 = pytest.importorskip("boto3")
LAMBDA_PRELUDE = """
-from __future__ import print_function
-
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration, get_lambda_bootstrap
import sentry_sdk
import json
@@ -106,7 +104,11 @@ def lambda_client():
@pytest.fixture(
- params=["python3.6", "python3.7", "python3.8", "python3.9", "python2.7"]
+ params=[
+ "python3.7",
+ "python3.8",
+ "python3.9",
+ ]
)
def lambda_runtime(request):
return request.param
@@ -189,7 +191,8 @@ def test_handler(event, context):
assert frame1["in_app"] is True
- assert exception["mechanism"] == {"type": "aws_lambda", "handled": False}
+ assert exception["mechanism"]["type"] == "aws_lambda"
+ assert not exception["mechanism"]["handled"]
assert event["extra"]["lambda"]["function_name"].startswith("test_function_")
@@ -283,9 +286,6 @@ def test_handler(event, context):
def test_init_error(run_lambda_function, lambda_runtime):
- if lambda_runtime == "python2.7":
- pytest.skip("initialization error not supported on Python 2.7")
-
envelopes, events, response = run_lambda_function(
LAMBDA_PRELUDE
+ (
@@ -327,7 +327,8 @@ def test_handler(event, context):
"WARNING : Function is expected to get timed out. Configured timeout duration = 3 seconds.",
)
- assert exception["mechanism"] == {"type": "threading", "handled": False}
+ assert exception["mechanism"]["type"] == "threading"
+ assert not exception["mechanism"]["handled"]
assert event["extra"]["lambda"]["function_name"].startswith("test_function_")
@@ -360,8 +361,9 @@ def test_handler(event, context):
(envelope,) = envelopes
assert envelope["type"] == "transaction"
- assert envelope["contexts"]["trace"]["op"] == "serverless.function"
+ assert envelope["contexts"]["trace"]["op"] == "function.aws.lambda"
assert envelope["transaction"].startswith("test_function_")
+ assert envelope["transaction_info"] == {"source": "component"}
assert envelope["transaction"] in envelope["request"]["url"]
@@ -388,8 +390,9 @@ def test_handler(event, context):
(envelope,) = envelopes
assert envelope["type"] == "transaction"
- assert envelope["contexts"]["trace"]["op"] == "serverless.function"
+ assert envelope["contexts"]["trace"]["op"] == "function.aws.lambda"
assert envelope["transaction"].startswith("test_function_")
+ assert envelope["transaction_info"] == {"source": "component"}
assert envelope["transaction"] in envelope["request"]["url"]
@@ -474,7 +477,7 @@ def test_handler(event, context):
error_event = events[0]
assert error_event["level"] == "error"
- assert error_event["contexts"]["trace"]["op"] == "serverless.function"
+ assert error_event["contexts"]["trace"]["op"] == "function.aws.lambda"
function_name = error_event["extra"]["lambda"]["function_name"]
assert function_name.startswith("test_function_")
@@ -521,8 +524,8 @@ def test_handler(event, context):
def test_traces_sampler_gets_correct_values_in_sampling_context(
run_lambda_function,
DictionaryContaining, # noqa:N803
- ObjectDescribedBy, # noqa:N803
- StringContaining, # noqa:N803
+ ObjectDescribedBy,
+ StringContaining,
):
# TODO: This whole thing is a little hacky, specifically around the need to
# get `conftest.py` code into the AWS runtime, which is why there's both
@@ -662,3 +665,139 @@ def test_handler(event, context):
assert response["Payload"]["errorMessage"] == "something went wrong"
assert "sentry_handler" in response["LogResult"][3].decode("utf-8")
+
+
+def test_error_has_new_trace_context_performance_enabled(run_lambda_function):
+ envelopes, _, _ = run_lambda_function(
+ LAMBDA_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=1.0)
+
+ def test_handler(event, context):
+ sentry_sdk.capture_message("hi")
+ raise Exception("something went wrong")
+ """
+ ),
+ payload=b'{"foo": "bar"}',
+ )
+
+ (msg_event, error_event, transaction_event) = envelopes
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_new_trace_context_performance_disabled(run_lambda_function):
+ _, events, _ = run_lambda_function(
+ LAMBDA_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=None) # this is the default, just added for clarity
+
+ def test_handler(event, context):
+ sentry_sdk.capture_message("hi")
+ raise Exception("something went wrong")
+ """
+ ),
+ payload=b'{"foo": "bar"}',
+ )
+
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_existing_trace_context_performance_enabled(run_lambda_function):
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ envelopes, _, _ = run_lambda_function(
+ LAMBDA_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=1.0)
+
+ def test_handler(event, context):
+ sentry_sdk.capture_message("hi")
+ raise Exception("something went wrong")
+ """
+ ),
+ payload=b'{"sentry_trace": "%s"}' % sentry_trace_header.encode(),
+ )
+
+ (msg_event, error_event, transaction_event) = envelopes
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
+
+
+def test_error_has_existing_trace_context_performance_disabled(run_lambda_function):
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ _, events, _ = run_lambda_function(
+ LAMBDA_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=None) # this is the default, just added for clarity
+
+ def test_handler(event, context):
+ sentry_sdk.capture_message("hi")
+ raise Exception("something went wrong")
+ """
+ ),
+ payload=b'{"sentry_trace": "%s"}' % sentry_trace_header.encode(),
+ )
+
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
diff --git a/tests/integrations/boto3/test_s3.py b/tests/integrations/boto3/test_s3.py
index 67376b55d4..5812c2c1bb 100644
--- a/tests/integrations/boto3/test_s3.py
+++ b/tests/integrations/boto3/test_s3.py
@@ -1,9 +1,17 @@
+import pytest
+
+import boto3
+
from sentry_sdk import Hub
from sentry_sdk.integrations.boto3 import Boto3Integration
from tests.integrations.boto3.aws_mock import MockResponse
from tests.integrations.boto3 import read_fixture
-import boto3
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
session = boto3.Session(
aws_access_key_id="-",
@@ -30,7 +38,7 @@ def test_basic(sentry_init, capture_events):
assert event["type"] == "transaction"
assert len(event["spans"]) == 1
(span,) = event["spans"]
- assert span["op"] == "aws.request"
+ assert span["op"] == "http.client"
assert span["description"] == "aws.s3.ListObjects"
@@ -53,11 +61,19 @@ def test_streaming(sentry_init, capture_events):
(event,) = events
assert event["type"] == "transaction"
assert len(event["spans"]) == 2
+
span1 = event["spans"][0]
- assert span1["op"] == "aws.request"
+ assert span1["op"] == "http.client"
assert span1["description"] == "aws.s3.GetObject"
+ assert span1["data"] == {
+ "http.method": "GET",
+ "aws.request.url": "https://bucket.s3.amazonaws.com/foo.pdf",
+ "http.fragment": "",
+ "http.query": "",
+ }
+
span2 = event["spans"][1]
- assert span2["op"] == "aws.request.stream"
+ assert span2["op"] == "http.client.stream"
assert span2["description"] == "aws.s3.GetObject"
assert span2["parent_span_id"] == span1["span_id"]
@@ -80,6 +96,34 @@ def test_streaming_close(sentry_init, capture_events):
assert event["type"] == "transaction"
assert len(event["spans"]) == 2
span1 = event["spans"][0]
- assert span1["op"] == "aws.request"
+ assert span1["op"] == "http.client"
span2 = event["spans"][1]
- assert span2["op"] == "aws.request.stream"
+ assert span2["op"] == "http.client.stream"
+
+
+@pytest.mark.tests_internal_exceptions
+def test_omit_url_data_if_parsing_fails(sentry_init, capture_events):
+ sentry_init(traces_sample_rate=1.0, integrations=[Boto3Integration()])
+ events = capture_events()
+
+ s3 = session.resource("s3")
+
+ with mock.patch(
+ "sentry_sdk.integrations.boto3.parse_url",
+ side_effect=ValueError,
+ ):
+ with Hub.current.start_transaction() as transaction, MockResponse(
+ s3.meta.client, 200, {}, read_fixture("s3_list.xml")
+ ):
+ bucket = s3.Bucket("bucket")
+ items = [obj for obj in bucket.objects.all()]
+ assert len(items) == 2
+ assert items[0].key == "foo.txt"
+ assert items[1].key == "bar.txt"
+ transaction.finish()
+
+ (event,) = events
+ assert event["spans"][0]["data"] == {
+ "http.method": "GET",
+ # no url data
+ }
diff --git a/tests/integrations/bottle/test_bottle.py b/tests/integrations/bottle/test_bottle.py
index 16aacb55c5..eed5e990b9 100644
--- a/tests/integrations/bottle/test_bottle.py
+++ b/tests/integrations/bottle/test_bottle.py
@@ -8,6 +8,7 @@
from io import BytesIO
from bottle import Bottle, debug as set_debug, abort, redirect
from sentry_sdk import capture_message
+from sentry_sdk.serializer import MAX_DATABAG_BREADTH
from sentry_sdk.integrations.logging import LoggingIntegration
from werkzeug.test import Client
@@ -24,6 +25,11 @@ def hi():
capture_message("hi")
return "ok"
+ @app.route("/message/")
+ def hi_with_id(message_id):
+ capture_message("hi")
+ return "ok"
+
@app.route("/message-named-route", name="hi")
def named_hi():
capture_message("hi")
@@ -55,20 +61,21 @@ def test_has_context(sentry_init, app, capture_events, get_client):
@pytest.mark.parametrize(
- "url,transaction_style,expected_transaction",
+ "url,transaction_style,expected_transaction,expected_source",
[
- ("/message", "endpoint", "hi"),
- ("/message", "url", "/message"),
- ("/message-named-route", "endpoint", "hi"),
+ ("/message", "endpoint", "hi", "component"),
+ ("/message", "url", "/message", "route"),
+ ("/message/123456", "url", "/message/", "route"),
+ ("/message-named-route", "endpoint", "hi", "component"),
],
)
def test_transaction_style(
sentry_init,
- app,
- capture_events,
+ url,
transaction_style,
expected_transaction,
- url,
+ expected_source,
+ capture_events,
get_client,
):
sentry_init(
@@ -79,11 +86,14 @@ def test_transaction_style(
events = capture_events()
client = get_client()
- response = client.get("/message")
+ response = client.get(url)
assert response[1] == "200 OK"
(event,) = events
+ # We use endswith() because in Python 2.7 it is "test_bottle.hi"
+ # and in later Pythons "test_bottle.app..hi"
assert event["transaction"].endswith(expected_transaction)
+ assert event["transaction_info"] == {"source": expected_source}
@pytest.mark.parametrize("debug", (True, False), ids=["debug", "nodebug"])
@@ -141,9 +151,9 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]["bar"]) == 512
+ assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
@@ -191,12 +201,12 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]) == 512
+ assert len(event["request"]["data"]["foo"]) == 1024
-@pytest.mark.parametrize("input_char", [u"a", b"a"])
+@pytest.mark.parametrize("input_char", ["a", b"a"])
def test_too_large_raw_request(
sentry_init, input_char, capture_events, app, get_client
):
@@ -225,9 +235,7 @@ def index():
assert response[1] == "200 OK"
(event,) = events
- assert event["_meta"]["request"]["data"] == {
- "": {"len": 2000, "rem": [["!config", "x", 0, 2000]]}
- }
+ assert event["_meta"]["request"]["data"] == {"": {"rem": [["!config", "x"]]}}
assert not event["request"]["data"]
@@ -256,19 +264,49 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]) == 512
+ assert len(event["request"]["data"]["foo"]) == 1024
assert event["_meta"]["request"]["data"]["file"] == {
"": {
- "len": -1,
- "rem": [["!raw", "x", 0, -1]],
- } # bottle default content-length is -1
+ "rem": [["!raw", "x"]],
+ }
}
assert not event["request"]["data"]["file"]
+def test_json_not_truncated_if_request_bodies_is_always(
+ sentry_init, capture_events, app, get_client
+):
+ sentry_init(
+ integrations=[bottle_sentry.BottleIntegration()], request_bodies="always"
+ )
+
+ data = {
+ "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
+ }
+
+ @app.route("/", method="POST")
+ def index():
+ import bottle
+
+ assert bottle.request.json == data
+ assert bottle.request.body.read() == json.dumps(data).encode("ascii")
+ capture_message("hi")
+ return "ok"
+
+ events = capture_events()
+
+ client = get_client()
+
+ response = client.post("/", content_type="application/json", data=json.dumps(data))
+ assert response[1] == "200 OK"
+
+ (event,) = events
+ assert event["request"]["data"] == data
+
+
@pytest.mark.parametrize(
"integrations",
[
@@ -348,10 +386,8 @@ def crashing_app(environ, start_response):
assert error is exc.value
(event,) = events
- assert event["exception"]["values"][0]["mechanism"] == {
- "type": "bottle",
- "handled": False,
- }
+ assert event["exception"]["values"][0]["mechanism"]["type"] == "bottle"
+ assert event["exception"]["values"][0]["mechanism"]["handled"] is False
def test_500(sentry_init, capture_events, app, get_client):
diff --git a/tests/integrations/celery/__init__.py b/tests/integrations/celery/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/integrations/celery/test_celery.py b/tests/integrations/celery/test_celery.py
index bdf1706c59..d120d34a12 100644
--- a/tests/integrations/celery/test_celery.py
+++ b/tests/integrations/celery/test_celery.py
@@ -5,11 +5,13 @@
pytest.importorskip("celery")
from sentry_sdk import Hub, configure_scope, start_transaction
-from sentry_sdk.integrations.celery import CeleryIntegration
+from sentry_sdk.integrations.celery import CeleryIntegration, _get_headers
+
from sentry_sdk._compat import text_type
from celery import Celery, VERSION
from celery.bin import worker
+from celery.signals import task_success
try:
from unittest import mock # python 3.3 and above
@@ -84,8 +86,14 @@ def celery(init_celery):
@pytest.fixture(
params=[
- lambda task, x, y: (task.delay(x, y), {"args": [x, y], "kwargs": {}}),
- lambda task, x, y: (task.apply_async((x, y)), {"args": [x, y], "kwargs": {}}),
+ lambda task, x, y: (
+ task.delay(x, y),
+ {"args": [x, y], "kwargs": {}},
+ ),
+ lambda task, x, y: (
+ task.apply_async((x, y)),
+ {"args": [x, y], "kwargs": {}},
+ ),
lambda task, x, y: (
task.apply_async(args=(x, y)),
{"args": [x, y], "kwargs": {}},
@@ -105,7 +113,8 @@ def celery_invocation(request):
return request.param
-def test_simple(capture_events, celery, celery_invocation):
+def test_simple_with_performance(capture_events, init_celery, celery_invocation):
+ celery = init_celery(traces_sample_rate=1.0)
events = capture_events()
@celery.task(name="dummy_task")
@@ -113,26 +122,61 @@ def dummy_task(x, y):
foo = 42 # noqa
return x / y
- with start_transaction() as transaction:
+ with start_transaction(op="unit test transaction") as transaction:
celery_invocation(dummy_task, 1, 2)
_, expected_context = celery_invocation(dummy_task, 1, 0)
- (event,) = events
+ (_, error_event, _, _) = events
- assert event["contexts"]["trace"]["trace_id"] == transaction.trace_id
- assert event["contexts"]["trace"]["span_id"] != transaction.span_id
- assert event["transaction"] == "dummy_task"
- assert "celery_task_id" in event["tags"]
- assert event["extra"]["celery-job"] == dict(
+ assert error_event["contexts"]["trace"]["trace_id"] == transaction.trace_id
+ assert error_event["contexts"]["trace"]["span_id"] != transaction.span_id
+ assert error_event["transaction"] == "dummy_task"
+ assert "celery_task_id" in error_event["tags"]
+ assert error_event["extra"]["celery-job"] == dict(
task_name="dummy_task", **expected_context
)
- (exception,) = event["exception"]["values"]
+ (exception,) = error_event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "celery"
assert exception["stacktrace"]["frames"][0]["vars"]["foo"] == "42"
+def test_simple_without_performance(capture_events, init_celery, celery_invocation):
+ celery = init_celery(traces_sample_rate=None)
+ events = capture_events()
+
+ @celery.task(name="dummy_task")
+ def dummy_task(x, y):
+ foo = 42 # noqa
+ return x / y
+
+ with configure_scope() as scope:
+ celery_invocation(dummy_task, 1, 2)
+ _, expected_context = celery_invocation(dummy_task, 1, 0)
+
+ (error_event,) = events
+
+ assert (
+ error_event["contexts"]["trace"]["trace_id"]
+ == scope._propagation_context["trace_id"]
+ )
+ assert (
+ error_event["contexts"]["trace"]["span_id"]
+ != scope._propagation_context["span_id"]
+ )
+ assert error_event["transaction"] == "dummy_task"
+ assert "celery_task_id" in error_event["tags"]
+ assert error_event["extra"]["celery-job"] == dict(
+ task_name="dummy_task", **expected_context
+ )
+
+ (exception,) = error_event["exception"]["values"]
+ assert exception["type"] == "ZeroDivisionError"
+ assert exception["mechanism"]["type"] == "celery"
+ assert exception["stacktrace"]["frames"][0]["vars"]["foo"] == "42"
+
+
@pytest.mark.parametrize("task_fails", [True, False], ids=["error", "success"])
def test_transaction_events(capture_events, init_celery, celery_invocation, task_fails):
celery = init_celery(traces_sample_rate=1.0)
@@ -155,9 +199,11 @@ def dummy_task(x, y):
assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
execution_event, submission_event = events
-
assert execution_event["transaction"] == "dummy_task"
+ assert execution_event["transaction_info"] == {"source": "task"}
+
assert submission_event["transaction"] == "submission"
+ assert submission_event["transaction_info"] == {"source": "custom"}
assert execution_event["type"] == submission_event["type"] == "transaction"
assert execution_event["contexts"]["trace"]["trace_id"] == transaction.trace_id
@@ -171,14 +217,14 @@ def dummy_task(x, y):
assert execution_event["spans"] == []
assert submission_event["spans"] == [
{
- u"description": u"dummy_task",
- u"op": "celery.submit",
- u"parent_span_id": submission_event["contexts"]["trace"]["span_id"],
- u"same_process_as_parent": True,
- u"span_id": submission_event["spans"][0]["span_id"],
- u"start_timestamp": submission_event["spans"][0]["start_timestamp"],
- u"timestamp": submission_event["spans"][0]["timestamp"],
- u"trace_id": text_type(transaction.trace_id),
+ "description": "dummy_task",
+ "op": "queue.submit.celery",
+ "parent_span_id": submission_event["contexts"]["trace"]["span_id"],
+ "same_process_as_parent": True,
+ "span_id": submission_event["spans"][0]["span_id"],
+ "start_timestamp": submission_event["spans"][0]["start_timestamp"],
+ "timestamp": submission_event["spans"][0]["timestamp"],
+ "trace_id": text_type(transaction.trace_id),
}
]
@@ -311,6 +357,8 @@ def dummy_task(self):
assert e["type"] == "ZeroDivisionError"
+# TODO: This test is hanging when running test with `tox --parallel auto`. Find out why and fix it!
+@pytest.mark.skip
@pytest.mark.forked
def test_redis_backend_trace_propagation(init_celery, capture_events_forksafe, tmpdir):
celery = init_celery(traces_sample_rate=1.0, backend="redis", debug=True)
@@ -338,8 +386,12 @@ def dummy_task(self):
submit_transaction = events.read_event()
assert submit_transaction["type"] == "transaction"
assert submit_transaction["transaction"] == "submit_celery"
- (span,) = submit_transaction["spans"]
- assert span["op"] == "celery.submit"
+
+ assert len(
+ submit_transaction["spans"]
+ ), 4 # Because redis integration was auto enabled
+ span = submit_transaction["spans"][0]
+ assert span["op"] == "queue.submit.celery"
assert span["description"] == "dummy_task"
event = events.read_event()
@@ -429,3 +481,29 @@ def dummy_task(x, y):
celery_invocation(dummy_task, 1, 0)
assert not events
+
+
+def test_task_headers(celery):
+ """
+ Test that the headers set in the Celery Beat auto-instrumentation are passed to the celery signal handlers
+ """
+ sentry_crons_setup = {
+ "sentry-monitor-slug": "some-slug",
+ "sentry-monitor-config": {"some": "config"},
+ "sentry-monitor-check-in-id": "123abc",
+ }
+
+ @celery.task(name="dummy_task")
+ def dummy_task(x, y):
+ return x + y
+
+ def crons_task_success(sender, **kwargs):
+ headers = _get_headers(sender)
+ assert headers == sentry_crons_setup
+
+ task_success.connect(crons_task_success)
+
+ # This is how the Celery Beat auto-instrumentation starts a task
+ # in the monkey patched version of `apply_async`
+ # in `sentry_sdk/integrations/celery.py::_wrap_apply_async()`
+ dummy_task.apply_async(args=(1, 0), headers=sentry_crons_setup)
diff --git a/tests/integrations/celery/test_celery_beat_crons.py b/tests/integrations/celery/test_celery_beat_crons.py
new file mode 100644
index 0000000000..636bcb545c
--- /dev/null
+++ b/tests/integrations/celery/test_celery_beat_crons.py
@@ -0,0 +1,326 @@
+import pytest
+
+pytest.importorskip("celery")
+
+from sentry_sdk.integrations.celery import (
+ _get_headers,
+ _get_humanized_interval,
+ _get_monitor_config,
+ _patch_beat_apply_entry,
+ crons_task_success,
+ crons_task_failure,
+ crons_task_retry,
+)
+from sentry_sdk.crons import MonitorStatus
+from celery.schedules import crontab, schedule
+
+try:
+ from unittest import mock # python 3.3 and above
+ from unittest.mock import MagicMock
+except ImportError:
+ import mock # python < 3.3
+ from mock import MagicMock
+
+
+def test_get_headers():
+ fake_task = MagicMock()
+ fake_task.request = {
+ "bla": "blub",
+ "foo": "bar",
+ }
+
+ assert _get_headers(fake_task) == {}
+
+ fake_task.request.update(
+ {
+ "headers": {
+ "bla": "blub",
+ },
+ }
+ )
+
+ assert _get_headers(fake_task) == {"bla": "blub"}
+
+ fake_task.request.update(
+ {
+ "headers": {
+ "headers": {
+ "tri": "blub",
+ "bar": "baz",
+ },
+ "bla": "blub",
+ },
+ }
+ )
+
+ assert _get_headers(fake_task) == {"bla": "blub", "tri": "blub", "bar": "baz"}
+
+
+@pytest.mark.parametrize(
+ "seconds, expected_tuple",
+ [
+ (0, (0, "second")),
+ (1, (1, "second")),
+ (0.00001, (0, "second")),
+ (59, (59, "second")),
+ (60, (1, "minute")),
+ (100, (1, "minute")),
+ (1000, (16, "minute")),
+ (10000, (2, "hour")),
+ (100000, (1, "day")),
+ (100000000, (1157, "day")),
+ ],
+)
+def test_get_humanized_interval(seconds, expected_tuple):
+ assert _get_humanized_interval(seconds) == expected_tuple
+
+
+def test_crons_task_success():
+ fake_task = MagicMock()
+ fake_task.request = {
+ "headers": {
+ "sentry-monitor-slug": "test123",
+ "sentry-monitor-check-in-id": "1234567890",
+ "sentry-monitor-start-timestamp-s": 200.1,
+ "sentry-monitor-config": {
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ "sentry-monitor-some-future-key": "some-future-value",
+ },
+ }
+
+ with mock.patch(
+ "sentry_sdk.integrations.celery.capture_checkin"
+ ) as mock_capture_checkin:
+ with mock.patch(
+ "sentry_sdk.integrations.celery._now_seconds_since_epoch",
+ return_value=500.5,
+ ):
+ crons_task_success(fake_task)
+
+ mock_capture_checkin.assert_called_once_with(
+ monitor_slug="test123",
+ monitor_config={
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ duration=300.4,
+ check_in_id="1234567890",
+ status=MonitorStatus.OK,
+ )
+
+
+def test_crons_task_failure():
+ fake_task = MagicMock()
+ fake_task.request = {
+ "headers": {
+ "sentry-monitor-slug": "test123",
+ "sentry-monitor-check-in-id": "1234567890",
+ "sentry-monitor-start-timestamp-s": 200.1,
+ "sentry-monitor-config": {
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ "sentry-monitor-some-future-key": "some-future-value",
+ },
+ }
+
+ with mock.patch(
+ "sentry_sdk.integrations.celery.capture_checkin"
+ ) as mock_capture_checkin:
+ with mock.patch(
+ "sentry_sdk.integrations.celery._now_seconds_since_epoch",
+ return_value=500.5,
+ ):
+ crons_task_failure(fake_task)
+
+ mock_capture_checkin.assert_called_once_with(
+ monitor_slug="test123",
+ monitor_config={
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ duration=300.4,
+ check_in_id="1234567890",
+ status=MonitorStatus.ERROR,
+ )
+
+
+def test_crons_task_retry():
+ fake_task = MagicMock()
+ fake_task.request = {
+ "headers": {
+ "sentry-monitor-slug": "test123",
+ "sentry-monitor-check-in-id": "1234567890",
+ "sentry-monitor-start-timestamp-s": 200.1,
+ "sentry-monitor-config": {
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ "sentry-monitor-some-future-key": "some-future-value",
+ },
+ }
+
+ with mock.patch(
+ "sentry_sdk.integrations.celery.capture_checkin"
+ ) as mock_capture_checkin:
+ with mock.patch(
+ "sentry_sdk.integrations.celery._now_seconds_since_epoch",
+ return_value=500.5,
+ ):
+ crons_task_retry(fake_task)
+
+ mock_capture_checkin.assert_called_once_with(
+ monitor_slug="test123",
+ monitor_config={
+ "schedule": {
+ "type": "interval",
+ "value": 3,
+ "unit": "day",
+ },
+ "timezone": "Europe/Vienna",
+ },
+ duration=300.4,
+ check_in_id="1234567890",
+ status=MonitorStatus.ERROR,
+ )
+
+
+def test_get_monitor_config_crontab():
+ app = MagicMock()
+ app.conf = MagicMock()
+ app.conf.timezone = "Europe/Vienna"
+
+ celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
+ monitor_config = _get_monitor_config(celery_schedule, app)
+ assert monitor_config == {
+ "schedule": {
+ "type": "crontab",
+ "value": "*/10 12 3 * *",
+ },
+ "timezone": "Europe/Vienna",
+ }
+ assert "unit" not in monitor_config["schedule"]
+
+
+def test_get_monitor_config_seconds():
+ app = MagicMock()
+ app.conf = MagicMock()
+ app.conf.timezone = "Europe/Vienna"
+
+ celery_schedule = schedule(run_every=3) # seconds
+ monitor_config = _get_monitor_config(celery_schedule, app)
+ assert monitor_config == {}
+
+
+def test_get_monitor_config_minutes():
+ app = MagicMock()
+ app.conf = MagicMock()
+ app.conf.timezone = "Europe/Vienna"
+
+ celery_schedule = schedule(run_every=60) # seconds
+ monitor_config = _get_monitor_config(celery_schedule, app)
+ assert monitor_config == {
+ "schedule": {
+ "type": "interval",
+ "value": 1,
+ "unit": "minute",
+ },
+ "timezone": "Europe/Vienna",
+ }
+
+
+def test_get_monitor_config_unknown():
+ app = MagicMock()
+ app.conf = MagicMock()
+ app.conf.timezone = "Europe/Vienna"
+
+ unknown_celery_schedule = MagicMock()
+ monitor_config = _get_monitor_config(unknown_celery_schedule, app)
+ assert monitor_config == {}
+
+
+def test_get_monitor_config_default_timezone():
+ app = MagicMock()
+ app.conf = MagicMock()
+ app.conf.timezone = None
+
+ celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
+
+ monitor_config = _get_monitor_config(celery_schedule, app)
+
+ assert monitor_config["timezone"] == "UTC"
+
+
+@pytest.mark.parametrize(
+ "task_name,exclude_beat_tasks,task_in_excluded_beat_tasks",
+ [
+ ["some_task_name", ["xxx", "some_task.*"], True],
+ ["some_task_name", ["xxx", "some_other_task.*"], False],
+ ],
+)
+def test_exclude_beat_tasks_option(
+ task_name, exclude_beat_tasks, task_in_excluded_beat_tasks
+):
+ """
+ Test excluding Celery Beat tasks from automatic instrumentation.
+ """
+ fake_apply_entry = MagicMock()
+
+ fake_scheduler = MagicMock()
+ fake_scheduler.apply_entry = fake_apply_entry
+
+ fake_integration = MagicMock()
+ fake_integration.exclude_beat_tasks = exclude_beat_tasks
+
+ fake_schedule_entry = MagicMock()
+ fake_schedule_entry.name = task_name
+
+ fake_get_monitor_config = MagicMock()
+
+ with mock.patch(
+ "sentry_sdk.integrations.celery.Scheduler", fake_scheduler
+ ) as Scheduler: # noqa: N806
+ with mock.patch(
+ "sentry_sdk.integrations.celery.Hub.current.get_integration",
+ return_value=fake_integration,
+ ):
+ with mock.patch(
+ "sentry_sdk.integrations.celery._get_monitor_config",
+ fake_get_monitor_config,
+ ) as _get_monitor_config:
+ # Mimic CeleryIntegration patching of Scheduler.apply_entry()
+ _patch_beat_apply_entry()
+ # Mimic Celery Beat calling a task from the Beat schedule
+ Scheduler.apply_entry(fake_scheduler, fake_schedule_entry)
+
+ if task_in_excluded_beat_tasks:
+ # Only the original Scheduler.apply_entry() is called, _get_monitor_config is NOT called.
+ assert fake_apply_entry.call_count == 1
+ _get_monitor_config.assert_not_called()
+
+ else:
+ # The original Scheduler.apply_entry() is called, AND _get_monitor_config is called.
+ assert fake_apply_entry.call_count == 1
+ assert _get_monitor_config.call_count == 1
diff --git a/tests/integrations/chalice/test_chalice.py b/tests/integrations/chalice/test_chalice.py
index 8bb33a5cb6..4162a55623 100644
--- a/tests/integrations/chalice/test_chalice.py
+++ b/tests/integrations/chalice/test_chalice.py
@@ -4,6 +4,7 @@
from chalice.local import LambdaContext, LocalGateway
from sentry_sdk.integrations.chalice import ChaliceIntegration
+from sentry_sdk import capture_message
from pytest_chalice.handlers import RequestHandler
@@ -41,6 +42,16 @@ def has_request():
def badrequest():
raise BadRequestError("bad-request")
+ @app.route("/message")
+ def hi():
+ capture_message("hi")
+ return {"status": "ok"}
+
+ @app.route("/message/{message_id}")
+ def hi_with_id(message_id):
+ capture_message("hi again")
+ return {"status": "ok"}
+
LocalGateway._generate_lambda_context = _generate_lambda_context
return app
@@ -109,3 +120,28 @@ def test_bad_reques(client: RequestHandler) -> None:
("Message", "BadRequestError: bad-request"),
]
)
+
+
+@pytest.mark.parametrize(
+ "url,expected_transaction,expected_source",
+ [
+ ("/message", "api_handler", "component"),
+ ("/message/123456", "api_handler", "component"),
+ ],
+)
+def test_transaction(
+ app,
+ client: RequestHandler,
+ capture_events,
+ url,
+ expected_transaction,
+ expected_source,
+):
+ events = capture_events()
+
+ response = client.get(url)
+ assert response.status_code == 200
+
+ (event,) = events
+ assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
diff --git a/tests/integrations/cloud_resource_context/__init__.py b/tests/integrations/cloud_resource_context/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/integrations/cloud_resource_context/test_cloud_resource_context.py b/tests/integrations/cloud_resource_context/test_cloud_resource_context.py
new file mode 100644
index 0000000000..b36f795a2b
--- /dev/null
+++ b/tests/integrations/cloud_resource_context/test_cloud_resource_context.py
@@ -0,0 +1,410 @@
+import json
+
+import pytest
+
+try:
+ from unittest import mock # python 3.3 and above
+ from unittest.mock import MagicMock
+except ImportError:
+ import mock # python < 3.3
+ from mock import MagicMock
+
+from sentry_sdk.integrations.cloud_resource_context import (
+ CLOUD_PLATFORM,
+ CLOUD_PROVIDER,
+)
+
+AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD = {
+ "accountId": "298817902971",
+ "architecture": "x86_64",
+ "availabilityZone": "us-east-1b",
+ "billingProducts": None,
+ "devpayProductCodes": None,
+ "marketplaceProductCodes": None,
+ "imageId": "ami-00874d747dde344fa",
+ "instanceId": "i-07d3301297fe0a55a",
+ "instanceType": "t2.small",
+ "kernelId": None,
+ "pendingTime": "2023-02-08T07:54:05Z",
+ "privateIp": "171.131.65.115",
+ "ramdiskId": None,
+ "region": "us-east-1",
+ "version": "2017-09-30",
+}
+
+try:
+ # Python 3
+ AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD_BYTES = bytes(
+ json.dumps(AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD), "utf-8"
+ )
+except TypeError:
+ # Python 2
+ AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD_BYTES = bytes(
+ json.dumps(AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD)
+ ).encode("utf-8")
+
+GCP_GCE_EXAMPLE_METADATA_PLAYLOAD = {
+ "instance": {
+ "attributes": {},
+ "cpuPlatform": "Intel Broadwell",
+ "description": "",
+ "disks": [
+ {
+ "deviceName": "tests-cloud-contexts-in-python-sdk",
+ "index": 0,
+ "interface": "SCSI",
+ "mode": "READ_WRITE",
+ "type": "PERSISTENT-BALANCED",
+ }
+ ],
+ "guestAttributes": {},
+ "hostname": "tests-cloud-contexts-in-python-sdk.c.client-infra-internal.internal",
+ "id": 1535324527892303790,
+ "image": "projects/debian-cloud/global/images/debian-11-bullseye-v20221206",
+ "licenses": [{"id": "2853224013536823851"}],
+ "machineType": "projects/542054129475/machineTypes/e2-medium",
+ "maintenanceEvent": "NONE",
+ "name": "tests-cloud-contexts-in-python-sdk",
+ "networkInterfaces": [
+ {
+ "accessConfigs": [
+ {"externalIp": "134.30.53.15", "type": "ONE_TO_ONE_NAT"}
+ ],
+ "dnsServers": ["169.254.169.254"],
+ "forwardedIps": [],
+ "gateway": "10.188.0.1",
+ "ip": "10.188.0.3",
+ "ipAliases": [],
+ "mac": "42:01:0c:7c:00:13",
+ "mtu": 1460,
+ "network": "projects/544954029479/networks/default",
+ "subnetmask": "255.255.240.0",
+ "targetInstanceIps": [],
+ }
+ ],
+ "preempted": "FALSE",
+ "remainingCpuTime": -1,
+ "scheduling": {
+ "automaticRestart": "TRUE",
+ "onHostMaintenance": "MIGRATE",
+ "preemptible": "FALSE",
+ },
+ "serviceAccounts": {},
+ "tags": ["http-server", "https-server"],
+ "virtualClock": {"driftToken": "0"},
+ "zone": "projects/142954069479/zones/northamerica-northeast2-b",
+ },
+ "oslogin": {"authenticate": {"sessions": {}}},
+ "project": {
+ "attributes": {},
+ "numericProjectId": 204954049439,
+ "projectId": "my-project-internal",
+ },
+}
+
+try:
+ # Python 3
+ GCP_GCE_EXAMPLE_METADATA_PLAYLOAD_BYTES = bytes(
+ json.dumps(GCP_GCE_EXAMPLE_METADATA_PLAYLOAD), "utf-8"
+ )
+except TypeError:
+ # Python 2
+ GCP_GCE_EXAMPLE_METADATA_PLAYLOAD_BYTES = bytes(
+ json.dumps(GCP_GCE_EXAMPLE_METADATA_PLAYLOAD)
+ ).encode("utf-8")
+
+
+def test_is_aws_http_error():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ response = MagicMock()
+ response.status = 405
+
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._is_aws() is False
+ assert CloudResourceContextIntegration.aws_token == ""
+
+
+def test_is_aws_ok():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ response = MagicMock()
+ response.status = 200
+ response.data = b"something"
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._is_aws() is True
+ assert CloudResourceContextIntegration.aws_token == "something"
+
+ CloudResourceContextIntegration.http.request = MagicMock(
+ side_effect=Exception("Test")
+ )
+ assert CloudResourceContextIntegration._is_aws() is False
+
+
+def test_is_aw_exception():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(
+ side_effect=Exception("Test")
+ )
+
+ assert CloudResourceContextIntegration._is_aws() is False
+
+
+@pytest.mark.parametrize(
+ "http_status, response_data, expected_context",
+ [
+ [
+ 405,
+ b"",
+ {
+ "cloud.provider": CLOUD_PROVIDER.AWS,
+ "cloud.platform": CLOUD_PLATFORM.AWS_EC2,
+ },
+ ],
+ [
+ 200,
+ b"something-but-not-json",
+ {
+ "cloud.provider": CLOUD_PROVIDER.AWS,
+ "cloud.platform": CLOUD_PLATFORM.AWS_EC2,
+ },
+ ],
+ [
+ 200,
+ AWS_EC2_EXAMPLE_IMDSv2_PAYLOAD_BYTES,
+ {
+ "cloud.provider": "aws",
+ "cloud.platform": "aws_ec2",
+ "cloud.account.id": "298817902971",
+ "cloud.availability_zone": "us-east-1b",
+ "cloud.region": "us-east-1",
+ "host.id": "i-07d3301297fe0a55a",
+ "host.type": "t2.small",
+ },
+ ],
+ ],
+)
+def test_get_aws_context(http_status, response_data, expected_context):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ response = MagicMock()
+ response.status = http_status
+ response.data = response_data
+
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._get_aws_context() == expected_context
+
+
+def test_is_gcp_http_error():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ response = MagicMock()
+ response.status = 405
+ response.data = b'{"some": "json"}'
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._is_gcp() is False
+ assert CloudResourceContextIntegration.gcp_metadata is None
+
+
+def test_is_gcp_ok():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ response = MagicMock()
+ response.status = 200
+ response.data = b'{"some": "json"}'
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._is_gcp() is True
+ assert CloudResourceContextIntegration.gcp_metadata == {"some": "json"}
+
+
+def test_is_gcp_exception():
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(
+ side_effect=Exception("Test")
+ )
+ assert CloudResourceContextIntegration._is_gcp() is False
+
+
+@pytest.mark.parametrize(
+ "http_status, response_data, expected_context",
+ [
+ [
+ 405,
+ None,
+ {
+ "cloud.provider": CLOUD_PROVIDER.GCP,
+ "cloud.platform": CLOUD_PLATFORM.GCP_COMPUTE_ENGINE,
+ },
+ ],
+ [
+ 200,
+ b"something-but-not-json",
+ {
+ "cloud.provider": CLOUD_PROVIDER.GCP,
+ "cloud.platform": CLOUD_PLATFORM.GCP_COMPUTE_ENGINE,
+ },
+ ],
+ [
+ 200,
+ GCP_GCE_EXAMPLE_METADATA_PLAYLOAD_BYTES,
+ {
+ "cloud.provider": "gcp",
+ "cloud.platform": "gcp_compute_engine",
+ "cloud.account.id": "my-project-internal",
+ "cloud.availability_zone": "northamerica-northeast2-b",
+ "host.id": 1535324527892303790,
+ },
+ ],
+ ],
+)
+def test_get_gcp_context(http_status, response_data, expected_context):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration.gcp_metadata = None
+
+ response = MagicMock()
+ response.status = http_status
+ response.data = response_data
+
+ CloudResourceContextIntegration.http = MagicMock()
+ CloudResourceContextIntegration.http.request = MagicMock(return_value=response)
+
+ assert CloudResourceContextIntegration._get_gcp_context() == expected_context
+
+
+@pytest.mark.parametrize(
+ "is_aws, is_gcp, expected_provider",
+ [
+ [False, False, ""],
+ [False, True, CLOUD_PROVIDER.GCP],
+ [True, False, CLOUD_PROVIDER.AWS],
+ [True, True, CLOUD_PROVIDER.AWS],
+ ],
+)
+def test_get_cloud_provider(is_aws, is_gcp, expected_provider):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration._is_aws = MagicMock(return_value=is_aws)
+ CloudResourceContextIntegration._is_gcp = MagicMock(return_value=is_gcp)
+
+ assert CloudResourceContextIntegration._get_cloud_provider() == expected_provider
+
+
+@pytest.mark.parametrize(
+ "cloud_provider",
+ [
+ CLOUD_PROVIDER.ALIBABA,
+ CLOUD_PROVIDER.AZURE,
+ CLOUD_PROVIDER.IBM,
+ CLOUD_PROVIDER.TENCENT,
+ ],
+)
+def test_get_cloud_resource_context_unsupported_providers(cloud_provider):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration._get_cloud_provider = MagicMock(
+ return_value=cloud_provider
+ )
+
+ assert CloudResourceContextIntegration._get_cloud_resource_context() == {}
+
+
+@pytest.mark.parametrize(
+ "cloud_provider",
+ [
+ CLOUD_PROVIDER.AWS,
+ CLOUD_PROVIDER.GCP,
+ ],
+)
+def test_get_cloud_resource_context_supported_providers(cloud_provider):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration._get_cloud_provider = MagicMock(
+ return_value=cloud_provider
+ )
+
+ assert CloudResourceContextIntegration._get_cloud_resource_context() != {}
+
+
+@pytest.mark.parametrize(
+ "cloud_provider, cloud_resource_context, warning_called, set_context_called",
+ [
+ ["", {}, False, False],
+ [CLOUD_PROVIDER.AWS, {}, False, False],
+ [CLOUD_PROVIDER.GCP, {}, False, False],
+ [CLOUD_PROVIDER.AZURE, {}, True, False],
+ [CLOUD_PROVIDER.ALIBABA, {}, True, False],
+ [CLOUD_PROVIDER.IBM, {}, True, False],
+ [CLOUD_PROVIDER.TENCENT, {}, True, False],
+ ["", {"some": "context"}, False, True],
+ [CLOUD_PROVIDER.AWS, {"some": "context"}, False, True],
+ [CLOUD_PROVIDER.GCP, {"some": "context"}, False, True],
+ ],
+)
+def test_setup_once(
+ cloud_provider, cloud_resource_context, warning_called, set_context_called
+):
+ from sentry_sdk.integrations.cloud_resource_context import (
+ CloudResourceContextIntegration,
+ )
+
+ CloudResourceContextIntegration.cloud_provider = cloud_provider
+ CloudResourceContextIntegration._get_cloud_resource_context = MagicMock(
+ return_value=cloud_resource_context
+ )
+
+ with mock.patch(
+ "sentry_sdk.integrations.cloud_resource_context.set_context"
+ ) as fake_set_context:
+ with mock.patch(
+ "sentry_sdk.integrations.cloud_resource_context.logger.warning"
+ ) as fake_warning:
+ CloudResourceContextIntegration.setup_once()
+
+ if set_context_called:
+ fake_set_context.assert_called_once_with(
+ "cloud_resource", cloud_resource_context
+ )
+ else:
+ fake_set_context.assert_not_called()
+
+ if warning_called:
+ assert fake_warning.call_count == 1
+ else:
+ fake_warning.assert_not_called()
diff --git a/tests/integrations/django/asgi/test_asgi.py b/tests/integrations/django/asgi/test_asgi.py
index 0e6dd4f9ff..85921cf364 100644
--- a/tests/integrations/django/asgi/test_asgi.py
+++ b/tests/integrations/django/asgi/test_asgi.py
@@ -1,3 +1,5 @@
+import json
+
import django
import pytest
from channels.testing import HttpCommunicator
@@ -5,6 +7,11 @@
from sentry_sdk.integrations.django import DjangoIntegration
from tests.integrations.django.myapp.asgi import channels_application
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
APPS = [channels_application]
if django.VERSION >= (3, 0):
from tests.integrations.django.myapp.asgi import asgi_application
@@ -70,11 +77,47 @@ async def test_async_views(sentry_init, capture_events, application):
}
+@pytest.mark.parametrize("application", APPS)
+@pytest.mark.parametrize("endpoint", ["/sync/thread_ids", "/async/thread_ids"])
@pytest.mark.asyncio
@pytest.mark.skipif(
django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
)
-async def test_async_views_concurrent_execution(sentry_init, capture_events, settings):
+async def test_active_thread_id(sentry_init, capture_envelopes, endpoint, application):
+ with mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0):
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+
+ envelopes = capture_envelopes()
+
+ comm = HttpCommunicator(application, "GET", endpoint)
+ response = await comm.get_response()
+ assert response["status"] == 200, response["body"]
+
+ await comm.wait()
+
+ data = json.loads(response["body"])
+
+ envelopes = [envelope for envelope in envelopes]
+ assert len(envelopes) == 1
+
+ profiles = [item for item in envelopes[0].items if item.type == "profile"]
+ assert len(profiles) == 1
+
+ for profile in profiles:
+ transactions = profile.payload.json["transactions"]
+ assert len(transactions) == 1
+ assert str(data["active"]) == transactions[0]["active_thread_id"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+ django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
+)
+async def test_async_views_concurrent_execution(sentry_init, settings):
import asyncio
import time
@@ -108,7 +151,7 @@ async def test_async_views_concurrent_execution(sentry_init, capture_events, set
django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
)
async def test_async_middleware_that_is_function_concurrent_execution(
- sentry_init, capture_events, settings
+ sentry_init, settings
):
import asyncio
import time
@@ -175,10 +218,138 @@ async def test_async_middleware_spans(
render_span_tree(transaction)
== """\
- op="http.server": description=null
- - op="django.middleware": description="django.contrib.sessions.middleware.SessionMiddleware.__acall__"
- - op="django.middleware": description="django.contrib.auth.middleware.AuthenticationMiddleware.__acall__"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.__acall__"
- - op="django.middleware": description="tests.integrations.django.myapp.settings.TestMiddleware.__acall__"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
- - op="django.view": description="async_message\""""
+ - op="event.django": description="django.db.reset_queries"
+ - op="event.django": description="django.db.close_old_connections"
+ - op="middleware.django": description="django.contrib.sessions.middleware.SessionMiddleware.__acall__"
+ - op="middleware.django": description="django.contrib.auth.middleware.AuthenticationMiddleware.__acall__"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.__acall__"
+ - op="middleware.django": description="tests.integrations.django.myapp.settings.TestMiddleware.__acall__"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
+ - op="view.render": description="async_message"
+ - op="event.django": description="django.db.close_old_connections"
+ - op="event.django": description="django.core.cache.close_caches"
+ - op="event.django": description="django.core.handlers.base.reset_urlconf\""""
+ )
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+ django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
+)
+async def test_has_trace_if_performance_enabled(sentry_init, capture_events):
+ sentry_init(integrations=[DjangoIntegration()], traces_sample_rate=1.0)
+
+ events = capture_events()
+
+ comm = HttpCommunicator(asgi_application, "GET", "/view-exc-with-msg")
+ response = await comm.get_response()
+ assert response["status"] == 500
+
+ # ASGI Django does not create transactions per default,
+ # so we do not have a transaction_event here.
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
)
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+ django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
+)
+async def test_has_trace_if_performance_disabled(sentry_init, capture_events):
+ sentry_init(integrations=[DjangoIntegration()])
+
+ events = capture_events()
+
+ comm = HttpCommunicator(asgi_application, "GET", "/view-exc-with-msg")
+ response = await comm.get_response()
+ assert response["status"] == 500
+
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+ django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
+)
+async def test_trace_from_headers_if_performance_enabled(sentry_init, capture_events):
+ sentry_init(integrations=[DjangoIntegration()], traces_sample_rate=1.0)
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ comm = HttpCommunicator(
+ asgi_application,
+ "GET",
+ "/view-exc-with-msg",
+ headers=[(b"sentry-trace", sentry_trace_header.encode())],
+ )
+ response = await comm.get_response()
+ assert response["status"] == 500
+
+ # ASGI Django does not create transactions per default,
+ # so we do not have a transaction_event here.
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+ django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
+)
+async def test_trace_from_headers_if_performance_disabled(sentry_init, capture_events):
+ sentry_init(integrations=[DjangoIntegration()])
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ comm = HttpCommunicator(
+ asgi_application,
+ "GET",
+ "/view-exc-with-msg",
+ headers=[(b"sentry-trace", sentry_trace_header.encode())],
+ )
+ response = await comm.get_response()
+ assert response["status"] == 500
+
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
diff --git a/tests/integrations/django/myapp/routing.py b/tests/integrations/django/myapp/routing.py
index b5755549ec..30cab968ad 100644
--- a/tests/integrations/django/myapp/routing.py
+++ b/tests/integrations/django/myapp/routing.py
@@ -1,11 +1,18 @@
import channels
-
-from channels.http import AsgiHandler
from channels.routing import ProtocolTypeRouter
-if channels.__version__ < "3.0.0":
- channels_handler = AsgiHandler
-else:
- channels_handler = AsgiHandler()
+try:
+ from channels.http import AsgiHandler
+
+ if channels.__version__ < "3.0.0":
+ django_asgi_app = AsgiHandler
+ else:
+ django_asgi_app = AsgiHandler()
+
+except ModuleNotFoundError:
+ # Since channels 4.0 ASGI handling is done by Django itself
+ from django.core.asgi import get_asgi_application
+
+ django_asgi_app = get_asgi_application()
-application = ProtocolTypeRouter({"http": channels_handler})
+application = ProtocolTypeRouter({"http": django_asgi_app})
diff --git a/tests/integrations/django/myapp/urls.py b/tests/integrations/django/myapp/urls.py
index 8e43460bba..0140f03965 100644
--- a/tests/integrations/django/myapp/urls.py
+++ b/tests/integrations/django/myapp/urls.py
@@ -28,6 +28,14 @@ def path(path, *args, **kwargs):
urlpatterns = [
path("view-exc", views.view_exc, name="view_exc"),
+ path("view-exc-with-msg", views.view_exc_with_msg, name="view_exc_with_msg"),
+ path("cached-view", views.cached_view, name="cached_view"),
+ path("not-cached-view", views.not_cached_view, name="not_cached_view"),
+ path(
+ "view-with-cached-template-fragment",
+ views.view_with_cached_template_fragment,
+ name="view_with_cached_template_fragment",
+ ),
path(
"read-body-and-view-exc",
views.read_body_and_view_exc,
@@ -58,6 +66,7 @@ def path(path, *args, **kwargs):
views.csrf_hello_not_exempt,
name="csrf_hello_not_exempt",
),
+ path("sync/thread_ids", views.thread_ids_sync, name="thread_ids_sync"),
]
# async views
@@ -67,6 +76,11 @@ def path(path, *args, **kwargs):
if views.my_async_view is not None:
urlpatterns.append(path("my_async_view", views.my_async_view, name="my_async_view"))
+if views.thread_ids_async is not None:
+ urlpatterns.append(
+ path("async/thread_ids", views.thread_ids_async, name="thread_ids_async")
+ )
+
# rest framework
try:
urlpatterns.append(
@@ -80,6 +94,9 @@ def path(path, *args, **kwargs):
)
)
urlpatterns.append(path("rest-hello", views.rest_hello, name="rest_hello"))
+ urlpatterns.append(
+ path("rest-json-response", views.rest_json_response, name="rest_json_response")
+ )
urlpatterns.append(
path(
"rest-permission-denied-exc",
diff --git a/tests/integrations/django/myapp/views.py b/tests/integrations/django/myapp/views.py
index cac881552c..c7628a2ad0 100644
--- a/tests/integrations/django/myapp/views.py
+++ b/tests/integrations/django/myapp/views.py
@@ -1,16 +1,22 @@
+import json
+import threading
+
from django import VERSION
from django.contrib.auth import login
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse, HttpResponseNotFound, HttpResponseServerError
from django.shortcuts import render
+from django.template import Context, Template
from django.template.response import TemplateResponse
from django.utils.decorators import method_decorator
+from django.views.decorators.cache import cache_page
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import ListView
try:
from rest_framework.decorators import api_view
+ from rest_framework.response import Response
@api_view(["POST"])
def rest_framework_exc(request):
@@ -29,12 +35,16 @@ def rest_hello(request):
def rest_permission_denied_exc(request):
raise PermissionDenied("bye")
+ @api_view(["GET"])
+ def rest_json_response(request):
+ return Response(dict(ok=True))
except ImportError:
pass
import sentry_sdk
+from sentry_sdk import capture_message
@csrf_exempt
@@ -42,6 +52,34 @@ def view_exc(request):
1 / 0
+@csrf_exempt
+def view_exc_with_msg(request):
+ capture_message("oops")
+ 1 / 0
+
+
+@cache_page(60)
+def cached_view(request):
+ return HttpResponse("ok")
+
+
+def not_cached_view(request):
+ return HttpResponse("ok")
+
+
+def view_with_cached_template_fragment(request):
+ template = Template(
+ """{% load cache %}
+ Not cached content goes here.
+ {% cache 500 some_identifier %}
+ And here some cached content.
+ {% endcache %}
+ """
+ )
+ rendered = template.render(Context({}))
+ return HttpResponse(rendered)
+
+
# This is a "class based view" as previously found in the sentry codebase. The
# interesting property of this one is that csrf_exempt, as a class attribute,
# is not in __dict__, so regular use of functools.wraps will not forward the
@@ -155,6 +193,16 @@ def csrf_hello_not_exempt(*args, **kwargs):
return HttpResponse("ok")
+def thread_ids_sync(*args, **kwargs):
+ response = json.dumps(
+ {
+ "main": threading.main_thread().ident,
+ "active": threading.current_thread().ident,
+ }
+ )
+ return HttpResponse(response)
+
+
if VERSION >= (3, 1):
# Use exec to produce valid Python 2
exec(
@@ -169,6 +217,16 @@ def csrf_hello_not_exempt(*args, **kwargs):
await asyncio.sleep(1)
return HttpResponse('Hello World')"""
)
+
+ exec(
+ """async def thread_ids_async(request):
+ response = json.dumps({
+ "main": threading.main_thread().ident,
+ "active": threading.current_thread().ident,
+ })
+ return HttpResponse(response)"""
+ )
else:
async_message = None
my_async_view = None
+ thread_ids_async = None
diff --git a/tests/integrations/django/test_basic.py b/tests/integrations/django/test_basic.py
index cc77c9a76a..5c7e32ef5f 100644
--- a/tests/integrations/django/test_basic.py
+++ b/tests/integrations/django/test_basic.py
@@ -1,44 +1,33 @@
from __future__ import absolute_import
-import pytest
-import pytest_django
import json
+import pytest
+import random
+from functools import partial
from werkzeug.test import Client
+
from django import VERSION as DJANGO_VERSION
from django.contrib.auth.models import User
from django.core.management import execute_from_command_line
from django.db.utils import OperationalError, ProgrammingError, DataError
-from sentry_sdk.integrations.executing import ExecutingIntegration
-
try:
from django.urls import reverse
except ImportError:
from django.core.urlresolvers import reverse
+from sentry_sdk._compat import PY2, PY310
from sentry_sdk import capture_message, capture_exception, configure_scope
+from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.django import DjangoIntegration
-from functools import partial
-
+from sentry_sdk.integrations.django.signals_handlers import _get_receiver_name
+from sentry_sdk.integrations.django.caching import _get_span_description
+from sentry_sdk.integrations.executing import ExecutingIntegration
from tests.integrations.django.myapp.wsgi import application
+from tests.integrations.django.utils import pytest_mark_django_db_decorator
-# Hack to prevent from experimental feature introduced in version `4.3.0` in `pytest-django` that
-# requires explicit database allow from failing the test
-pytest_mark_django_db_decorator = partial(pytest.mark.django_db)
-try:
- pytest_version = tuple(map(int, pytest_django.__version__.split(".")))
- if pytest_version > (4, 2, 0):
- pytest_mark_django_db_decorator = partial(
- pytest.mark.django_db, databases="__all__"
- )
-except ValueError:
- if "dev" in pytest_django.__version__:
- pytest_mark_django_db_decorator = partial(
- pytest.mark.django_db, databases="__all__"
- )
-except AttributeError:
- pass
+DJANGO_VERSION = DJANGO_VERSION[:2]
@pytest.fixture
@@ -46,6 +35,36 @@ def client():
return Client(application)
+@pytest.fixture
+def use_django_caching(settings):
+ settings.CACHES = {
+ "default": {
+ "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+ "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000),
+ }
+ }
+
+
+@pytest.fixture
+def use_django_caching_with_middlewares(settings):
+ settings.CACHES = {
+ "default": {
+ "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+ "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000),
+ }
+ }
+ if hasattr(settings, "MIDDLEWARE"):
+ middleware = settings.MIDDLEWARE
+ elif hasattr(settings, "MIDDLEWARE_CLASSES"):
+ middleware = settings.MIDDLEWARE_CLASSES
+ else:
+ middleware = None
+
+ if middleware is not None:
+ middleware.insert(0, "django.middleware.cache.UpdateCacheMiddleware")
+ middleware.append("django.middleware.cache.FetchFromCacheMiddleware")
+
+
def test_view_exceptions(sentry_init, client, capture_exceptions, capture_events):
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
exceptions = capture_exceptions()
@@ -143,6 +162,112 @@ def test_transaction_with_class_view(sentry_init, client, capture_events):
assert event["message"] == "hi"
+def test_has_trace_if_performance_enabled(sentry_init, client, capture_events):
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+ client.head(reverse("view_exc_with_msg"))
+
+ (msg_event, error_event, transaction_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_has_trace_if_performance_disabled(sentry_init, client, capture_events):
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ )
+ events = capture_events()
+ client.head(reverse("view_exc_with_msg"))
+
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_trace_from_headers_if_performance_enabled(sentry_init, client, capture_events):
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ traces_sample_rate=1.0,
+ )
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ client.head(
+ reverse("view_exc_with_msg"), headers={"sentry-trace": sentry_trace_header}
+ )
+
+ (msg_event, error_event, transaction_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert transaction_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
+def test_trace_from_headers_if_performance_disabled(
+ sentry_init, client, capture_events
+):
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ )
+
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ client.head(
+ reverse("view_exc_with_msg"), headers={"sentry-trace": sentry_trace_header}
+ )
+
+ (msg_event, error_event) = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
@pytest.mark.forked
@pytest.mark.django_db
def test_user_captured(sentry_init, client, capture_events):
@@ -299,6 +424,25 @@ def test_sql_dict_query_params(sentry_init, capture_events):
assert crumb["data"]["db.params"] == {"my_foo": 10}
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+def test_response_trace(sentry_init, client, capture_events, render_span_tree):
+ pytest.importorskip("rest_framework")
+ sentry_init(
+ integrations=[DjangoIntegration()],
+ traces_sample_rate=1.0,
+ )
+
+ events = capture_events()
+ content, status, headers = client.get(reverse("rest_json_response"))
+ assert status == "200 OK"
+
+ assert (
+ '- op="view.response.render": description="serialize response"'
+ in render_span_tree(events[0])
+ )
+
+
@pytest.mark.parametrize(
"query",
[
@@ -427,7 +571,14 @@ def test_django_connect_trace(sentry_init, client, capture_events, render_span_t
content, status, headers = client.get(reverse("postgres_select"))
assert status == "200 OK"
- assert '- op="db": description="connect"' in render_span_tree(events[0])
+ (event,) = events
+
+ for span in event["spans"]:
+ if span.get("op") == "db":
+ data = span.get("data")
+ assert data.get(SPANDATA.DB_SYSTEM) == "postgresql"
+
+ assert '- op="db": description="connect"' in render_span_tree(event)
@pytest.mark.forked
@@ -469,25 +620,40 @@ def test_django_connect_breadcrumbs(
@pytest.mark.parametrize(
- "transaction_style,expected_transaction",
+ "transaction_style,client_url,expected_transaction,expected_source,expected_response",
[
- ("function_name", "tests.integrations.django.myapp.views.message"),
- ("url", "/message"),
+ (
+ "function_name",
+ "/message",
+ "tests.integrations.django.myapp.views.message",
+ "component",
+ b"ok",
+ ),
+ ("url", "/message", "/message", "route", b"ok"),
+ ("url", "/404", "/404", "url", b"404"),
],
)
def test_transaction_style(
- sentry_init, client, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ client,
+ capture_events,
+ transaction_style,
+ client_url,
+ expected_transaction,
+ expected_source,
+ expected_response,
):
sentry_init(
integrations=[DjangoIntegration(transaction_style=transaction_style)],
send_default_pii=True,
)
events = capture_events()
- content, status, headers = client.get(reverse("message"))
- assert b"".join(content) == b"ok"
+ content, status, headers = client.get(client_url)
+ assert b"".join(content) == expected_response
(event,) = events
assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
def test_request_body(sentry_init, client, capture_events):
@@ -504,8 +670,7 @@ def test_request_body(sentry_init, client, capture_events):
assert event["message"] == "hi"
assert event["request"]["data"] == ""
assert event["_meta"]["request"]["data"][""] == {
- "len": 6,
- "rem": [["!raw", "x", 0, 6]],
+ "rem": [["!raw", "x"]],
}
del events[:]
@@ -567,7 +732,6 @@ def test_template_exception(
assert template_frame["post_context"] == ["11\n", "12\n", "13\n", "14\n", "15\n"]
assert template_frame["lineno"] == 10
- assert template_frame["in_app"]
assert template_frame["filename"].endswith("error.html")
filenames = [
@@ -576,15 +740,15 @@ def test_template_exception(
if with_executing_integration:
assert filenames[-3:] == [
- (u"Parser.parse", u"django.template.base"),
+ ("Parser.parse", "django.template.base"),
(None, None),
- (u"Parser.invalid_block_tag", u"django.template.base"),
+ ("Parser.invalid_block_tag", "django.template.base"),
]
else:
assert filenames[-3:] == [
- (u"parse", u"django.template.base"),
+ ("parse", "django.template.base"),
(None, None),
- (u"invalid_block_tag", u"django.template.base"),
+ ("invalid_block_tag", "django.template.base"),
]
@@ -615,7 +779,7 @@ def test_rest_framework_basic(
elif ct == "application/x-www-form-urlencoded":
client.post(reverse(route), data=body)
else:
- assert False
+ raise AssertionError("unreachable")
(error,) = exceptions
assert isinstance(error, ZeroDivisionError)
@@ -637,7 +801,7 @@ def test_does_not_capture_403(sentry_init, client, capture_events, endpoint):
sentry_init(integrations=[DjangoIntegration()])
events = capture_events()
- _content, status, _headers = client.get(reverse(endpoint))
+ _, status, _ = client.get(reverse(endpoint))
assert status.lower() == "403 forbidden"
assert not events
@@ -651,82 +815,134 @@ def test_render_spans(sentry_init, client, capture_events, render_span_tree):
views_tests = [
(
reverse("template_test2"),
- '- op="django.template.render": description="[user_name.html, ...]"',
+ '- op="template.render": description="[user_name.html, ...]"',
),
]
if DJANGO_VERSION >= (1, 7):
views_tests.append(
(
reverse("template_test"),
- '- op="django.template.render": description="user_name.html"',
+ '- op="template.render": description="user_name.html"',
),
)
for url, expected_line in views_tests:
events = capture_events()
- _content, status, _headers = client.get(url)
+ client.get(url)
transaction = events[0]
assert expected_line in render_span_tree(transaction)
+if DJANGO_VERSION >= (1, 10):
+ EXPECTED_MIDDLEWARE_SPANS = """\
+- op="http.server": description=null
+ - op="middleware.django": description="django.contrib.sessions.middleware.SessionMiddleware.__call__"
+ - op="middleware.django": description="django.contrib.auth.middleware.AuthenticationMiddleware.__call__"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.__call__"
+ - op="middleware.django": description="tests.integrations.django.myapp.settings.TestMiddleware.__call__"
+ - op="middleware.django": description="tests.integrations.django.myapp.settings.TestFunctionMiddleware.__call__"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
+ - op="view.render": description="message"\
+"""
+else:
+ EXPECTED_MIDDLEWARE_SPANS = """\
+- op="http.server": description=null
+ - op="middleware.django": description="django.contrib.sessions.middleware.SessionMiddleware.process_request"
+ - op="middleware.django": description="django.contrib.auth.middleware.AuthenticationMiddleware.process_request"
+ - op="middleware.django": description="tests.integrations.django.myapp.settings.TestMiddleware.process_request"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
+ - op="view.render": description="message"
+ - op="middleware.django": description="tests.integrations.django.myapp.settings.TestMiddleware.process_response"
+ - op="middleware.django": description="django.middleware.csrf.CsrfViewMiddleware.process_response"
+ - op="middleware.django": description="django.contrib.sessions.middleware.SessionMiddleware.process_response"\
+"""
+
+
def test_middleware_spans(sentry_init, client, capture_events, render_span_tree):
sentry_init(
- integrations=[DjangoIntegration()],
+ integrations=[
+ DjangoIntegration(signals_spans=False),
+ ],
traces_sample_rate=1.0,
- _experiments={"record_sql_params": True},
)
events = capture_events()
- _content, status, _headers = client.get(reverse("message"))
+ client.get(reverse("message"))
message, transaction = events
assert message["message"] == "hi"
+ assert render_span_tree(transaction) == EXPECTED_MIDDLEWARE_SPANS
- if DJANGO_VERSION >= (1, 10):
- assert (
- render_span_tree(transaction)
- == """\
+
+def test_middleware_spans_disabled(sentry_init, client, capture_events):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(middleware_spans=False, signals_spans=False),
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("message"))
+
+ message, transaction = events
+
+ assert message["message"] == "hi"
+ assert not len(transaction["spans"])
+
+
+if DJANGO_VERSION >= (1, 10):
+ EXPECTED_SIGNALS_SPANS = """\
- op="http.server": description=null
- - op="django.middleware": description="django.contrib.sessions.middleware.SessionMiddleware.__call__"
- - op="django.middleware": description="django.contrib.auth.middleware.AuthenticationMiddleware.__call__"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.__call__"
- - op="django.middleware": description="tests.integrations.django.myapp.settings.TestMiddleware.__call__"
- - op="django.middleware": description="tests.integrations.django.myapp.settings.TestFunctionMiddleware.__call__"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
- - op="django.view": description="message"\
+ - op="event.django": description="django.db.reset_queries"
+ - op="event.django": description="django.db.close_old_connections"\
"""
- )
-
- else:
- assert (
- render_span_tree(transaction)
- == """\
+else:
+ EXPECTED_SIGNALS_SPANS = """\
- op="http.server": description=null
- - op="django.middleware": description="django.contrib.sessions.middleware.SessionMiddleware.process_request"
- - op="django.middleware": description="django.contrib.auth.middleware.AuthenticationMiddleware.process_request"
- - op="django.middleware": description="tests.integrations.django.myapp.settings.TestMiddleware.process_request"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.process_view"
- - op="django.view": description="message"
- - op="django.middleware": description="tests.integrations.django.myapp.settings.TestMiddleware.process_response"
- - op="django.middleware": description="django.middleware.csrf.CsrfViewMiddleware.process_response"
- - op="django.middleware": description="django.contrib.sessions.middleware.SessionMiddleware.process_response"\
+ - op="event.django": description="django.db.reset_queries"
+ - op="event.django": description="django.db.close_old_connections"\
"""
- )
-def test_middleware_spans_disabled(sentry_init, client, capture_events):
+def test_signals_spans(sentry_init, client, capture_events, render_span_tree):
sentry_init(
- integrations=[DjangoIntegration(middleware_spans=False)], traces_sample_rate=1.0
+ integrations=[
+ DjangoIntegration(middleware_spans=False),
+ ],
+ traces_sample_rate=1.0,
)
events = capture_events()
- _content, status, _headers = client.get(reverse("message"))
+ client.get(reverse("message"))
message, transaction = events
assert message["message"] == "hi"
+ assert render_span_tree(transaction) == EXPECTED_SIGNALS_SPANS
+
+ assert transaction["spans"][0]["op"] == "event.django"
+ assert transaction["spans"][0]["description"] == "django.db.reset_queries"
+
+ assert transaction["spans"][1]["op"] == "event.django"
+ assert transaction["spans"][1]["description"] == "django.db.close_old_connections"
+
+
+def test_signals_spans_disabled(sentry_init, client, capture_events):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(middleware_spans=False, signals_spans=False),
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+ client.get(reverse("message"))
+
+ message, transaction = events
+
+ assert message["message"] == "hi"
assert not transaction["spans"]
@@ -791,3 +1007,270 @@ def test_custom_urlconf_middleware(
assert "custom_urlconf_middleware" in render_span_tree(transaction_event)
settings.MIDDLEWARE.pop(0)
+
+
+def test_get_receiver_name():
+ def dummy(a, b):
+ return a + b
+
+ name = _get_receiver_name(dummy)
+
+ if PY2:
+ assert name == "tests.integrations.django.test_basic.dummy"
+ else:
+ assert (
+ name
+ == "tests.integrations.django.test_basic.test_get_receiver_name..dummy"
+ )
+
+ a_partial = partial(dummy)
+ name = _get_receiver_name(a_partial)
+ if PY310:
+ assert name == "functools.partial()"
+ else:
+ assert name == "partial()"
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_disabled_middleware(
+ sentry_init,
+ client,
+ capture_events,
+ use_django_caching_with_middlewares,
+ settings,
+):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=False,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("not_cached_view"))
+ client.get(reverse("not_cached_view"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 0
+ assert len(second_event["spans"]) == 0
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_disabled_decorator(
+ sentry_init, client, capture_events, use_django_caching
+):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=False,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("cached_view"))
+ client.get(reverse("cached_view"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 0
+ assert len(second_event["spans"]) == 0
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_disabled_templatetag(
+ sentry_init, client, capture_events, use_django_caching
+):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=False,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("view_with_cached_template_fragment"))
+ client.get(reverse("view_with_cached_template_fragment"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 0
+ assert len(second_event["spans"]) == 0
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_middleware(
+ sentry_init,
+ client,
+ capture_events,
+ use_django_caching_with_middlewares,
+ settings,
+):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=True,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+
+ client.application.load_middleware()
+ events = capture_events()
+
+ client.get(reverse("not_cached_view"))
+ client.get(reverse("not_cached_view"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 1
+ assert first_event["spans"][0]["op"] == "cache.get_item"
+ assert first_event["spans"][0]["description"].startswith(
+ "get views.decorators.cache.cache_header."
+ )
+ assert first_event["spans"][0]["data"] == {"cache.hit": False}
+
+ assert len(second_event["spans"]) == 2
+ assert second_event["spans"][0]["op"] == "cache.get_item"
+ assert second_event["spans"][0]["description"].startswith(
+ "get views.decorators.cache.cache_header."
+ )
+ assert second_event["spans"][0]["data"] == {"cache.hit": False}
+
+ assert second_event["spans"][1]["op"] == "cache.get_item"
+ assert second_event["spans"][1]["description"].startswith(
+ "get views.decorators.cache.cache_page."
+ )
+ assert second_event["spans"][1]["data"]["cache.hit"]
+ assert "cache.item_size" in second_event["spans"][1]["data"]
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_decorator(sentry_init, client, capture_events, use_django_caching):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=True,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("cached_view"))
+ client.get(reverse("cached_view"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 1
+ assert first_event["spans"][0]["op"] == "cache.get_item"
+ assert first_event["spans"][0]["description"].startswith(
+ "get views.decorators.cache.cache_header."
+ )
+ assert first_event["spans"][0]["data"] == {"cache.hit": False}
+
+ assert len(second_event["spans"]) == 2
+ assert second_event["spans"][0]["op"] == "cache.get_item"
+ assert second_event["spans"][0]["description"].startswith(
+ "get views.decorators.cache.cache_header."
+ )
+ assert second_event["spans"][0]["data"] == {"cache.hit": False}
+
+ assert second_event["spans"][1]["op"] == "cache.get_item"
+ assert second_event["spans"][1]["description"].startswith(
+ "get views.decorators.cache.cache_page."
+ )
+ assert second_event["spans"][1]["data"]["cache.hit"]
+ assert "cache.item_size" in second_event["spans"][1]["data"]
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+@pytest.mark.skipif(DJANGO_VERSION < (1, 9), reason="Requires Django >= 1.9")
+def test_cache_spans_templatetag(
+ sentry_init, client, capture_events, use_django_caching
+):
+ sentry_init(
+ integrations=[
+ DjangoIntegration(
+ cache_spans=True,
+ middleware_spans=False,
+ signals_spans=False,
+ )
+ ],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client.get(reverse("view_with_cached_template_fragment"))
+ client.get(reverse("view_with_cached_template_fragment"))
+
+ (first_event, second_event) = events
+ assert len(first_event["spans"]) == 1
+ assert first_event["spans"][0]["op"] == "cache.get_item"
+ assert first_event["spans"][0]["description"].startswith(
+ "get template.cache.some_identifier."
+ )
+ assert first_event["spans"][0]["data"] == {"cache.hit": False}
+
+ assert len(second_event["spans"]) == 1
+ assert second_event["spans"][0]["op"] == "cache.get_item"
+ assert second_event["spans"][0]["description"].startswith(
+ "get template.cache.some_identifier."
+ )
+ assert second_event["spans"][0]["data"]["cache.hit"]
+ assert "cache.item_size" in second_event["spans"][0]["data"]
+
+
+@pytest.mark.parametrize(
+ "method_name, args, kwargs, expected_description",
+ [
+ ("get", None, None, "get "),
+ ("get", [], {}, "get "),
+ ("get", ["bla", "blub", "foo"], {}, "get bla"),
+ (
+ "get_many",
+ [["bla 1", "bla 2", "bla 3"], "blub", "foo"],
+ {},
+ "get_many ['bla 1', 'bla 2', 'bla 3']",
+ ),
+ (
+ "get_many",
+ [["bla 1", "bla 2", "bla 3"], "blub", "foo"],
+ {"key": "bar"},
+ "get_many ['bla 1', 'bla 2', 'bla 3']",
+ ),
+ ("get", [], {"key": "bar"}, "get bar"),
+ (
+ "get",
+ "something",
+ {},
+ "get s",
+ ), # this should never happen, just making sure that we are not raising an exception in that case.
+ ],
+)
+def test_cache_spans_get_span_description(
+ method_name, args, kwargs, expected_description
+):
+ assert _get_span_description(method_name, args, kwargs) == expected_description
diff --git a/tests/integrations/django/test_data_scrubbing.py b/tests/integrations/django/test_data_scrubbing.py
new file mode 100644
index 0000000000..b3e531183f
--- /dev/null
+++ b/tests/integrations/django/test_data_scrubbing.py
@@ -0,0 +1,83 @@
+import pytest
+
+from werkzeug.test import Client
+
+from sentry_sdk.integrations.django import DjangoIntegration
+from tests.integrations.django.myapp.wsgi import application
+from tests.integrations.django.utils import pytest_mark_django_db_decorator
+
+try:
+ from django.urls import reverse
+except ImportError:
+ from django.core.urlresolvers import reverse
+
+
+@pytest.fixture
+def client():
+ return Client(application)
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+def test_scrub_django_session_cookies_removed(
+ sentry_init,
+ client,
+ capture_events,
+):
+ sentry_init(integrations=[DjangoIntegration()], send_default_pii=False)
+ events = capture_events()
+ client.set_cookie("localhost", "sessionid", "123")
+ client.set_cookie("localhost", "csrftoken", "456")
+ client.set_cookie("localhost", "foo", "bar")
+ client.get(reverse("view_exc"))
+
+ (event,) = events
+ assert "cookies" not in event["request"]
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+def test_scrub_django_session_cookies_filtered(
+ sentry_init,
+ client,
+ capture_events,
+):
+ sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
+ events = capture_events()
+ client.set_cookie("localhost", "sessionid", "123")
+ client.set_cookie("localhost", "csrftoken", "456")
+ client.set_cookie("localhost", "foo", "bar")
+ client.get(reverse("view_exc"))
+
+ (event,) = events
+ assert event["request"]["cookies"] == {
+ "sessionid": "[Filtered]",
+ "csrftoken": "[Filtered]",
+ "foo": "bar",
+ }
+
+
+@pytest.mark.forked
+@pytest_mark_django_db_decorator()
+def test_scrub_django_custom_session_cookies_filtered(
+ sentry_init,
+ client,
+ capture_events,
+ settings,
+):
+ settings.SESSION_COOKIE_NAME = "my_sess"
+ settings.CSRF_COOKIE_NAME = "csrf_secret"
+
+ sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
+ events = capture_events()
+ client.set_cookie("localhost", "my_sess", "123")
+ client.set_cookie("localhost", "csrf_secret", "456")
+ client.set_cookie("localhost", "foo", "bar")
+ client.get(reverse("view_exc"))
+
+ (event,) = events
+ assert event["request"]["cookies"] == {
+ "my_sess": "[Filtered]",
+ "csrf_secret": "[Filtered]",
+ "foo": "bar",
+ }
diff --git a/tests/integrations/django/test_transactions.py b/tests/integrations/django/test_transactions.py
index a87dc621a9..160da9223d 100644
--- a/tests/integrations/django/test_transactions.py
+++ b/tests/integrations/django/test_transactions.py
@@ -24,13 +24,16 @@
url(r"^api/(?P(v1|v2))/author/$", lambda x: ""),
url(r"^report/", lambda x: ""),
url(r"^example/", include(included_url_conf)),
+ url(
+ r"^(?P[$\\-_.+!*(),\\w//]+)/$", lambda x: ""
+ ), # example of complex regex from django-cms
)
def test_legacy_resolver_no_match():
resolver = RavenResolver()
result = resolver.resolve("/foo/bar", example_url_conf)
- assert result == "/foo/bar"
+ assert result is None
def test_legacy_resolver_complex_match():
@@ -53,6 +56,16 @@ def test_legacy_resolver_included_match():
assert result == "/example/foo/bar/{param}"
+def test_complex_regex_from_django_cms():
+ """
+ Reference: https://github.com/getsentry/sentry-python/issues/1527
+ """
+
+ resolver = RavenResolver()
+ result = resolver.resolve("/,/", example_url_conf)
+ assert result == "/{slug}/"
+
+
@pytest.mark.skipif(django.VERSION < (2, 0), reason="Requires Django > 2.0")
def test_legacy_resolver_newstyle_django20_urlconf():
from django.urls import path
diff --git a/tests/integrations/django/utils.py b/tests/integrations/django/utils.py
new file mode 100644
index 0000000000..8f68c8fa14
--- /dev/null
+++ b/tests/integrations/django/utils.py
@@ -0,0 +1,22 @@
+from functools import partial
+
+import pytest
+import pytest_django
+
+
+# Hack to prevent from experimental feature introduced in version `4.3.0` in `pytest-django` that
+# requires explicit database allow from failing the test
+pytest_mark_django_db_decorator = partial(pytest.mark.django_db)
+try:
+ pytest_version = tuple(map(int, pytest_django.__version__.split(".")))
+ if pytest_version > (4, 2, 0):
+ pytest_mark_django_db_decorator = partial(
+ pytest.mark.django_db, databases="__all__"
+ )
+except ValueError:
+ if "dev" in pytest_django.__version__:
+ pytest_mark_django_db_decorator = partial(
+ pytest.mark.django_db, databases="__all__"
+ )
+except AttributeError:
+ pass
diff --git a/tests/integrations/falcon/test_falcon.py b/tests/integrations/falcon/test_falcon.py
index 84e8d228f0..dd7aa80dfe 100644
--- a/tests/integrations/falcon/test_falcon.py
+++ b/tests/integrations/falcon/test_falcon.py
@@ -21,8 +21,14 @@ def on_get(self, req, resp):
sentry_sdk.capture_message("hi")
resp.media = "hi"
+ class MessageByIdResource:
+ def on_get(self, req, resp, message_id):
+ sentry_sdk.capture_message("hi")
+ resp.media = "hi"
+
app = falcon.API()
app.add_route("/message", MessageResource())
+ app.add_route("/message/{message_id:int}", MessageByIdResource())
return app
@@ -53,22 +59,34 @@ def test_has_context(sentry_init, capture_events, make_client):
@pytest.mark.parametrize(
- "transaction_style,expected_transaction",
- [("uri_template", "/message"), ("path", "/message")],
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ ("/message", "uri_template", "/message", "route"),
+ ("/message", "path", "/message", "url"),
+ ("/message/123456", "uri_template", "/message/{message_id:int}", "route"),
+ ("/message/123456", "path", "/message/123456", "url"),
+ ],
)
def test_transaction_style(
- sentry_init, make_client, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ make_client,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
):
integration = FalconIntegration(transaction_style=transaction_style)
sentry_init(integrations=[integration])
events = capture_events()
client = make_client()
- response = client.simulate_get("/message")
+ response = client.simulate_get(url)
assert response.status == falcon.HTTP_200
(event,) = events
assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
def test_unhandled_errors(sentry_init, capture_exceptions, capture_events):
@@ -189,9 +207,9 @@ def on_post(self, req, resp):
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]["bar"]) == 512
+ assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
diff --git a/tests/integrations/fastapi/__init__.py b/tests/integrations/fastapi/__init__.py
new file mode 100644
index 0000000000..7f667e6f75
--- /dev/null
+++ b/tests/integrations/fastapi/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("fastapi")
diff --git a/tests/integrations/fastapi/test_fastapi.py b/tests/integrations/fastapi/test_fastapi.py
new file mode 100644
index 0000000000..86e7a612d8
--- /dev/null
+++ b/tests/integrations/fastapi/test_fastapi.py
@@ -0,0 +1,220 @@
+import json
+import logging
+import threading
+
+import pytest
+from sentry_sdk.integrations.fastapi import FastApiIntegration
+
+fastapi = pytest.importorskip("fastapi")
+
+from fastapi import FastAPI, Request
+from fastapi.testclient import TestClient
+from sentry_sdk import capture_message
+from sentry_sdk.integrations.starlette import StarletteIntegration
+from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+
+def fastapi_app_factory():
+ app = FastAPI()
+
+ @app.get("/message")
+ async def _message():
+ capture_message("Hi")
+ return {"message": "Hi"}
+
+ @app.get("/message/{message_id}")
+ async def _message_with_id(message_id):
+ capture_message("Hi")
+ return {"message": "Hi"}
+
+ @app.get("/sync/thread_ids")
+ def _thread_ids_sync():
+ return {
+ "main": str(threading.main_thread().ident),
+ "active": str(threading.current_thread().ident),
+ }
+
+ @app.get("/async/thread_ids")
+ async def _thread_ids_async():
+ return {
+ "main": str(threading.main_thread().ident),
+ "active": str(threading.current_thread().ident),
+ }
+
+ return app
+
+
+@pytest.mark.asyncio
+async def test_response(sentry_init, capture_events):
+ # FastAPI is heavily based on Starlette so we also need
+ # to enable StarletteIntegration.
+ # In the future this will be auto enabled.
+ sentry_init(
+ integrations=[StarletteIntegration(), FastApiIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ )
+
+ app = fastapi_app_factory()
+
+ events = capture_events()
+
+ client = TestClient(app)
+ response = client.get("/message")
+
+ assert response.json() == {"message": "Hi"}
+
+ assert len(events) == 2
+
+ (message_event, transaction_event) = events
+ assert message_event["message"] == "Hi"
+ assert transaction_event["transaction"] == "/message"
+
+
+@pytest.mark.parametrize(
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ (
+ "/message",
+ "url",
+ "/message",
+ "route",
+ ),
+ (
+ "/message",
+ "endpoint",
+ "tests.integrations.fastapi.test_fastapi.fastapi_app_factory.._message",
+ "component",
+ ),
+ (
+ "/message/123456",
+ "url",
+ "/message/{message_id}",
+ "route",
+ ),
+ (
+ "/message/123456",
+ "endpoint",
+ "tests.integrations.fastapi.test_fastapi.fastapi_app_factory.._message_with_id",
+ "component",
+ ),
+ ],
+)
+def test_transaction_style(
+ sentry_init,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
+):
+ sentry_init(
+ integrations=[
+ StarletteIntegration(transaction_style=transaction_style),
+ FastApiIntegration(transaction_style=transaction_style),
+ ],
+ )
+ app = fastapi_app_factory()
+
+ events = capture_events()
+
+ client = TestClient(app)
+ client.get(url)
+
+ (event,) = events
+ assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
+
+ # Assert that state is not leaked
+ events.clear()
+ capture_message("foo")
+ (event,) = events
+
+ assert "request" not in event
+ assert "transaction" not in event
+
+
+def test_legacy_setup(
+ sentry_init,
+ capture_events,
+):
+ # Check that behaviour does not change
+ # if the user just adds the new Integrations
+ # and forgets to remove SentryAsgiMiddleware
+ sentry_init()
+ app = fastapi_app_factory()
+ asgi_app = SentryAsgiMiddleware(app)
+
+ events = capture_events()
+
+ client = TestClient(asgi_app)
+ client.get("/message/123456")
+
+ (event,) = events
+ assert event["transaction"] == "/message/{message_id}"
+
+
+@pytest.mark.parametrize("endpoint", ["/sync/thread_ids", "/async/thread_ids"])
+@mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0)
+def test_active_thread_id(sentry_init, capture_envelopes, teardown_profiling, endpoint):
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+ app = fastapi_app_factory()
+ asgi_app = SentryAsgiMiddleware(app)
+
+ envelopes = capture_envelopes()
+
+ client = TestClient(asgi_app)
+ response = client.get(endpoint)
+ assert response.status_code == 200
+
+ data = json.loads(response.content)
+
+ envelopes = [envelope for envelope in envelopes]
+ assert len(envelopes) == 1
+
+ profiles = [item for item in envelopes[0].items if item.type == "profile"]
+ assert len(profiles) == 1
+
+ for profile in profiles:
+ transactions = profile.payload.json["transactions"]
+ assert len(transactions) == 1
+ assert str(data["active"]) == transactions[0]["active_thread_id"]
+
+
+@pytest.mark.asyncio
+async def test_original_request_not_scrubbed(sentry_init, capture_events):
+ sentry_init(
+ integrations=[StarletteIntegration(), FastApiIntegration()],
+ traces_sample_rate=1.0,
+ debug=True,
+ )
+
+ app = FastAPI()
+
+ @app.post("/error")
+ async def _error(request: Request):
+ logging.critical("Oh no!")
+ assert request.headers["Authorization"] == "Bearer ohno"
+ assert await request.json() == {"password": "secret"}
+
+ return {"error": "Oh no!"}
+
+ events = capture_events()
+
+ client = TestClient(app)
+ client.post(
+ "/error", json={"password": "secret"}, headers={"Authorization": "Bearer ohno"}
+ )
+
+ event = events[0]
+ assert event["request"]["data"] == {"password": "[Filtered]"}
+ assert event["request"]["headers"]["authorization"] == "[Filtered]"
diff --git a/tests/integrations/flask/test_flask.py b/tests/integrations/flask/test_flask.py
index 8723a35c86..097edd48c2 100644
--- a/tests/integrations/flask/test_flask.py
+++ b/tests/integrations/flask/test_flask.py
@@ -28,6 +28,7 @@
)
from sentry_sdk.integrations.logging import LoggingIntegration
import sentry_sdk.integrations.flask as flask_sentry
+from sentry_sdk.serializer import MAX_DATABAG_BREADTH
login_manager = LoginManager()
@@ -46,6 +47,11 @@ def hi():
capture_message("hi")
return "ok"
+ @app.route("/message/")
+ def hi_with_id(message_id):
+ capture_message("hi again")
+ return "ok"
+
return app
@@ -74,10 +80,22 @@ def test_has_context(sentry_init, app, capture_events):
@pytest.mark.parametrize(
- "transaction_style,expected_transaction", [("endpoint", "hi"), ("url", "/message")]
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ ("/message", "endpoint", "hi", "component"),
+ ("/message", "url", "/message", "route"),
+ ("/message/123456", "endpoint", "hi_with_id", "component"),
+ ("/message/123456", "url", "/message/", "route"),
+ ],
)
def test_transaction_style(
- sentry_init, app, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ app,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
):
sentry_init(
integrations=[
@@ -87,11 +105,12 @@ def test_transaction_style(
events = capture_events()
client = app.test_client()
- response = client.get("/message")
+ response = client.get(url)
assert response.status_code == 200
(event,) = events
assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
@pytest.mark.parametrize("debug", (True, False))
@@ -245,9 +264,9 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]["bar"]) == 512
+ assert len(event["request"]["data"]["foo"]["bar"]) == 1024
def test_flask_session_tracking(sentry_init, capture_envelopes, app):
@@ -334,9 +353,9 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]) == 512
+ assert len(event["request"]["data"]["foo"]) == 1024
def test_flask_formdata_request_appear_transaction_body(
@@ -396,9 +415,7 @@ def index():
assert response.status_code == 200
(event,) = events
- assert event["_meta"]["request"]["data"] == {
- "": {"len": 2000, "rem": [["!config", "x", 0, 2000]]}
- }
+ assert event["_meta"]["request"]["data"] == {"": {"rem": [["!config", "x"]]}}
assert not event["request"]["data"]
@@ -423,16 +440,40 @@ def index():
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]) == 512
+ assert len(event["request"]["data"]["foo"]) == 1024
- assert event["_meta"]["request"]["data"]["file"] == {
- "": {"len": 0, "rem": [["!raw", "x", 0, 0]]}
- }
+ assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}}
assert not event["request"]["data"]["file"]
+def test_json_not_truncated_if_request_bodies_is_always(
+ sentry_init, capture_events, app
+):
+ sentry_init(integrations=[flask_sentry.FlaskIntegration()], request_bodies="always")
+
+ data = {
+ "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
+ }
+
+ @app.route("/", methods=["POST"])
+ def index():
+ assert request.get_json() == data
+ assert request.get_data() == json.dumps(data).encode("ascii")
+ capture_message("hi")
+ return "ok"
+
+ events = capture_events()
+
+ client = app.test_client()
+ response = client.post("/", content_type="application/json", data=json.dumps(data))
+ assert response.status_code == 200
+
+ (event,) = events
+ assert event["request"]["data"] == data
+
+
@pytest.mark.parametrize(
"integrations",
[
@@ -724,6 +765,25 @@ def error():
assert exception["type"] == "ZeroDivisionError"
+def test_error_has_trace_context_if_tracing_disabled(sentry_init, capture_events, app):
+ sentry_init(integrations=[flask_sentry.FlaskIntegration()])
+
+ events = capture_events()
+
+ @app.route("/error")
+ def error():
+ 1 / 0
+
+ with pytest.raises(ZeroDivisionError):
+ with app.test_client() as client:
+ response = client.get("/error")
+ assert response.status_code == 500
+
+ (error_event,) = events
+
+ assert error_event["contexts"]["trace"]
+
+
def test_class_based_views(sentry_init, app, capture_events):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
@@ -775,3 +835,26 @@ def index():
response = client.get("/")
assert response.status_code == 200
assert response.data == b"hi"
+
+
+def test_request_not_modified_by_reference(sentry_init, capture_events, app):
+ sentry_init(integrations=[flask_sentry.FlaskIntegration()])
+
+ @app.route("/", methods=["POST"])
+ def index():
+ logging.critical("oops")
+ assert request.get_json() == {"password": "ohno"}
+ assert request.headers["Authorization"] == "Bearer ohno"
+ return "ok"
+
+ events = capture_events()
+
+ client = app.test_client()
+ client.post(
+ "/", json={"password": "ohno"}, headers={"Authorization": "Bearer ohno"}
+ )
+
+ (event,) = events
+
+ assert event["request"]["data"]["password"] == "[Filtered]"
+ assert event["request"]["headers"]["Authorization"] == "[Filtered]"
diff --git a/tests/integrations/gcp/test_gcp.py b/tests/integrations/gcp/test_gcp.py
index 78ac8f2746..678219dc8b 100644
--- a/tests/integrations/gcp/test_gcp.py
+++ b/tests/integrations/gcp/test_gcp.py
@@ -93,9 +93,8 @@ def init_sdk(timeout_warning=False, **extra_init_args):
@pytest.fixture
def run_cloud_function():
def inner(code, subprocess_kwargs=()):
-
- event = []
- envelope = []
+ events = []
+ envelopes = []
return_value = None
# STEP : Create a zip of cloud function
@@ -133,10 +132,10 @@ def inner(code, subprocess_kwargs=()):
print("GCP:", line)
if line.startswith("EVENT: "):
line = line[len("EVENT: ") :]
- event = json.loads(line)
+ events.append(json.loads(line))
elif line.startswith("ENVELOPE: "):
line = line[len("ENVELOPE: ") :]
- envelope = json.loads(line)
+ envelopes.append(json.loads(line))
elif line.startswith("RETURN VALUE: "):
line = line[len("RETURN VALUE: ") :]
return_value = json.loads(line)
@@ -145,13 +144,13 @@ def inner(code, subprocess_kwargs=()):
stream.close()
- return envelope, event, return_value
+ return envelopes, events, return_value
return inner
def test_handled_exception(run_cloud_function):
- envelope, event, return_value = run_cloud_function(
+ _, events, return_value = run_cloud_function(
dedent(
"""
functionhandler = None
@@ -168,16 +167,17 @@ def cloud_function(functionhandler, event):
"""
)
)
- assert event["level"] == "error"
- (exception,) = event["exception"]["values"]
+ assert events[0]["level"] == "error"
+ (exception,) = events[0]["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "something went wrong"
- assert exception["mechanism"] == {"type": "gcp", "handled": False}
+ assert exception["mechanism"]["type"] == "gcp"
+ assert not exception["mechanism"]["handled"]
def test_unhandled_exception(run_cloud_function):
- envelope, event, return_value = run_cloud_function(
+ _, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
@@ -195,16 +195,17 @@ def cloud_function(functionhandler, event):
"""
)
)
- assert event["level"] == "error"
- (exception,) = event["exception"]["values"]
+ assert events[0]["level"] == "error"
+ (exception,) = events[0]["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["value"] == "division by zero"
- assert exception["mechanism"] == {"type": "gcp", "handled": False}
+ assert exception["mechanism"]["type"] == "gcp"
+ assert not exception["mechanism"]["handled"]
def test_timeout_error(run_cloud_function):
- envelope, event, return_value = run_cloud_function(
+ _, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
@@ -222,19 +223,20 @@ def cloud_function(functionhandler, event):
"""
)
)
- assert event["level"] == "error"
- (exception,) = event["exception"]["values"]
+ assert events[0]["level"] == "error"
+ (exception,) = events[0]["exception"]["values"]
assert exception["type"] == "ServerlessTimeoutWarning"
assert (
exception["value"]
== "WARNING : Function is expected to get timed out. Configured timeout duration = 3 seconds."
)
- assert exception["mechanism"] == {"type": "threading", "handled": False}
+ assert exception["mechanism"]["type"] == "threading"
+ assert not exception["mechanism"]["handled"]
def test_performance_no_error(run_cloud_function):
- envelope, event, return_value = run_cloud_function(
+ envelopes, _, _ = run_cloud_function(
dedent(
"""
functionhandler = None
@@ -252,14 +254,15 @@ def cloud_function(functionhandler, event):
)
)
- assert envelope["type"] == "transaction"
- assert envelope["contexts"]["trace"]["op"] == "serverless.function"
- assert envelope["transaction"].startswith("Google Cloud function")
- assert envelope["transaction"] in envelope["request"]["url"]
+ assert envelopes[0]["type"] == "transaction"
+ assert envelopes[0]["contexts"]["trace"]["op"] == "function.gcp"
+ assert envelopes[0]["transaction"].startswith("Google Cloud function")
+ assert envelopes[0]["transaction_info"] == {"source": "component"}
+ assert envelopes[0]["transaction"] in envelopes[0]["request"]["url"]
def test_performance_error(run_cloud_function):
- envelope, event, return_value = run_cloud_function(
+ envelopes, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
@@ -277,16 +280,18 @@ def cloud_function(functionhandler, event):
)
)
- assert envelope["type"] == "transaction"
- assert envelope["contexts"]["trace"]["op"] == "serverless.function"
- assert envelope["transaction"].startswith("Google Cloud function")
- assert envelope["transaction"] in envelope["request"]["url"]
- assert event["level"] == "error"
- (exception,) = event["exception"]["values"]
+ assert envelopes[0]["level"] == "error"
+ (exception,) = envelopes[0]["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "something went wrong"
- assert exception["mechanism"] == {"type": "gcp", "handled": False}
+ assert exception["mechanism"]["type"] == "gcp"
+ assert not exception["mechanism"]["handled"]
+
+ assert envelopes[1]["type"] == "transaction"
+ assert envelopes[1]["contexts"]["trace"]["op"] == "function.gcp"
+ assert envelopes[1]["transaction"].startswith("Google Cloud function")
+ assert envelopes[1]["transaction"] in envelopes[0]["request"]["url"]
def test_traces_sampler_gets_correct_values_in_sampling_context(
@@ -366,3 +371,184 @@ def _safe_is_equal(x, y):
)
assert return_value["AssertionError raised"] is False
+
+
+def test_error_has_new_trace_context_performance_enabled(run_cloud_function):
+ """
+ Check if an 'trace' context is added to errros and transactions when performance monitoring is enabled.
+ """
+ envelopes, _, _ = run_cloud_function(
+ dedent(
+ """
+ functionhandler = None
+ event = {}
+ def cloud_function(functionhandler, event):
+ sentry_sdk.capture_message("hi")
+ x = 3/0
+ return "3"
+ """
+ )
+ + FUNCTIONS_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=1.0)
+ gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
+ """
+ )
+ )
+ (msg_event, error_event, transaction_event) = envelopes
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_new_trace_context_performance_disabled(run_cloud_function):
+ """
+ Check if an 'trace' context is added to errros and transactions when performance monitoring is disabled.
+ """
+ _, events, _ = run_cloud_function(
+ dedent(
+ """
+ functionhandler = None
+ event = {}
+ def cloud_function(functionhandler, event):
+ sentry_sdk.capture_message("hi")
+ x = 3/0
+ return "3"
+ """
+ )
+ + FUNCTIONS_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=None), # this is the default, just added for clarity
+ gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
+ """
+ )
+ )
+
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_existing_trace_context_performance_enabled(run_cloud_function):
+ """
+ Check if an 'trace' context is added to errros and transactions
+ from the incoming 'sentry-trace' header when performance monitoring is enabled.
+ """
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ envelopes, _, _ = run_cloud_function(
+ dedent(
+ """
+ functionhandler = None
+
+ from collections import namedtuple
+ GCPEvent = namedtuple("GCPEvent", ["headers"])
+ event = GCPEvent(headers={"sentry-trace": "%s"})
+
+ def cloud_function(functionhandler, event):
+ sentry_sdk.capture_message("hi")
+ x = 3/0
+ return "3"
+ """
+ % sentry_trace_header
+ )
+ + FUNCTIONS_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=1.0)
+ gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
+ """
+ )
+ )
+ (msg_event, error_event, transaction_event) = envelopes
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
+
+
+def test_error_has_existing_trace_context_performance_disabled(run_cloud_function):
+ """
+ Check if an 'trace' context is added to errros and transactions
+ from the incoming 'sentry-trace' header when performance monitoring is disabled.
+ """
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ _, events, _ = run_cloud_function(
+ dedent(
+ """
+ functionhandler = None
+
+ from collections import namedtuple
+ GCPEvent = namedtuple("GCPEvent", ["headers"])
+ event = GCPEvent(headers={"sentry-trace": "%s"})
+
+ def cloud_function(functionhandler, event):
+ sentry_sdk.capture_message("hi")
+ x = 3/0
+ return "3"
+ """
+ % sentry_trace_header
+ )
+ + FUNCTIONS_PRELUDE
+ + dedent(
+ """
+ init_sdk(traces_sample_rate=None), # this is the default, just added for clarity
+ gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
+ """
+ )
+ )
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
diff --git a/tests/integrations/grpc/__init__.py b/tests/integrations/grpc/__init__.py
new file mode 100644
index 0000000000..88a0a201e4
--- /dev/null
+++ b/tests/integrations/grpc/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("grpc")
diff --git a/tests/integrations/grpc/grpc_test_service.proto b/tests/integrations/grpc/grpc_test_service.proto
new file mode 100644
index 0000000000..43497c7129
--- /dev/null
+++ b/tests/integrations/grpc/grpc_test_service.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package grpc_test_server;
+
+service gRPCTestService{
+ rpc TestServe(gRPCTestMessage) returns (gRPCTestMessage);
+}
+
+message gRPCTestMessage {
+ string text = 1;
+}
diff --git a/tests/integrations/grpc/grpc_test_service_pb2.py b/tests/integrations/grpc/grpc_test_service_pb2.py
new file mode 100644
index 0000000000..94765dae2c
--- /dev/null
+++ b/tests/integrations/grpc/grpc_test_service_pb2.py
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: grpc_test_service.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+ b'\n\x17grpc_test_service.proto\x12\x10grpc_test_server"\x1f\n\x0fgRPCTestMessage\x12\x0c\n\x04text\x18\x01 \x01(\t2d\n\x0fgRPCTestService\x12Q\n\tTestServe\x12!.grpc_test_server.gRPCTestMessage\x1a!.grpc_test_server.gRPCTestMessageb\x06proto3'
+)
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "grpc_test_service_pb2", globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+ DESCRIPTOR._options = None
+ _GRPCTESTMESSAGE._serialized_start = 45
+ _GRPCTESTMESSAGE._serialized_end = 76
+ _GRPCTESTSERVICE._serialized_start = 78
+ _GRPCTESTSERVICE._serialized_end = 178
+# @@protoc_insertion_point(module_scope)
diff --git a/tests/integrations/grpc/grpc_test_service_pb2.pyi b/tests/integrations/grpc/grpc_test_service_pb2.pyi
new file mode 100644
index 0000000000..02a0b7045b
--- /dev/null
+++ b/tests/integrations/grpc/grpc_test_service_pb2.pyi
@@ -0,0 +1,32 @@
+"""
+@generated by mypy-protobuf. Do not edit manually!
+isort:skip_file
+"""
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.message
+import sys
+
+if sys.version_info >= (3, 8):
+ import typing as typing_extensions
+else:
+ import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing_extensions.final
+class gRPCTestMessage(google.protobuf.message.Message):
+ DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+ TEXT_FIELD_NUMBER: builtins.int
+ text: builtins.str
+ def __init__(
+ self,
+ *,
+ text: builtins.str = ...,
+ ) -> None: ...
+ def ClearField(
+ self, field_name: typing_extensions.Literal["text", b"text"]
+ ) -> None: ...
+
+global___gRPCTestMessage = gRPCTestMessage
diff --git a/tests/integrations/grpc/grpc_test_service_pb2_grpc.py b/tests/integrations/grpc/grpc_test_service_pb2_grpc.py
new file mode 100644
index 0000000000..73b7d94c16
--- /dev/null
+++ b/tests/integrations/grpc/grpc_test_service_pb2_grpc.py
@@ -0,0 +1,79 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+import tests.integrations.grpc.grpc_test_service_pb2 as grpc__test__service__pb2
+
+
+class gRPCTestServiceStub(object):
+ """Missing associated documentation comment in .proto file."""
+
+ def __init__(self, channel):
+ """Constructor.
+
+ Args:
+ channel: A grpc.Channel.
+ """
+ self.TestServe = channel.unary_unary(
+ "/grpc_test_server.gRPCTestService/TestServe",
+ request_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
+ response_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
+ )
+
+
+class gRPCTestServiceServicer(object):
+ """Missing associated documentation comment in .proto file."""
+
+ def TestServe(self, request, context):
+ """Missing associated documentation comment in .proto file."""
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details("Method not implemented!")
+ raise NotImplementedError("Method not implemented!")
+
+
+def add_gRPCTestServiceServicer_to_server(servicer, server):
+ rpc_method_handlers = {
+ "TestServe": grpc.unary_unary_rpc_method_handler(
+ servicer.TestServe,
+ request_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
+ response_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
+ ),
+ }
+ generic_handler = grpc.method_handlers_generic_handler(
+ "grpc_test_server.gRPCTestService", rpc_method_handlers
+ )
+ server.add_generic_rpc_handlers((generic_handler,))
+
+
+# This class is part of an EXPERIMENTAL API.
+class gRPCTestService(object):
+ """Missing associated documentation comment in .proto file."""
+
+ @staticmethod
+ def TestServe(
+ request,
+ target,
+ options=(),
+ channel_credentials=None,
+ call_credentials=None,
+ insecure=False,
+ compression=None,
+ wait_for_ready=None,
+ timeout=None,
+ metadata=None,
+ ):
+ return grpc.experimental.unary_unary(
+ request,
+ target,
+ "/grpc_test_server.gRPCTestService/TestServe",
+ grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
+ grpc__test__service__pb2.gRPCTestMessage.FromString,
+ options,
+ channel_credentials,
+ insecure,
+ call_credentials,
+ compression,
+ wait_for_ready,
+ timeout,
+ metadata,
+ )
diff --git a/tests/integrations/grpc/test_grpc.py b/tests/integrations/grpc/test_grpc.py
new file mode 100644
index 0000000000..92883e9256
--- /dev/null
+++ b/tests/integrations/grpc/test_grpc.py
@@ -0,0 +1,189 @@
+from __future__ import absolute_import
+
+import os
+
+from concurrent import futures
+
+import grpc
+import pytest
+
+from sentry_sdk import Hub, start_transaction
+from sentry_sdk.consts import OP
+from sentry_sdk.integrations.grpc.client import ClientInterceptor
+from sentry_sdk.integrations.grpc.server import ServerInterceptor
+from tests.integrations.grpc.grpc_test_service_pb2 import gRPCTestMessage
+from tests.integrations.grpc.grpc_test_service_pb2_grpc import (
+ gRPCTestServiceServicer,
+ add_gRPCTestServiceServicer_to_server,
+ gRPCTestServiceStub,
+)
+
+PORT = 50051
+PORT += os.getpid() % 100 # avoid port conflicts when running tests in parallel
+
+
+@pytest.mark.forked
+def test_grpc_server_starts_transaction(sentry_init, capture_events_forksafe):
+ sentry_init(traces_sample_rate=1.0)
+ events = capture_events_forksafe()
+
+ server = _set_up()
+
+ with grpc.insecure_channel(f"localhost:{PORT}") as channel:
+ stub = gRPCTestServiceStub(channel)
+ stub.TestServe(gRPCTestMessage(text="test"))
+
+ _tear_down(server=server)
+
+ events.write_file.close()
+ event = events.read_event()
+ span = event["spans"][0]
+
+ assert event["type"] == "transaction"
+ assert event["transaction_info"] == {
+ "source": "custom",
+ }
+ assert event["contexts"]["trace"]["op"] == OP.GRPC_SERVER
+ assert span["op"] == "test"
+
+
+@pytest.mark.forked
+def test_grpc_server_continues_transaction(sentry_init, capture_events_forksafe):
+ sentry_init(traces_sample_rate=1.0)
+ events = capture_events_forksafe()
+
+ server = _set_up()
+
+ with grpc.insecure_channel(f"localhost:{PORT}") as channel:
+ stub = gRPCTestServiceStub(channel)
+
+ with start_transaction() as transaction:
+ metadata = (
+ (
+ "baggage",
+ "sentry-trace_id={trace_id},sentry-environment=test,"
+ "sentry-transaction=test-transaction,sentry-sample_rate=1.0".format(
+ trace_id=transaction.trace_id
+ ),
+ ),
+ (
+ "sentry-trace",
+ "{trace_id}-{parent_span_id}-{sampled}".format(
+ trace_id=transaction.trace_id,
+ parent_span_id=transaction.span_id,
+ sampled=1,
+ ),
+ ),
+ )
+ stub.TestServe(gRPCTestMessage(text="test"), metadata=metadata)
+
+ _tear_down(server=server)
+
+ events.write_file.close()
+ event = events.read_event()
+ span = event["spans"][0]
+
+ assert event["type"] == "transaction"
+ assert event["transaction_info"] == {
+ "source": "custom",
+ }
+ assert event["contexts"]["trace"]["op"] == OP.GRPC_SERVER
+ assert event["contexts"]["trace"]["trace_id"] == transaction.trace_id
+ assert span["op"] == "test"
+
+
+@pytest.mark.forked
+def test_grpc_client_starts_span(sentry_init, capture_events_forksafe):
+ sentry_init(traces_sample_rate=1.0)
+ events = capture_events_forksafe()
+ interceptors = [ClientInterceptor()]
+
+ server = _set_up()
+
+ with grpc.insecure_channel(f"localhost:{PORT}") as channel:
+ channel = grpc.intercept_channel(channel, *interceptors)
+ stub = gRPCTestServiceStub(channel)
+
+ with start_transaction():
+ stub.TestServe(gRPCTestMessage(text="test"))
+
+ _tear_down(server=server)
+
+ events.write_file.close()
+ events.read_event()
+ local_transaction = events.read_event()
+ span = local_transaction["spans"][0]
+
+ assert len(local_transaction["spans"]) == 1
+ assert span["op"] == OP.GRPC_CLIENT
+ assert (
+ span["description"]
+ == "unary unary call to /grpc_test_server.gRPCTestService/TestServe"
+ )
+ assert span["data"] == {
+ "type": "unary unary",
+ "method": "/grpc_test_server.gRPCTestService/TestServe",
+ "code": "OK",
+ }
+
+
+@pytest.mark.forked
+def test_grpc_client_and_servers_interceptors_integration(
+ sentry_init, capture_events_forksafe
+):
+ sentry_init(traces_sample_rate=1.0)
+ events = capture_events_forksafe()
+ interceptors = [ClientInterceptor()]
+
+ server = _set_up()
+
+ with grpc.insecure_channel(f"localhost:{PORT}") as channel:
+ channel = grpc.intercept_channel(channel, *interceptors)
+ stub = gRPCTestServiceStub(channel)
+
+ with start_transaction():
+ stub.TestServe(gRPCTestMessage(text="test"))
+
+ _tear_down(server=server)
+
+ events.write_file.close()
+ server_transaction = events.read_event()
+ local_transaction = events.read_event()
+
+ assert (
+ server_transaction["contexts"]["trace"]["trace_id"]
+ == local_transaction["contexts"]["trace"]["trace_id"]
+ )
+
+
+def _set_up():
+ server = grpc.server(
+ futures.ThreadPoolExecutor(max_workers=2),
+ interceptors=[ServerInterceptor(find_name=_find_name)],
+ )
+
+ add_gRPCTestServiceServicer_to_server(TestService, server)
+ server.add_insecure_port(f"[::]:{PORT}")
+ server.start()
+
+ return server
+
+
+def _tear_down(server: grpc.Server):
+ server.stop(None)
+
+
+def _find_name(request):
+ return request.__class__
+
+
+class TestService(gRPCTestServiceServicer):
+ events = []
+
+ @staticmethod
+ def TestServe(request, context): # noqa: N802
+ hub = Hub.current
+ with hub.start_span(op="test", description="test"):
+ pass
+
+ return gRPCTestMessage(text=request.text)
diff --git a/tests/integrations/httpx/test_httpx.py b/tests/integrations/httpx/test_httpx.py
index 4623f13348..72188a23e3 100644
--- a/tests/integrations/httpx/test_httpx.py
+++ b/tests/integrations/httpx/test_httpx.py
@@ -1,66 +1,259 @@
import asyncio
+import pytest
import httpx
+import responses
from sentry_sdk import capture_message, start_transaction
+from sentry_sdk.consts import MATCH_ALL, SPANDATA
from sentry_sdk.integrations.httpx import HttpxIntegration
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
-def test_crumb_capture_and_hint(sentry_init, capture_events):
+
+@pytest.mark.parametrize(
+ "httpx_client",
+ (httpx.Client(), httpx.AsyncClient()),
+)
+def test_crumb_capture_and_hint(sentry_init, capture_events, httpx_client):
def before_breadcrumb(crumb, hint):
crumb["data"]["extra"] = "foo"
return crumb
sentry_init(integrations=[HttpxIntegration()], before_breadcrumb=before_breadcrumb)
- clients = (httpx.Client(), httpx.AsyncClient())
- for i, c in enumerate(clients):
- with start_transaction():
- events = capture_events()
-
- url = "https://httpbin.org/status/200"
- if not asyncio.iscoroutinefunction(c.get):
- response = c.get(url)
- else:
- response = asyncio.get_event_loop().run_until_complete(c.get(url))
-
- assert response.status_code == 200
- capture_message("Testing!")
-
- (event,) = events
- # send request twice so we need get breadcrumb by index
- crumb = event["breadcrumbs"]["values"][i]
- assert crumb["type"] == "http"
- assert crumb["category"] == "httplib"
- assert crumb["data"] == {
- "url": url,
- "method": "GET",
- "status_code": 200,
- "reason": "OK",
- "extra": "foo",
- }
-
-
-def test_outgoing_trace_headers(sentry_init):
+
+ url = "http://example.com/"
+ responses.add(responses.GET, url, status=200)
+
+ with start_transaction():
+ events = capture_events()
+
+ if asyncio.iscoroutinefunction(httpx_client.get):
+ response = asyncio.get_event_loop().run_until_complete(
+ httpx_client.get(url)
+ )
+ else:
+ response = httpx_client.get(url)
+
+ assert response.status_code == 200
+ capture_message("Testing!")
+
+ (event,) = events
+
+ crumb = event["breadcrumbs"]["values"][0]
+ assert crumb["type"] == "http"
+ assert crumb["category"] == "httplib"
+ assert crumb["data"] == {
+ "url": url,
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_FRAGMENT: "",
+ SPANDATA.HTTP_QUERY: "",
+ SPANDATA.HTTP_STATUS_CODE: 200,
+ "reason": "OK",
+ "extra": "foo",
+ }
+
+
+@pytest.mark.parametrize(
+ "httpx_client",
+ (httpx.Client(), httpx.AsyncClient()),
+)
+def test_outgoing_trace_headers(sentry_init, httpx_client):
sentry_init(traces_sample_rate=1.0, integrations=[HttpxIntegration()])
- clients = (httpx.Client(), httpx.AsyncClient())
- for i, c in enumerate(clients):
- with start_transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- # make trace_id difference between transactions
- trace_id=f"012345678901234567890123456789{i}",
- ) as transaction:
- url = "https://httpbin.org/status/200"
- if not asyncio.iscoroutinefunction(c.get):
- response = c.get(url)
- else:
- response = asyncio.get_event_loop().run_until_complete(c.get(url))
-
- request_span = transaction._span_recorder.spans[-1]
- assert response.request.headers[
- "sentry-trace"
- ] == "{trace_id}-{parent_span_id}-{sampled}".format(
- trace_id=transaction.trace_id,
- parent_span_id=request_span.span_id,
- sampled=1,
+
+ url = "http://example.com/"
+ responses.add(responses.GET, url, status=200)
+
+ with start_transaction(
+ name="/interactions/other-dogs/new-dog",
+ op="greeting.sniff",
+ trace_id="01234567890123456789012345678901",
+ ) as transaction:
+ if asyncio.iscoroutinefunction(httpx_client.get):
+ response = asyncio.get_event_loop().run_until_complete(
+ httpx_client.get(url)
)
+ else:
+ response = httpx_client.get(url)
+
+ request_span = transaction._span_recorder.spans[-1]
+ assert response.request.headers[
+ "sentry-trace"
+ ] == "{trace_id}-{parent_span_id}-{sampled}".format(
+ trace_id=transaction.trace_id,
+ parent_span_id=request_span.span_id,
+ sampled=1,
+ )
+
+
+@pytest.mark.parametrize(
+ "httpx_client,trace_propagation_targets,url,trace_propagated",
+ [
+ [
+ httpx.Client(),
+ None,
+ "https://example.com/",
+ False,
+ ],
+ [
+ httpx.Client(),
+ [],
+ "https://example.com/",
+ False,
+ ],
+ [
+ httpx.Client(),
+ [MATCH_ALL],
+ "https://example.com/",
+ True,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com/"],
+ "https://example.com/",
+ True,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com/"],
+ "https://example.com",
+ False,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com"],
+ "https://example.com",
+ True,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://example.net",
+ False,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://good.example.net",
+ True,
+ ],
+ [
+ httpx.Client(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://good.example.net/some/thing",
+ True,
+ ],
+ [
+ httpx.AsyncClient(),
+ None,
+ "https://example.com/",
+ False,
+ ],
+ [
+ httpx.AsyncClient(),
+ [],
+ "https://example.com/",
+ False,
+ ],
+ [
+ httpx.AsyncClient(),
+ [MATCH_ALL],
+ "https://example.com/",
+ True,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com/"],
+ "https://example.com/",
+ True,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com/"],
+ "https://example.com",
+ False,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com"],
+ "https://example.com",
+ True,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://example.net",
+ False,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://good.example.net",
+ True,
+ ],
+ [
+ httpx.AsyncClient(),
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "https://good.example.net/some/thing",
+ True,
+ ],
+ ],
+)
+def test_option_trace_propagation_targets(
+ sentry_init,
+ httpx_client,
+ httpx_mock, # this comes from pytest-httpx
+ trace_propagation_targets,
+ url,
+ trace_propagated,
+):
+ httpx_mock.add_response()
+
+ sentry_init(
+ release="test",
+ trace_propagation_targets=trace_propagation_targets,
+ traces_sample_rate=1.0,
+ integrations=[HttpxIntegration()],
+ )
+
+ if asyncio.iscoroutinefunction(httpx_client.get):
+ asyncio.get_event_loop().run_until_complete(httpx_client.get(url))
+ else:
+ httpx_client.get(url)
+
+ request_headers = httpx_mock.get_request().headers
+
+ if trace_propagated:
+ assert "sentry-trace" in request_headers
+ else:
+ assert "sentry-trace" not in request_headers
+
+
+@pytest.mark.tests_internal_exceptions
+def test_omit_url_data_if_parsing_fails(sentry_init, capture_events):
+ sentry_init(integrations=[HttpxIntegration()])
+
+ httpx_client = httpx.Client()
+ url = "http://example.com"
+ responses.add(responses.GET, url, status=200)
+
+ events = capture_events()
+ with mock.patch(
+ "sentry_sdk.integrations.httpx.parse_url",
+ side_effect=ValueError,
+ ):
+ response = httpx_client.get(url)
+
+ assert response.status_code == 200
+ capture_message("Testing!")
+
+ (event,) = events
+ assert event["breadcrumbs"]["values"][0]["data"] == {
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_STATUS_CODE: 200,
+ "reason": "OK",
+ # no url related data
+ }
diff --git a/tests/integrations/huey/__init__.py b/tests/integrations/huey/__init__.py
new file mode 100644
index 0000000000..448a7eb2f7
--- /dev/null
+++ b/tests/integrations/huey/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("huey")
diff --git a/tests/integrations/huey/test_huey.py b/tests/integrations/huey/test_huey.py
new file mode 100644
index 0000000000..819a4816d7
--- /dev/null
+++ b/tests/integrations/huey/test_huey.py
@@ -0,0 +1,140 @@
+import pytest
+from decimal import DivisionByZero
+
+from sentry_sdk import start_transaction
+from sentry_sdk.integrations.huey import HueyIntegration
+
+from huey.api import MemoryHuey, Result
+from huey.exceptions import RetryTask
+
+
+@pytest.fixture
+def init_huey(sentry_init):
+ def inner():
+ sentry_init(
+ integrations=[HueyIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ debug=True,
+ )
+
+ return MemoryHuey(name="sentry_sdk")
+
+ return inner
+
+
+@pytest.fixture(autouse=True)
+def flush_huey_tasks(init_huey):
+ huey = init_huey()
+ huey.flush()
+
+
+def execute_huey_task(huey, func, *args, **kwargs):
+ exceptions = kwargs.pop("exceptions", None)
+ result = func(*args, **kwargs)
+ task = huey.dequeue()
+ if exceptions is not None:
+ try:
+ huey.execute(task)
+ except exceptions:
+ pass
+ else:
+ huey.execute(task)
+ return result
+
+
+def test_task_result(init_huey):
+ huey = init_huey()
+
+ @huey.task()
+ def increase(num):
+ return num + 1
+
+ result = increase(3)
+
+ assert isinstance(result, Result)
+ assert len(huey) == 1
+ task = huey.dequeue()
+ assert huey.execute(task) == 4
+ assert result.get() == 4
+
+
+@pytest.mark.parametrize("task_fails", [True, False], ids=["error", "success"])
+def test_task_transaction(capture_events, init_huey, task_fails):
+ huey = init_huey()
+
+ @huey.task()
+ def division(a, b):
+ return a / b
+
+ events = capture_events()
+ execute_huey_task(
+ huey, division, 1, int(not task_fails), exceptions=(DivisionByZero,)
+ )
+
+ if task_fails:
+ error_event = events.pop(0)
+ assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
+ assert error_event["exception"]["values"][0]["mechanism"]["type"] == "huey"
+
+ (event,) = events
+ assert event["type"] == "transaction"
+ assert event["transaction"] == "division"
+ assert event["transaction_info"] == {"source": "task"}
+
+ if task_fails:
+ assert event["contexts"]["trace"]["status"] == "internal_error"
+ else:
+ assert event["contexts"]["trace"]["status"] == "ok"
+
+ assert "huey_task_id" in event["tags"]
+ assert "huey_task_retry" in event["tags"]
+
+
+def test_task_retry(capture_events, init_huey):
+ huey = init_huey()
+ context = {"retry": True}
+
+ @huey.task()
+ def retry_task(context):
+ if context["retry"]:
+ context["retry"] = False
+ raise RetryTask()
+
+ events = capture_events()
+ result = execute_huey_task(huey, retry_task, context)
+ (event,) = events
+
+ assert event["transaction"] == "retry_task"
+ assert event["tags"]["huey_task_id"] == result.task.id
+ assert len(huey) == 1
+
+ task = huey.dequeue()
+ huey.execute(task)
+ (event, _) = events
+
+ assert event["transaction"] == "retry_task"
+ assert event["tags"]["huey_task_id"] == result.task.id
+ assert len(huey) == 0
+
+
+def test_huey_enqueue(init_huey, capture_events):
+ huey = init_huey()
+
+ @huey.task(name="different_task_name")
+ def dummy_task():
+ pass
+
+ events = capture_events()
+
+ with start_transaction() as transaction:
+ dummy_task()
+
+ (event,) = events
+
+ assert event["contexts"]["trace"]["trace_id"] == transaction.trace_id
+ assert event["contexts"]["trace"]["span_id"] == transaction.span_id
+
+ assert len(event["spans"])
+ assert event["spans"][0]["op"] == "queue.submit.huey"
+ assert event["spans"][0]["description"] == "different_task_name"
diff --git a/tests/integrations/logging/test_logging.py b/tests/integrations/logging/test_logging.py
index 73843cc6eb..de1c55e26f 100644
--- a/tests/integrations/logging/test_logging.py
+++ b/tests/integrations/logging/test_logging.py
@@ -1,3 +1,4 @@
+# coding: utf-8
import sys
import pytest
@@ -115,6 +116,45 @@ def test_logging_level(sentry_init, capture_events):
assert not events
+def test_custom_log_level_names(sentry_init, capture_events):
+ levels = {
+ logging.DEBUG: "debug",
+ logging.INFO: "info",
+ logging.WARN: "warning",
+ logging.WARNING: "warning",
+ logging.ERROR: "error",
+ logging.CRITICAL: "fatal",
+ logging.FATAL: "fatal",
+ }
+
+ # set custom log level names
+ # fmt: off
+ logging.addLevelName(logging.DEBUG, u"custom level debüg: ")
+ # fmt: on
+ logging.addLevelName(logging.INFO, "")
+ logging.addLevelName(logging.WARN, "custom level warn: ")
+ logging.addLevelName(logging.WARNING, "custom level warning: ")
+ logging.addLevelName(logging.ERROR, None)
+ logging.addLevelName(logging.CRITICAL, "custom level critical: ")
+ logging.addLevelName(logging.FATAL, "custom level 🔥: ")
+
+ for logging_level, sentry_level in levels.items():
+ logger.setLevel(logging_level)
+ sentry_init(
+ integrations=[LoggingIntegration(event_level=logging_level)],
+ default_integrations=False,
+ )
+ events = capture_events()
+
+ logger.log(logging_level, "Trying level %s", logging_level)
+ assert events
+ assert events[0]["level"] == sentry_level
+ assert events[0]["logentry"]["message"] == "Trying level %s"
+ assert events[0]["logentry"]["params"] == [logging_level]
+
+ del events[:]
+
+
def test_logging_filters(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
diff --git a/tests/integrations/loguru/__init__.py b/tests/integrations/loguru/__init__.py
new file mode 100644
index 0000000000..9d67fb3799
--- /dev/null
+++ b/tests/integrations/loguru/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("loguru")
diff --git a/tests/integrations/loguru/test_loguru.py b/tests/integrations/loguru/test_loguru.py
new file mode 100644
index 0000000000..3185f021c3
--- /dev/null
+++ b/tests/integrations/loguru/test_loguru.py
@@ -0,0 +1,77 @@
+import pytest
+from loguru import logger
+
+import sentry_sdk
+from sentry_sdk.integrations.loguru import LoguruIntegration, LoggingLevels
+
+logger.remove(0) # don't print to console
+
+
+@pytest.mark.parametrize(
+ "level,created_event",
+ [
+ # None - no breadcrumb
+ # False - no event
+ # True - event created
+ (LoggingLevels.TRACE, None),
+ (LoggingLevels.DEBUG, None),
+ (LoggingLevels.INFO, False),
+ (LoggingLevels.SUCCESS, False),
+ (LoggingLevels.WARNING, False),
+ (LoggingLevels.ERROR, True),
+ (LoggingLevels.CRITICAL, True),
+ ],
+)
+@pytest.mark.parametrize("disable_breadcrumbs", [True, False])
+@pytest.mark.parametrize("disable_events", [True, False])
+def test_just_log(
+ sentry_init,
+ capture_events,
+ level,
+ created_event,
+ disable_breadcrumbs,
+ disable_events,
+):
+ sentry_init(
+ integrations=[
+ LoguruIntegration(
+ level=None if disable_breadcrumbs else LoggingLevels.INFO.value,
+ event_level=None if disable_events else LoggingLevels.ERROR.value,
+ )
+ ],
+ default_integrations=False,
+ )
+ events = capture_events()
+
+ getattr(logger, level.name.lower())("test")
+
+ formatted_message = (
+ " | "
+ + "{:9}".format(level.name.upper())
+ + "| tests.integrations.loguru.test_loguru:test_just_log:46 - test"
+ )
+
+ if not created_event:
+ assert not events
+
+ breadcrumbs = sentry_sdk.Hub.current.scope._breadcrumbs
+ if (
+ not disable_breadcrumbs and created_event is not None
+ ): # not None == not TRACE or DEBUG level
+ (breadcrumb,) = breadcrumbs
+ assert breadcrumb["level"] == level.name.lower()
+ assert breadcrumb["category"] == "tests.integrations.loguru.test_loguru"
+ assert breadcrumb["message"][23:] == formatted_message
+ else:
+ assert not breadcrumbs
+
+ return
+
+ if disable_events:
+ assert not events
+ return
+
+ (event,) = events
+ assert event["level"] == (level.name.lower())
+ assert event["logger"] == "tests.integrations.loguru.test_loguru"
+ assert event["logentry"]["message"][23:] == formatted_message
diff --git a/tests/integrations/modules/test_modules.py b/tests/integrations/modules/test_modules.py
index 3f4d7bd9dc..b552a14a1c 100644
--- a/tests/integrations/modules/test_modules.py
+++ b/tests/integrations/modules/test_modules.py
@@ -1,6 +1,21 @@
+import re
import sentry_sdk
-from sentry_sdk.integrations.modules import ModulesIntegration
+from sentry_sdk.integrations.modules import (
+ ModulesIntegration,
+ _get_installed_modules,
+)
+
+
+def _normalize_distribution_name(name):
+ # type: (str) -> str
+ """Normalize distribution name according to PEP-0503.
+
+ See:
+ https://peps.python.org/pep-0503/#normalized-names
+ for more details.
+ """
+ return re.sub(r"[-_.]+", "-", name).lower()
def test_basic(sentry_init, capture_events):
@@ -12,3 +27,40 @@ def test_basic(sentry_init, capture_events):
(event,) = events
assert "sentry-sdk" in event["modules"]
assert "pytest" in event["modules"]
+
+
+def test_installed_modules():
+ try:
+ from importlib.metadata import distributions, version
+
+ importlib_available = True
+ except ImportError:
+ importlib_available = False
+
+ try:
+ import pkg_resources
+
+ pkg_resources_available = True
+ except ImportError:
+ pkg_resources_available = False
+
+ installed_distributions = {
+ _normalize_distribution_name(dist): version
+ for dist, version in _get_installed_modules().items()
+ }
+
+ if importlib_available:
+ importlib_distributions = {
+ _normalize_distribution_name(dist.metadata["Name"]): version(
+ dist.metadata["Name"]
+ )
+ for dist in distributions()
+ }
+ assert installed_distributions == importlib_distributions
+
+ if pkg_resources_available:
+ pkg_resources_distributions = {
+ _normalize_distribution_name(dist.key): dist.version
+ for dist in pkg_resources.working_set
+ }
+ assert installed_distributions == pkg_resources_distributions
diff --git a/tests/integrations/opentelemetry/__init__.py b/tests/integrations/opentelemetry/__init__.py
new file mode 100644
index 0000000000..39ecc610d5
--- /dev/null
+++ b/tests/integrations/opentelemetry/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+django = pytest.importorskip("opentelemetry")
diff --git a/tests/integrations/opentelemetry/test_propagator.py b/tests/integrations/opentelemetry/test_propagator.py
new file mode 100644
index 0000000000..d3e29707e5
--- /dev/null
+++ b/tests/integrations/opentelemetry/test_propagator.py
@@ -0,0 +1,252 @@
+try:
+ from unittest import mock # python 3.3 and above
+ from unittest.mock import MagicMock
+except ImportError:
+ import mock # python < 3.3
+ from mock import MagicMock
+
+from opentelemetry.context import get_current
+from opentelemetry.trace.propagation import get_current_span
+from opentelemetry.trace import (
+ set_span_in_context,
+ TraceFlags,
+ SpanContext,
+)
+from sentry_sdk.integrations.opentelemetry.consts import (
+ SENTRY_BAGGAGE_KEY,
+ SENTRY_TRACE_KEY,
+)
+
+from sentry_sdk.integrations.opentelemetry.propagator import SentryPropagator
+from sentry_sdk.integrations.opentelemetry.span_processor import SentrySpanProcessor
+from sentry_sdk.tracing_utils import Baggage
+
+
+def test_extract_no_context_no_sentry_trace_header():
+ """
+ No context and NO Sentry trace data in getter.
+ Extract should return empty context.
+ """
+ carrier = None
+ context = None
+ getter = MagicMock()
+ getter.get.return_value = None
+
+ modified_context = SentryPropagator().extract(carrier, context, getter)
+
+ assert modified_context == {}
+
+
+def test_extract_context_no_sentry_trace_header():
+ """
+ Context but NO Sentry trace data in getter.
+ Extract should return context as is.
+ """
+ carrier = None
+ context = {"some": "value"}
+ getter = MagicMock()
+ getter.get.return_value = None
+
+ modified_context = SentryPropagator().extract(carrier, context, getter)
+
+ assert modified_context == context
+
+
+def test_extract_empty_context_sentry_trace_header_no_baggage():
+ """
+ Empty context but Sentry trace data but NO Baggage in getter.
+ Extract should return context that has empty baggage in it and also a NoopSpan with span_id and trace_id.
+ """
+ carrier = None
+ context = {}
+ getter = MagicMock()
+ getter.get.side_effect = [
+ ["1234567890abcdef1234567890abcdef-1234567890abcdef-1"],
+ None,
+ ]
+
+ modified_context = SentryPropagator().extract(carrier, context, getter)
+
+ assert len(modified_context.keys()) == 3
+
+ assert modified_context[SENTRY_TRACE_KEY] == {
+ "trace_id": "1234567890abcdef1234567890abcdef",
+ "parent_span_id": "1234567890abcdef",
+ "parent_sampled": True,
+ }
+ assert modified_context[SENTRY_BAGGAGE_KEY].serialize() == ""
+
+ span_context = get_current_span(modified_context).get_span_context()
+ assert span_context.span_id == int("1234567890abcdef", 16)
+ assert span_context.trace_id == int("1234567890abcdef1234567890abcdef", 16)
+
+
+def test_extract_context_sentry_trace_header_baggage():
+ """
+ Empty context but Sentry trace data and Baggage in getter.
+ Extract should return context that has baggage in it and also a NoopSpan with span_id and trace_id.
+ """
+ baggage_header = (
+ "other-vendor-value-1=foo;bar;baz, sentry-trace_id=771a43a4192642f0b136d5159a501700, "
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3, sentry-sample_rate=0.01337, "
+ "sentry-user_id=Am%C3%A9lie, other-vendor-value-2=foo;bar;"
+ )
+
+ carrier = None
+ context = {"some": "value"}
+ getter = MagicMock()
+ getter.get.side_effect = [
+ ["1234567890abcdef1234567890abcdef-1234567890abcdef-1"],
+ [baggage_header],
+ ]
+
+ modified_context = SentryPropagator().extract(carrier, context, getter)
+
+ assert len(modified_context.keys()) == 4
+
+ assert modified_context[SENTRY_TRACE_KEY] == {
+ "trace_id": "1234567890abcdef1234567890abcdef",
+ "parent_span_id": "1234567890abcdef",
+ "parent_sampled": True,
+ }
+
+ assert modified_context[SENTRY_BAGGAGE_KEY].serialize() == (
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700,"
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3,"
+ "sentry-sample_rate=0.01337,sentry-user_id=Am%C3%A9lie"
+ )
+
+ span_context = get_current_span(modified_context).get_span_context()
+ assert span_context.span_id == int("1234567890abcdef", 16)
+ assert span_context.trace_id == int("1234567890abcdef1234567890abcdef", 16)
+
+
+def test_inject_empty_otel_span_map():
+ """
+ Empty otel_span_map.
+ So there is no sentry_span to be found in inject()
+ and the function is returned early and no setters are called.
+ """
+ carrier = None
+ context = get_current()
+ setter = MagicMock()
+ setter.set = MagicMock()
+
+ span_context = SpanContext(
+ trace_id=int("1234567890abcdef1234567890abcdef", 16),
+ span_id=int("1234567890abcdef", 16),
+ trace_flags=TraceFlags(TraceFlags.SAMPLED),
+ is_remote=True,
+ )
+ span = MagicMock()
+ span.context = span_context
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.propagator.trace.get_current_span",
+ return_value=span,
+ ):
+ full_context = set_span_in_context(span, context)
+ SentryPropagator().inject(carrier, full_context, setter)
+
+ setter.set.assert_not_called()
+
+
+def test_inject_sentry_span_no_baggage():
+ """
+ Inject a sentry span with no baggage.
+ """
+ carrier = None
+ context = get_current()
+ setter = MagicMock()
+ setter.set = MagicMock()
+
+ trace_id = "1234567890abcdef1234567890abcdef"
+ span_id = "1234567890abcdef"
+
+ span_context = SpanContext(
+ trace_id=int(trace_id, 16),
+ span_id=int(span_id, 16),
+ trace_flags=TraceFlags(TraceFlags.SAMPLED),
+ is_remote=True,
+ )
+ span = MagicMock()
+ span.context = span_context
+
+ sentry_span = MagicMock()
+ sentry_span.to_traceparent = mock.Mock(
+ return_value="1234567890abcdef1234567890abcdef-1234567890abcdef-1"
+ )
+ sentry_span.containing_transaction.get_baggage = mock.Mock(return_value=None)
+
+ span_processor = SentrySpanProcessor()
+ span_processor.otel_span_map[span_id] = sentry_span
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.propagator.trace.get_current_span",
+ return_value=span,
+ ):
+ full_context = set_span_in_context(span, context)
+ SentryPropagator().inject(carrier, full_context, setter)
+
+ setter.set.assert_called_once_with(
+ carrier,
+ "sentry-trace",
+ "1234567890abcdef1234567890abcdef-1234567890abcdef-1",
+ )
+
+
+def test_inject_sentry_span_baggage():
+ """
+ Inject a sentry span with baggage.
+ """
+ carrier = None
+ context = get_current()
+ setter = MagicMock()
+ setter.set = MagicMock()
+
+ trace_id = "1234567890abcdef1234567890abcdef"
+ span_id = "1234567890abcdef"
+
+ span_context = SpanContext(
+ trace_id=int(trace_id, 16),
+ span_id=int(span_id, 16),
+ trace_flags=TraceFlags(TraceFlags.SAMPLED),
+ is_remote=True,
+ )
+ span = MagicMock()
+ span.context = span_context
+
+ sentry_span = MagicMock()
+ sentry_span.to_traceparent = mock.Mock(
+ return_value="1234567890abcdef1234567890abcdef-1234567890abcdef-1"
+ )
+ sentry_items = {
+ "sentry-trace_id": "771a43a4192642f0b136d5159a501700",
+ "sentry-public_key": "49d0f7386ad645858ae85020e393bef3",
+ "sentry-sample_rate": 0.01337,
+ "sentry-user_id": "Amélie",
+ }
+ baggage = Baggage(sentry_items=sentry_items)
+ sentry_span.containing_transaction.get_baggage = MagicMock(return_value=baggage)
+
+ span_processor = SentrySpanProcessor()
+ span_processor.otel_span_map[span_id] = sentry_span
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.propagator.trace.get_current_span",
+ return_value=span,
+ ):
+ full_context = set_span_in_context(span, context)
+ SentryPropagator().inject(carrier, full_context, setter)
+
+ setter.set.assert_any_call(
+ carrier,
+ "sentry-trace",
+ "1234567890abcdef1234567890abcdef-1234567890abcdef-1",
+ )
+
+ setter.set.assert_any_call(
+ carrier,
+ "baggage",
+ baggage.serialize(),
+ )
diff --git a/tests/integrations/opentelemetry/test_span_processor.py b/tests/integrations/opentelemetry/test_span_processor.py
new file mode 100644
index 0000000000..0db2a942a5
--- /dev/null
+++ b/tests/integrations/opentelemetry/test_span_processor.py
@@ -0,0 +1,472 @@
+from datetime import datetime
+import time
+
+try:
+ from unittest import mock # python 3.3 and above
+ from unittest.mock import MagicMock
+except ImportError:
+ import mock
+ from mock import MagicMock # python < 3.3
+
+from sentry_sdk.integrations.opentelemetry.span_processor import (
+ SentrySpanProcessor,
+ link_trace_context_to_error_event,
+)
+from sentry_sdk.tracing import Span, Transaction
+
+from opentelemetry.trace import SpanKind, SpanContext
+from sentry_sdk.tracing_utils import extract_sentrytrace_data
+
+
+def test_is_sentry_span():
+ otel_span = MagicMock()
+
+ hub = MagicMock()
+ hub.client = None
+
+ span_processor = SentrySpanProcessor()
+ assert not span_processor._is_sentry_span(hub, otel_span)
+
+ client = MagicMock()
+ client.options = {"instrumenter": "otel"}
+ client.dsn = "https://1234567890abcdef@o123456.ingest.sentry.io/123456"
+
+ hub.client = client
+ assert not span_processor._is_sentry_span(hub, otel_span)
+
+ otel_span.attributes = {
+ "http.url": "https://example.com",
+ }
+ assert not span_processor._is_sentry_span(hub, otel_span)
+
+ otel_span.attributes = {
+ "http.url": "https://o123456.ingest.sentry.io/api/123/envelope",
+ }
+ assert span_processor._is_sentry_span(hub, otel_span)
+
+
+def test_get_otel_context():
+ otel_span = MagicMock()
+ otel_span.attributes = {"foo": "bar"}
+ otel_span.resource = MagicMock()
+ otel_span.resource.attributes = {"baz": "qux"}
+
+ span_processor = SentrySpanProcessor()
+ otel_context = span_processor._get_otel_context(otel_span)
+
+ assert otel_context == {
+ "attributes": {"foo": "bar"},
+ "resource": {"baz": "qux"},
+ }
+
+
+def test_get_trace_data_with_span_and_trace():
+ otel_span = MagicMock()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = None
+
+ parent_context = {}
+
+ span_processor = SentrySpanProcessor()
+ sentry_trace_data = span_processor._get_trace_data(otel_span, parent_context)
+ assert sentry_trace_data["trace_id"] == "1234567890abcdef1234567890abcdef"
+ assert sentry_trace_data["span_id"] == "1234567890abcdef"
+ assert sentry_trace_data["parent_span_id"] is None
+ assert sentry_trace_data["parent_sampled"] is None
+ assert sentry_trace_data["baggage"] is None
+
+
+def test_get_trace_data_with_span_and_trace_and_parent():
+ otel_span = MagicMock()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = MagicMock()
+ otel_span.parent.span_id = int("abcdef1234567890", 16)
+
+ parent_context = {}
+
+ span_processor = SentrySpanProcessor()
+ sentry_trace_data = span_processor._get_trace_data(otel_span, parent_context)
+ assert sentry_trace_data["trace_id"] == "1234567890abcdef1234567890abcdef"
+ assert sentry_trace_data["span_id"] == "1234567890abcdef"
+ assert sentry_trace_data["parent_span_id"] == "abcdef1234567890"
+ assert sentry_trace_data["parent_sampled"] is None
+ assert sentry_trace_data["baggage"] is None
+
+
+def test_get_trace_data_with_sentry_trace():
+ otel_span = MagicMock()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = MagicMock()
+ otel_span.parent.span_id = int("abcdef1234567890", 16)
+
+ parent_context = {}
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.get_value",
+ side_effect=[
+ extract_sentrytrace_data(
+ "1234567890abcdef1234567890abcdef-1234567890abcdef-1"
+ ),
+ None,
+ ],
+ ):
+ span_processor = SentrySpanProcessor()
+ sentry_trace_data = span_processor._get_trace_data(otel_span, parent_context)
+ assert sentry_trace_data["trace_id"] == "1234567890abcdef1234567890abcdef"
+ assert sentry_trace_data["span_id"] == "1234567890abcdef"
+ assert sentry_trace_data["parent_span_id"] == "abcdef1234567890"
+ assert sentry_trace_data["parent_sampled"] is True
+ assert sentry_trace_data["baggage"] is None
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.get_value",
+ side_effect=[
+ extract_sentrytrace_data(
+ "1234567890abcdef1234567890abcdef-1234567890abcdef-0"
+ ),
+ None,
+ ],
+ ):
+ span_processor = SentrySpanProcessor()
+ sentry_trace_data = span_processor._get_trace_data(otel_span, parent_context)
+ assert sentry_trace_data["trace_id"] == "1234567890abcdef1234567890abcdef"
+ assert sentry_trace_data["span_id"] == "1234567890abcdef"
+ assert sentry_trace_data["parent_span_id"] == "abcdef1234567890"
+ assert sentry_trace_data["parent_sampled"] is False
+ assert sentry_trace_data["baggage"] is None
+
+
+def test_get_trace_data_with_sentry_trace_and_baggage():
+ otel_span = MagicMock()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = MagicMock()
+ otel_span.parent.span_id = int("abcdef1234567890", 16)
+
+ parent_context = {}
+
+ baggage = (
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700,"
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3,"
+ "sentry-sample_rate=0.01337,sentry-user_id=Am%C3%A9lie"
+ )
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.get_value",
+ side_effect=[
+ extract_sentrytrace_data(
+ "1234567890abcdef1234567890abcdef-1234567890abcdef-1"
+ ),
+ baggage,
+ ],
+ ):
+ span_processor = SentrySpanProcessor()
+ sentry_trace_data = span_processor._get_trace_data(otel_span, parent_context)
+ assert sentry_trace_data["trace_id"] == "1234567890abcdef1234567890abcdef"
+ assert sentry_trace_data["span_id"] == "1234567890abcdef"
+ assert sentry_trace_data["parent_span_id"] == "abcdef1234567890"
+ assert sentry_trace_data["parent_sampled"]
+ assert sentry_trace_data["baggage"] == baggage
+
+
+def test_update_span_with_otel_data_http_method():
+ sentry_span = Span()
+
+ otel_span = MagicMock()
+ otel_span.name = "Test OTel Span"
+ otel_span.kind = SpanKind.CLIENT
+ otel_span.attributes = {
+ "http.method": "GET",
+ "http.status_code": 429,
+ "http.status_text": "xxx",
+ "http.user_agent": "curl/7.64.1",
+ "net.peer.name": "example.com",
+ "http.target": "/",
+ }
+
+ span_processor = SentrySpanProcessor()
+ span_processor._update_span_with_otel_data(sentry_span, otel_span)
+
+ assert sentry_span.op == "http.client"
+ assert sentry_span.description == "GET example.com /"
+ assert sentry_span.status == "resource_exhausted"
+
+ assert sentry_span._data["http.method"] == "GET"
+ assert sentry_span._data["http.response.status_code"] == 429
+ assert sentry_span._data["http.status_text"] == "xxx"
+ assert sentry_span._data["http.user_agent"] == "curl/7.64.1"
+ assert sentry_span._data["net.peer.name"] == "example.com"
+ assert sentry_span._data["http.target"] == "/"
+
+
+def test_update_span_with_otel_data_http_method2():
+ sentry_span = Span()
+
+ otel_span = MagicMock()
+ otel_span.name = "Test OTel Span"
+ otel_span.kind = SpanKind.SERVER
+ otel_span.attributes = {
+ "http.method": "GET",
+ "http.status_code": 429,
+ "http.status_text": "xxx",
+ "http.user_agent": "curl/7.64.1",
+ "http.url": "https://example.com/status/403?password=123&username=test@example.com&author=User123&auth=1234567890abcdef",
+ }
+
+ span_processor = SentrySpanProcessor()
+ span_processor._update_span_with_otel_data(sentry_span, otel_span)
+
+ assert sentry_span.op == "http.server"
+ assert sentry_span.description == "GET https://example.com/status/403"
+ assert sentry_span.status == "resource_exhausted"
+
+ assert sentry_span._data["http.method"] == "GET"
+ assert sentry_span._data["http.response.status_code"] == 429
+ assert sentry_span._data["http.status_text"] == "xxx"
+ assert sentry_span._data["http.user_agent"] == "curl/7.64.1"
+ assert (
+ sentry_span._data["http.url"]
+ == "https://example.com/status/403?password=123&username=test@example.com&author=User123&auth=1234567890abcdef"
+ )
+
+
+def test_update_span_with_otel_data_db_query():
+ sentry_span = Span()
+
+ otel_span = MagicMock()
+ otel_span.name = "Test OTel Span"
+ otel_span.attributes = {
+ "db.system": "postgresql",
+ "db.statement": "SELECT * FROM table where pwd = '123456'",
+ }
+
+ span_processor = SentrySpanProcessor()
+ span_processor._update_span_with_otel_data(sentry_span, otel_span)
+
+ assert sentry_span.op == "db"
+ assert sentry_span.description == "SELECT * FROM table where pwd = '123456'"
+
+ assert sentry_span._data["db.system"] == "postgresql"
+ assert (
+ sentry_span._data["db.statement"] == "SELECT * FROM table where pwd = '123456'"
+ )
+
+
+def test_on_start_transaction():
+ otel_span = MagicMock()
+ otel_span.name = "Sample OTel Span"
+ otel_span.start_time = time.time_ns()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = MagicMock()
+ otel_span.parent.span_id = int("abcdef1234567890", 16)
+
+ parent_context = {}
+
+ fake_client = MagicMock()
+ fake_client.options = {"instrumenter": "otel"}
+ fake_client.dsn = "https://1234567890abcdef@o123456.ingest.sentry.io/123456"
+
+ current_hub = MagicMock()
+ current_hub.client = fake_client
+
+ fake_hub = MagicMock()
+ fake_hub.current = current_hub
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.Hub", fake_hub
+ ):
+ span_processor = SentrySpanProcessor()
+ span_processor.on_start(otel_span, parent_context)
+
+ fake_hub.current.start_transaction.assert_called_once_with(
+ name="Sample OTel Span",
+ span_id="1234567890abcdef",
+ parent_span_id="abcdef1234567890",
+ trace_id="1234567890abcdef1234567890abcdef",
+ baggage=None,
+ start_timestamp=datetime.fromtimestamp(otel_span.start_time / 1e9),
+ instrumenter="otel",
+ )
+
+ assert len(span_processor.otel_span_map.keys()) == 1
+ assert list(span_processor.otel_span_map.keys())[0] == "1234567890abcdef"
+
+
+def test_on_start_child():
+ otel_span = MagicMock()
+ otel_span.name = "Sample OTel Span"
+ otel_span.start_time = time.time_ns()
+ otel_span.context = MagicMock()
+ otel_span.context.trace_id = int("1234567890abcdef1234567890abcdef", 16)
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+ otel_span.parent = MagicMock()
+ otel_span.parent.span_id = int("abcdef1234567890", 16)
+
+ parent_context = {}
+
+ fake_client = MagicMock()
+ fake_client.options = {"instrumenter": "otel"}
+ fake_client.dsn = "https://1234567890abcdef@o123456.ingest.sentry.io/123456"
+
+ current_hub = MagicMock()
+ current_hub.client = fake_client
+
+ fake_hub = MagicMock()
+ fake_hub.current = current_hub
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.Hub", fake_hub
+ ):
+ fake_span = MagicMock()
+
+ span_processor = SentrySpanProcessor()
+ span_processor.otel_span_map["abcdef1234567890"] = fake_span
+ span_processor.on_start(otel_span, parent_context)
+
+ fake_span.start_child.assert_called_once_with(
+ span_id="1234567890abcdef",
+ description="Sample OTel Span",
+ start_timestamp=datetime.fromtimestamp(otel_span.start_time / 1e9),
+ instrumenter="otel",
+ )
+
+ assert len(span_processor.otel_span_map.keys()) == 2
+ assert "abcdef1234567890" in span_processor.otel_span_map.keys()
+ assert "1234567890abcdef" in span_processor.otel_span_map.keys()
+
+
+def test_on_end_no_sentry_span():
+ """
+ If on_end is called on a span that is not in the otel_span_map, it should be a no-op.
+ """
+ otel_span = MagicMock()
+ otel_span.name = "Sample OTel Span"
+ otel_span.end_time = time.time_ns()
+ otel_span.context = MagicMock()
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+
+ span_processor = SentrySpanProcessor()
+ span_processor.otel_span_map = {}
+ span_processor._get_otel_context = MagicMock()
+ span_processor._update_span_with_otel_data = MagicMock()
+
+ span_processor.on_end(otel_span)
+
+ span_processor._get_otel_context.assert_not_called()
+ span_processor._update_span_with_otel_data.assert_not_called()
+
+
+def test_on_end_sentry_transaction():
+ """
+ Test on_end for a sentry Transaction.
+ """
+ otel_span = MagicMock()
+ otel_span.name = "Sample OTel Span"
+ otel_span.end_time = time.time_ns()
+ otel_span.context = MagicMock()
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+
+ fake_sentry_span = MagicMock(spec=Transaction)
+ fake_sentry_span.set_context = MagicMock()
+ fake_sentry_span.finish = MagicMock()
+
+ span_processor = SentrySpanProcessor()
+ span_processor._get_otel_context = MagicMock()
+ span_processor._update_span_with_otel_data = MagicMock()
+ span_processor.otel_span_map["1234567890abcdef"] = fake_sentry_span
+
+ span_processor.on_end(otel_span)
+
+ fake_sentry_span.set_context.assert_called_once()
+ span_processor._update_span_with_otel_data.assert_not_called()
+ fake_sentry_span.finish.assert_called_once()
+
+
+def test_on_end_sentry_span():
+ """
+ Test on_end for a sentry Span.
+ """
+ otel_span = MagicMock()
+ otel_span.name = "Sample OTel Span"
+ otel_span.end_time = time.time_ns()
+ otel_span.context = MagicMock()
+ otel_span.context.span_id = int("1234567890abcdef", 16)
+
+ fake_sentry_span = MagicMock(spec=Span)
+ fake_sentry_span.set_context = MagicMock()
+ fake_sentry_span.finish = MagicMock()
+
+ span_processor = SentrySpanProcessor()
+ span_processor._get_otel_context = MagicMock()
+ span_processor._update_span_with_otel_data = MagicMock()
+ span_processor.otel_span_map["1234567890abcdef"] = fake_sentry_span
+
+ span_processor.on_end(otel_span)
+
+ fake_sentry_span.set_context.assert_not_called()
+ span_processor._update_span_with_otel_data.assert_called_once_with(
+ fake_sentry_span, otel_span
+ )
+ fake_sentry_span.finish.assert_called_once()
+
+
+def test_link_trace_context_to_error_event():
+ """
+ Test that the trace context is added to the error event.
+ """
+ fake_client = MagicMock()
+ fake_client.options = {"instrumenter": "otel"}
+ fake_client
+
+ current_hub = MagicMock()
+ current_hub.client = fake_client
+
+ fake_hub = MagicMock()
+ fake_hub.current = current_hub
+
+ span_id = "1234567890abcdef"
+ trace_id = "1234567890abcdef1234567890abcdef"
+
+ fake_trace_context = {
+ "bla": "blub",
+ "foo": "bar",
+ "baz": 123,
+ }
+
+ sentry_span = MagicMock()
+ sentry_span.get_trace_context = MagicMock(return_value=fake_trace_context)
+
+ otel_span_map = {
+ span_id: sentry_span,
+ }
+
+ span_context = SpanContext(
+ trace_id=int(trace_id, 16),
+ span_id=int(span_id, 16),
+ is_remote=True,
+ )
+ otel_span = MagicMock()
+ otel_span.get_span_context = MagicMock(return_value=span_context)
+
+ fake_event = {"event_id": "1234567890abcdef1234567890abcdef"}
+
+ with mock.patch(
+ "sentry_sdk.integrations.opentelemetry.span_processor.get_current_span",
+ return_value=otel_span,
+ ):
+ event = link_trace_context_to_error_event(fake_event, otel_span_map)
+
+ assert event
+ assert event == fake_event # the event is changed in place inside the function
+ assert "contexts" in event
+ assert "trace" in event["contexts"]
+ assert event["contexts"]["trace"] == fake_trace_context
diff --git a/tests/integrations/pure_eval/test_pure_eval.py b/tests/integrations/pure_eval/test_pure_eval.py
index e7da025144..2d1a92026e 100644
--- a/tests/integrations/pure_eval/test_pure_eval.py
+++ b/tests/integrations/pure_eval/test_pure_eval.py
@@ -8,8 +8,8 @@
@pytest.mark.parametrize("integrations", [[], [PureEvalIntegration()]])
-def test_with_locals_enabled(sentry_init, capture_events, integrations):
- sentry_init(with_locals=True, integrations=integrations)
+def test_include_local_variables_enabled(sentry_init, capture_events, integrations):
+ sentry_init(include_local_variables=True, integrations=integrations)
events = capture_events()
def foo():
diff --git a/tests/integrations/pymongo/__init__.py b/tests/integrations/pymongo/__init__.py
new file mode 100644
index 0000000000..91223b0630
--- /dev/null
+++ b/tests/integrations/pymongo/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("pymongo")
diff --git a/tests/integrations/pymongo/test_pymongo.py b/tests/integrations/pymongo/test_pymongo.py
new file mode 100644
index 0000000000..786c775e41
--- /dev/null
+++ b/tests/integrations/pymongo/test_pymongo.py
@@ -0,0 +1,421 @@
+from sentry_sdk import capture_message, start_transaction
+from sentry_sdk.consts import SPANDATA
+from sentry_sdk.integrations.pymongo import PyMongoIntegration, _strip_pii
+
+from mockupdb import MockupDB, OpQuery
+from pymongo import MongoClient
+import pytest
+
+
+@pytest.fixture(scope="session")
+def mongo_server():
+ server = MockupDB(verbose=True)
+ server.autoresponds("ismaster", maxWireVersion=6)
+ server.run()
+ server.autoresponds(
+ {"find": "test_collection"}, cursor={"id": 123, "firstBatch": []}
+ )
+ # Find query changed somewhere between PyMongo 3.1 and 3.12.
+ # This line is to respond to "find" queries sent by old PyMongo the same way it's done above.
+ server.autoresponds(OpQuery({"foobar": 1}), cursor={"id": 123, "firstBatch": []})
+ server.autoresponds({"insert": "test_collection"}, ok=1)
+ server.autoresponds({"insert": "erroneous"}, ok=0, errmsg="test error")
+ yield server
+ server.stop()
+
+
+@pytest.mark.parametrize("with_pii", [False, True])
+def test_transactions(sentry_init, capture_events, mongo_server, with_pii):
+ sentry_init(
+ integrations=[PyMongoIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=with_pii,
+ )
+ events = capture_events()
+
+ connection = MongoClient(mongo_server.uri)
+
+ with start_transaction():
+ list(
+ connection["test_db"]["test_collection"].find({"foobar": 1})
+ ) # force query execution
+ connection["test_db"]["test_collection"].insert_one({"foo": 2})
+ try:
+ connection["test_db"]["erroneous"].insert_many([{"bar": 3}, {"baz": 4}])
+ pytest.fail("Request should raise")
+ except Exception:
+ pass
+
+ (event,) = events
+ (find, insert_success, insert_fail) = event["spans"]
+
+ common_tags = {
+ "db.name": "test_db",
+ "db.system": "mongodb",
+ "net.peer.name": mongo_server.host,
+ "net.peer.port": str(mongo_server.port),
+ }
+ for span in find, insert_success, insert_fail:
+ assert span["data"][SPANDATA.DB_SYSTEM] == "mongodb"
+ for field, value in common_tags.items():
+ assert span["tags"][field] == value
+
+ assert find["op"] == "db.query"
+ assert insert_success["op"] == "db.query"
+ assert insert_fail["op"] == "db.query"
+
+ assert find["tags"]["db.operation"] == "find"
+ assert insert_success["tags"]["db.operation"] == "insert"
+ assert insert_fail["tags"]["db.operation"] == "insert"
+
+ assert find["description"].startswith("find {")
+ assert insert_success["description"].startswith("insert {")
+ assert insert_fail["description"].startswith("insert {")
+ if with_pii:
+ assert "1" in find["description"]
+ assert "2" in insert_success["description"]
+ assert "3" in insert_fail["description"] and "4" in insert_fail["description"]
+ else:
+ # All values in filter replaced by "%s"
+ assert "1" not in find["description"]
+ # All keys below top level replaced by "%s"
+ assert "2" not in insert_success["description"]
+ assert (
+ "3" not in insert_fail["description"]
+ and "4" not in insert_fail["description"]
+ )
+
+ assert find["tags"]["status"] == "ok"
+ assert insert_success["tags"]["status"] == "ok"
+ assert insert_fail["tags"]["status"] == "internal_error"
+
+
+@pytest.mark.parametrize("with_pii", [False, True])
+def test_breadcrumbs(sentry_init, capture_events, mongo_server, with_pii):
+ sentry_init(
+ integrations=[PyMongoIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=with_pii,
+ )
+ events = capture_events()
+
+ connection = MongoClient(mongo_server.uri)
+
+ list(
+ connection["test_db"]["test_collection"].find({"foobar": 1})
+ ) # force query execution
+ capture_message("hi")
+
+ (event,) = events
+ (crumb,) = event["breadcrumbs"]["values"]
+
+ assert crumb["category"] == "query"
+ assert crumb["message"].startswith("find {")
+ if with_pii:
+ assert "1" in crumb["message"]
+ else:
+ assert "1" not in crumb["message"]
+ assert crumb["type"] == "db.query"
+ assert crumb["data"] == {
+ "db.name": "test_db",
+ "db.system": "mongodb",
+ "db.operation": "find",
+ "net.peer.name": mongo_server.host,
+ "net.peer.port": str(mongo_server.port),
+ }
+
+
+@pytest.mark.parametrize(
+ "testcase",
+ [
+ {
+ "command": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {
+ "username": "anton2",
+ "email": "anton@somewhere.io",
+ "password": "c4e86722fb56d946f7ddeecdae47e1c4458bf98a0a3ee5d5113111adf7bf0175",
+ "_id": "635bc7403cb4f8a736f61cf2",
+ }
+ ],
+ },
+ "command_stripped": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {"username": "%s", "email": "%s", "password": "%s", "_id": "%s"}
+ ],
+ },
+ },
+ {
+ "command": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {
+ "username": "indiana4",
+ "email": "indy@jones.org",
+ "password": "63e86722fb56d946f7ddeecdae47e1c4458bf98a0a3ee5d5113111adf7bf016b",
+ "_id": "635bc7403cb4f8a736f61cf3",
+ }
+ ],
+ },
+ "command_stripped": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {"username": "%s", "email": "%s", "password": "%s", "_id": "%s"}
+ ],
+ },
+ },
+ {
+ "command": {
+ "find": "my_collection",
+ "filter": {},
+ "limit": 1,
+ "singleBatch": True,
+ },
+ "command_stripped": {
+ "find": "my_collection",
+ "filter": {},
+ "limit": 1,
+ "singleBatch": True,
+ },
+ },
+ {
+ "command": {
+ "find": "my_collection",
+ "filter": {"username": "notthere"},
+ "limit": 1,
+ "singleBatch": True,
+ },
+ "command_stripped": {
+ "find": "my_collection",
+ "filter": {"username": "%s"},
+ "limit": 1,
+ "singleBatch": True,
+ },
+ },
+ {
+ "command": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {
+ "username": "userx1",
+ "email": "x@somewhere.io",
+ "password": "ccc86722fb56d946f7ddeecdae47e1c4458bf98a0a3ee5d5113111adf7bf0175",
+ "_id": "635bc7403cb4f8a736f61cf4",
+ },
+ {
+ "username": "userx2",
+ "email": "x@somewhere.io",
+ "password": "xxx86722fb56d946f7ddeecdae47e1c4458bf98a0a3ee5d5113111adf7bf0175",
+ "_id": "635bc7403cb4f8a736f61cf5",
+ },
+ ],
+ },
+ "command_stripped": {
+ "insert": "my_collection",
+ "ordered": True,
+ "documents": [
+ {"username": "%s", "email": "%s", "password": "%s", "_id": "%s"},
+ {"username": "%s", "email": "%s", "password": "%s", "_id": "%s"},
+ ],
+ },
+ },
+ {
+ "command": {
+ "find": "my_collection",
+ "filter": {"email": "ada@lovelace.com"},
+ },
+ "command_stripped": {"find": "my_collection", "filter": {"email": "%s"}},
+ },
+ {
+ "command": {
+ "aggregate": "my_collection",
+ "pipeline": [{"$match": {}}, {"$group": {"_id": 1, "n": {"$sum": 1}}}],
+ "cursor": {},
+ },
+ "command_stripped": {
+ "aggregate": "my_collection",
+ "pipeline": [{"$match": {}}, {"$group": {"_id": 1, "n": {"$sum": 1}}}],
+ "cursor": "%s",
+ },
+ },
+ {
+ "command": {
+ "aggregate": "my_collection",
+ "pipeline": [
+ {"$match": {"email": "x@somewhere.io"}},
+ {"$group": {"_id": 1, "n": {"$sum": 1}}},
+ ],
+ "cursor": {},
+ },
+ "command_stripped": {
+ "aggregate": "my_collection",
+ "pipeline": [
+ {"$match": {"email": "%s"}},
+ {"$group": {"_id": 1, "n": {"$sum": 1}}},
+ ],
+ "cursor": "%s",
+ },
+ },
+ {
+ "command": {
+ "createIndexes": "my_collection",
+ "indexes": [{"name": "username_1", "key": [("username", 1)]}],
+ },
+ "command_stripped": {
+ "createIndexes": "my_collection",
+ "indexes": [{"name": "username_1", "key": [("username", 1)]}],
+ },
+ },
+ {
+ "command": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": [
+ ("q", {"email": "anton@somewhere.io"}),
+ (
+ "u",
+ {
+ "email": "anton2@somwehre.io",
+ "extra_field": "extra_content",
+ "new": "bla",
+ },
+ ),
+ ("multi", False),
+ ("upsert", False),
+ ],
+ },
+ "command_stripped": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": "%s",
+ },
+ },
+ {
+ "command": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": [
+ ("q", {"email": "anton2@somwehre.io"}),
+ ("u", {"$rename": {"new": "new_field"}}),
+ ("multi", False),
+ ("upsert", False),
+ ],
+ },
+ "command_stripped": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": "%s",
+ },
+ },
+ {
+ "command": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": [
+ ("q", {"email": "x@somewhere.io"}),
+ ("u", {"$rename": {"password": "pwd"}}),
+ ("multi", True),
+ ("upsert", False),
+ ],
+ },
+ "command_stripped": {
+ "update": "my_collection",
+ "ordered": True,
+ "updates": "%s",
+ },
+ },
+ {
+ "command": {
+ "delete": "my_collection",
+ "ordered": True,
+ "deletes": [("q", {"username": "userx2"}), ("limit", 1)],
+ },
+ "command_stripped": {
+ "delete": "my_collection",
+ "ordered": True,
+ "deletes": "%s",
+ },
+ },
+ {
+ "command": {
+ "delete": "my_collection",
+ "ordered": True,
+ "deletes": [("q", {"email": "xplus@somewhere.io"}), ("limit", 0)],
+ },
+ "command_stripped": {
+ "delete": "my_collection",
+ "ordered": True,
+ "deletes": "%s",
+ },
+ },
+ {
+ "command": {
+ "findAndModify": "my_collection",
+ "query": {"email": "ada@lovelace.com"},
+ "new": False,
+ "remove": True,
+ },
+ "command_stripped": {
+ "findAndModify": "my_collection",
+ "query": {"email": "%s"},
+ "new": "%s",
+ "remove": "%s",
+ },
+ },
+ {
+ "command": {
+ "findAndModify": "my_collection",
+ "query": {"email": "anton2@somewhere.io"},
+ "new": False,
+ "update": {"email": "anton3@somwehre.io", "extra_field": "xxx"},
+ "upsert": False,
+ },
+ "command_stripped": {
+ "findAndModify": "my_collection",
+ "query": {"email": "%s"},
+ "new": "%s",
+ "update": {"email": "%s", "extra_field": "%s"},
+ "upsert": "%s",
+ },
+ },
+ {
+ "command": {
+ "findAndModify": "my_collection",
+ "query": {"email": "anton3@somewhere.io"},
+ "new": False,
+ "update": {"$rename": {"extra_field": "extra_field2"}},
+ "upsert": False,
+ },
+ "command_stripped": {
+ "findAndModify": "my_collection",
+ "query": {"email": "%s"},
+ "new": "%s",
+ "update": {"$rename": "%s"},
+ "upsert": "%s",
+ },
+ },
+ {
+ "command": {
+ "renameCollection": "test.my_collection",
+ "to": "test.new_collection",
+ },
+ "command_stripped": {
+ "renameCollection": "test.my_collection",
+ "to": "test.new_collection",
+ },
+ },
+ {
+ "command": {"drop": "new_collection"},
+ "command_stripped": {"drop": "new_collection"},
+ },
+ ],
+)
+def test_strip_pii(testcase):
+ assert _strip_pii(testcase["command"]) == testcase["command_stripped"]
diff --git a/tests/integrations/pyramid/test_pyramid.py b/tests/integrations/pyramid/test_pyramid.py
index 9c6fd51222..dc1567e3eb 100644
--- a/tests/integrations/pyramid/test_pyramid.py
+++ b/tests/integrations/pyramid/test_pyramid.py
@@ -1,8 +1,6 @@
import json
import logging
-import pkg_resources
import pytest
-
from io import BytesIO
import pyramid.testing
@@ -12,13 +10,23 @@
from sentry_sdk import capture_message, add_breadcrumb
from sentry_sdk.integrations.pyramid import PyramidIntegration
+from sentry_sdk.serializer import MAX_DATABAG_BREADTH
from werkzeug.test import Client
-PYRAMID_VERSION = tuple(
- map(int, pkg_resources.get_distribution("pyramid").version.split("."))
-)
+try:
+ from importlib.metadata import version
+
+ PYRAMID_VERSION = tuple(map(int, version("pyramid").split(".")))
+
+except ImportError:
+ # < py3.8
+ import pkg_resources
+
+ PYRAMID_VERSION = tuple(
+ map(int, pkg_resources.get_distribution("pyramid").version.split("."))
+ )
def hi(request):
@@ -26,12 +34,19 @@ def hi(request):
return Response("hi")
+def hi_with_id(request):
+ capture_message("hi with id")
+ return Response("hi with id")
+
+
@pytest.fixture
def pyramid_config():
config = pyramid.testing.setUp()
try:
config.add_route("hi", "/message")
config.add_view(hi, route_name="hi")
+ config.add_route("hi_with_id", "/message/{message_id}")
+ config.add_view(hi_with_id, route_name="hi_with_id")
yield config
finally:
pyramid.testing.tearDown()
@@ -82,20 +97,23 @@ def errors(request):
(event,) = events
(breadcrumb,) = event["breadcrumbs"]["values"]
assert breadcrumb["message"] == "hi2"
- assert event["exception"]["values"][0]["mechanism"]["type"] == "pyramid"
+ # Checking only the last value in the exceptions list,
+ # because Pyramid >= 1.9 returns a chained exception and before just a single exception
+ assert event["exception"]["values"][-1]["mechanism"]["type"] == "pyramid"
+ assert event["exception"]["values"][-1]["type"] == "ZeroDivisionError"
def test_has_context(route, get_client, sentry_init, capture_events):
sentry_init(integrations=[PyramidIntegration()])
events = capture_events()
- @route("/message/{msg}")
+ @route("/context_message/{msg}")
def hi2(request):
capture_message(request.matchdict["msg"])
return Response("hi")
client = get_client()
- client.get("/message/yoo")
+ client.get("/context_message/yoo")
(event,) = events
assert event["message"] == "yoo"
@@ -104,26 +122,38 @@ def hi2(request):
"headers": {"Host": "localhost"},
"method": "GET",
"query_string": "",
- "url": "http://localhost/message/yoo",
+ "url": "http://localhost/context_message/yoo",
}
assert event["transaction"] == "hi2"
@pytest.mark.parametrize(
- "transaction_style,expected_transaction",
- [("route_name", "hi"), ("route_pattern", "/message")],
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ ("/message", "route_name", "hi", "component"),
+ ("/message", "route_pattern", "/message", "route"),
+ ("/message/123456", "route_name", "hi_with_id", "component"),
+ ("/message/123456", "route_pattern", "/message/{message_id}", "route"),
+ ],
)
def test_transaction_style(
- sentry_init, get_client, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ get_client,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
):
sentry_init(integrations=[PyramidIntegration(transaction_style=transaction_style)])
events = capture_events()
client = get_client()
- client.get("/message")
+ client.get(url)
(event,) = events
assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
def test_large_json_request(sentry_init, capture_events, route, get_client):
@@ -146,9 +176,9 @@ def index(request):
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]["bar"]) == 512
+ assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
@@ -173,6 +203,31 @@ def index(request):
assert event["request"]["data"] == data
+def test_json_not_truncated_if_request_bodies_is_always(
+ sentry_init, capture_events, route, get_client
+):
+ sentry_init(integrations=[PyramidIntegration()], request_bodies="always")
+
+ data = {
+ "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
+ }
+
+ @route("/")
+ def index(request):
+ assert request.json == data
+ assert request.text == json.dumps(data)
+ capture_message("hi")
+ return Response("ok")
+
+ events = capture_events()
+
+ client = get_client()
+ client.post("/", content_type="application/json", data=json.dumps(data))
+
+ (event,) = events
+ assert event["request"]["data"] == data
+
+
def test_files_and_form(sentry_init, capture_events, route, get_client):
sentry_init(integrations=[PyramidIntegration()], request_bodies="always")
@@ -190,13 +245,11 @@ def index(request):
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
- "": {"len": 2000, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
- assert len(event["request"]["data"]["foo"]) == 512
+ assert len(event["request"]["data"]["foo"]) == 1024
- assert event["_meta"]["request"]["data"]["file"] == {
- "": {"len": 0, "rem": [["!raw", "x", 0, 0]]}
- }
+ assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}}
assert not event["request"]["data"]["file"]
diff --git a/tests/integrations/quart/test_quart.py b/tests/integrations/quart/test_quart.py
index d827b3c4aa..bda2c1013e 100644
--- a/tests/integrations/quart/test_quart.py
+++ b/tests/integrations/quart/test_quart.py
@@ -1,4 +1,8 @@
+import json
+import threading
+
import pytest
+import pytest_asyncio
quart = pytest.importorskip("quart")
@@ -21,7 +25,7 @@
auth_manager = AuthManager()
-@pytest.fixture
+@pytest_asyncio.fixture
async def app():
app = Quart(__name__)
app.debug = True
@@ -35,6 +39,25 @@ async def hi():
capture_message("hi")
return "ok"
+ @app.route("/message/")
+ async def hi_with_id(message_id):
+ capture_message("hi with id")
+ return "ok with id"
+
+ @app.get("/sync/thread_ids")
+ def _thread_ids_sync():
+ return {
+ "main": str(threading.main_thread().ident),
+ "active": str(threading.current_thread().ident),
+ }
+
+ @app.get("/async/thread_ids")
+ async def _thread_ids_async():
+ return {
+ "main": str(threading.main_thread().ident),
+ "active": str(threading.current_thread().ident),
+ }
+
return app
@@ -63,10 +86,22 @@ async def test_has_context(sentry_init, app, capture_events):
@pytest.mark.asyncio
@pytest.mark.parametrize(
- "transaction_style,expected_transaction", [("endpoint", "hi"), ("url", "/message")]
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ ("/message", "endpoint", "hi", "component"),
+ ("/message", "url", "/message", "route"),
+ ("/message/123456", "endpoint", "hi_with_id", "component"),
+ ("/message/123456", "url", "/message/", "route"),
+ ],
)
async def test_transaction_style(
- sentry_init, app, capture_events, transaction_style, expected_transaction
+ sentry_init,
+ app,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
):
sentry_init(
integrations=[
@@ -76,7 +111,7 @@ async def test_transaction_style(
events = capture_events()
client = app.test_client()
- response = await client.get("/message")
+ response = await client.get(url)
assert response.status_code == 200
(event,) = events
@@ -505,3 +540,30 @@ async def dispatch_request(self):
assert event["message"] == "hi"
assert event["transaction"] == "hello_class"
+
+
+@pytest.mark.parametrize("endpoint", ["/sync/thread_ids", "/async/thread_ids"])
+async def test_active_thread_id(sentry_init, capture_envelopes, endpoint, app):
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+
+ envelopes = capture_envelopes()
+
+ async with app.test_client() as client:
+ response = await client.get(endpoint)
+ assert response.status_code == 200
+
+ data = json.loads(response.content)
+
+ envelopes = [envelope for envelope in envelopes]
+ assert len(envelopes) == 1
+
+ profiles = [item for item in envelopes[0].items if item.type == "profile"]
+ assert len(profiles) == 1
+
+ for profile in profiles:
+ transactions = profile.payload.json["transactions"]
+ assert len(transactions) == 1
+ assert str(data["active"]) == transactions[0]["active_thread_id"]
diff --git a/tests/integrations/redis/test_redis.py b/tests/integrations/redis/test_redis.py
index 3708995068..37a886c224 100644
--- a/tests/integrations/redis/test_redis.py
+++ b/tests/integrations/redis/test_redis.py
@@ -1,7 +1,14 @@
-from sentry_sdk import capture_message
+from sentry_sdk import capture_message, start_transaction
+from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.redis import RedisIntegration
from fakeredis import FakeStrictRedis
+import pytest
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
def test_basic(sentry_init, capture_events):
@@ -19,7 +26,206 @@ def test_basic(sentry_init, capture_events):
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
- "data": {"redis.key": "foobar", "redis.command": "GET"},
+ "data": {
+ "redis.key": "foobar",
+ "redis.command": "GET",
+ "redis.is_cluster": False,
+ "db.operation": "GET",
+ },
"timestamp": crumb["timestamp"],
"type": "redis",
}
+
+
+@pytest.mark.parametrize("is_transaction", [False, True])
+def test_redis_pipeline(sentry_init, capture_events, is_transaction):
+ sentry_init(integrations=[RedisIntegration()], traces_sample_rate=1.0)
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ pipeline = connection.pipeline(transaction=is_transaction)
+ pipeline.get("foo")
+ pipeline.set("bar", 1)
+ pipeline.set("baz", 2)
+ pipeline.execute()
+
+ (event,) = events
+ (span,) = event["spans"]
+ assert span["op"] == "db.redis"
+ assert span["description"] == "redis.pipeline.execute"
+ assert span["data"] == {
+ "redis.commands": {
+ "count": 3,
+ "first_ten": ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"],
+ },
+ SPANDATA.DB_SYSTEM: "redis",
+ }
+ assert span["tags"] == {
+ "redis.transaction": is_transaction,
+ "redis.is_cluster": False,
+ }
+
+
+def test_sensitive_data(sentry_init, capture_events):
+ # fakeredis does not support the AUTH command, so we need to mock it
+ with mock.patch(
+ "sentry_sdk.integrations.redis._COMMANDS_INCLUDING_SENSITIVE_DATA", ["get"]
+ ):
+ sentry_init(
+ integrations=[RedisIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ connection.get(
+ "this is super secret"
+ ) # because fakeredis does not support AUTH we use GET instead
+
+ (event,) = events
+ spans = event["spans"]
+ assert spans[0]["op"] == "db.redis"
+ assert spans[0]["description"] == "GET [Filtered]"
+
+
+def test_pii_data_redacted(sentry_init, capture_events):
+ sentry_init(
+ integrations=[RedisIntegration()],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ connection.set("somekey1", "my secret string1")
+ connection.set("somekey2", "my secret string2")
+ connection.get("somekey2")
+ connection.delete("somekey1", "somekey2")
+
+ (event,) = events
+ spans = event["spans"]
+ assert spans[0]["op"] == "db.redis"
+ assert spans[0]["description"] == "SET 'somekey1' [Filtered]"
+ assert spans[1]["description"] == "SET 'somekey2' [Filtered]"
+ assert spans[2]["description"] == "GET 'somekey2'"
+ assert spans[3]["description"] == "DEL 'somekey1' [Filtered]"
+
+
+def test_pii_data_sent(sentry_init, capture_events):
+ sentry_init(
+ integrations=[RedisIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ connection.set("somekey1", "my secret string1")
+ connection.set("somekey2", "my secret string2")
+ connection.get("somekey2")
+ connection.delete("somekey1", "somekey2")
+
+ (event,) = events
+ spans = event["spans"]
+ assert spans[0]["op"] == "db.redis"
+ assert spans[0]["description"] == "SET 'somekey1' 'my secret string1'"
+ assert spans[1]["description"] == "SET 'somekey2' 'my secret string2'"
+ assert spans[2]["description"] == "GET 'somekey2'"
+ assert spans[3]["description"] == "DEL 'somekey1' 'somekey2'"
+
+
+def test_data_truncation(sentry_init, capture_events):
+ sentry_init(
+ integrations=[RedisIntegration()],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ long_string = "a" * 100000
+ connection.set("somekey1", long_string)
+ short_string = "b" * 10
+ connection.set("somekey2", short_string)
+
+ (event,) = events
+ spans = event["spans"]
+ assert spans[0]["op"] == "db.redis"
+ assert spans[0]["description"] == "SET 'somekey1' '%s..." % (
+ long_string[: 1024 - len("...") - len("SET 'somekey1' '")],
+ )
+ assert spans[1]["description"] == "SET 'somekey2' '%s'" % (short_string,)
+
+
+def test_data_truncation_custom(sentry_init, capture_events):
+ sentry_init(
+ integrations=[RedisIntegration(max_data_size=30)],
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+ with start_transaction():
+ long_string = "a" * 100000
+ connection.set("somekey1", long_string)
+ short_string = "b" * 10
+ connection.set("somekey2", short_string)
+
+ (event,) = events
+ spans = event["spans"]
+ assert spans[0]["op"] == "db.redis"
+ assert spans[0]["description"] == "SET 'somekey1' '%s..." % (
+ long_string[: 30 - len("...") - len("SET 'somekey1' '")],
+ )
+ assert spans[1]["description"] == "SET 'somekey2' '%s'" % (short_string,)
+
+
+def test_breadcrumbs(sentry_init, capture_events):
+ sentry_init(
+ integrations=[RedisIntegration(max_data_size=30)],
+ send_default_pii=True,
+ )
+ events = capture_events()
+
+ connection = FakeStrictRedis()
+
+ long_string = "a" * 100000
+ connection.set("somekey1", long_string)
+ short_string = "b" * 10
+ connection.set("somekey2", short_string)
+
+ capture_message("hi")
+
+ (event,) = events
+ crumbs = event["breadcrumbs"]["values"]
+
+ assert crumbs[0] == {
+ "message": "SET 'somekey1' 'aaaaaaaaaaa...",
+ "type": "redis",
+ "category": "redis",
+ "data": {
+ "db.operation": "SET",
+ "redis.is_cluster": False,
+ "redis.command": "SET",
+ "redis.key": "somekey1",
+ },
+ "timestamp": crumbs[0]["timestamp"],
+ }
+ assert crumbs[1] == {
+ "message": "SET 'somekey2' 'bbbbbbbbbb'",
+ "type": "redis",
+ "category": "redis",
+ "data": {
+ "db.operation": "SET",
+ "redis.is_cluster": False,
+ "redis.command": "SET",
+ "redis.key": "somekey2",
+ },
+ "timestamp": crumbs[1]["timestamp"],
+ }
diff --git a/tests/integrations/rediscluster/test_rediscluster.py b/tests/integrations/rediscluster/test_rediscluster.py
index 425ff13b2f..c4b5a8e7d3 100644
--- a/tests/integrations/rediscluster/test_rediscluster.py
+++ b/tests/integrations/rediscluster/test_rediscluster.py
@@ -1,5 +1,7 @@
import pytest
from sentry_sdk import capture_message
+from sentry_sdk.consts import SPANDATA
+from sentry_sdk.api import start_transaction
from sentry_sdk.integrations.redis import RedisIntegration
import rediscluster
@@ -10,8 +12,16 @@
rediscluster_classes.append(rediscluster.StrictRedisCluster)
-@pytest.fixture(scope="module", autouse=True)
-def monkeypatch_rediscluster_classes():
+@pytest.fixture(autouse=True)
+def monkeypatch_rediscluster_classes(reset_integrations):
+ try:
+ pipeline_cls = rediscluster.pipeline.ClusterPipeline
+ except AttributeError:
+ pipeline_cls = rediscluster.StrictClusterPipeline
+ rediscluster.RedisCluster.pipeline = lambda *_, **__: pipeline_cls(
+ connection_pool=True
+ )
+ pipeline_cls.execute = lambda *_, **__: None
for cls in rediscluster_classes:
cls.execute_command = lambda *_, **__: None
@@ -31,7 +41,41 @@ def test_rediscluster_basic(rediscluster_cls, sentry_init, capture_events):
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
- "data": {"redis.key": "foobar", "redis.command": "GET"},
+ "data": {
+ "db.operation": "GET",
+ "redis.key": "foobar",
+ "redis.command": "GET",
+ "redis.is_cluster": True,
+ },
"timestamp": crumb["timestamp"],
"type": "redis",
}
+
+
+def test_rediscluster_pipeline(sentry_init, capture_events):
+ sentry_init(integrations=[RedisIntegration()], traces_sample_rate=1.0)
+ events = capture_events()
+
+ rc = rediscluster.RedisCluster(connection_pool=True)
+ with start_transaction():
+ pipeline = rc.pipeline()
+ pipeline.get("foo")
+ pipeline.set("bar", 1)
+ pipeline.set("baz", 2)
+ pipeline.execute()
+
+ (event,) = events
+ (span,) = event["spans"]
+ assert span["op"] == "db.redis"
+ assert span["description"] == "redis.pipeline.execute"
+ assert span["data"] == {
+ "redis.commands": {
+ "count": 3,
+ "first_ten": ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"],
+ },
+ SPANDATA.DB_SYSTEM: "redis",
+ }
+ assert span["tags"] == {
+ "redis.transaction": False, # For Cluster, this is always False
+ "redis.is_cluster": True,
+ }
diff --git a/tests/integrations/requests/test_requests.py b/tests/integrations/requests/test_requests.py
index 02c6636853..aecf64762d 100644
--- a/tests/integrations/requests/test_requests.py
+++ b/tests/integrations/requests/test_requests.py
@@ -1,16 +1,27 @@
import pytest
+import responses
requests = pytest.importorskip("requests")
from sentry_sdk import capture_message
+from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.stdlib import StdlibIntegration
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
def test_crumb_capture(sentry_init, capture_events):
sentry_init(integrations=[StdlibIntegration()])
+
+ url = "http://example.com/"
+ responses.add(responses.GET, url, status=200)
+
events = capture_events()
- response = requests.get("https://httpbin.org/status/418")
+ response = requests.get(url)
capture_message("Testing!")
(event,) = events
@@ -18,8 +29,36 @@ def test_crumb_capture(sentry_init, capture_events):
assert crumb["type"] == "http"
assert crumb["category"] == "httplib"
assert crumb["data"] == {
- "url": "https://httpbin.org/status/418",
- "method": "GET",
- "status_code": response.status_code,
+ "url": url,
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_FRAGMENT: "",
+ SPANDATA.HTTP_QUERY: "",
+ SPANDATA.HTTP_STATUS_CODE: response.status_code,
+ "reason": response.reason,
+ }
+
+
+@pytest.mark.tests_internal_exceptions
+def test_omit_url_data_if_parsing_fails(sentry_init, capture_events):
+ sentry_init(integrations=[StdlibIntegration()])
+
+ url = "https://example.com"
+ responses.add(responses.GET, url, status=200)
+
+ events = capture_events()
+
+ with mock.patch(
+ "sentry_sdk.integrations.stdlib.parse_url",
+ side_effect=ValueError,
+ ):
+ response = requests.get(url)
+
+ capture_message("Testing!")
+
+ (event,) = events
+ assert event["breadcrumbs"]["values"][0]["data"] == {
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_STATUS_CODE: response.status_code,
"reason": response.reason,
+ # no url related data
}
diff --git a/tests/integrations/rq/test_rq.py b/tests/integrations/rq/test_rq.py
index 651bf22248..270a92e295 100644
--- a/tests/integrations/rq/test_rq.py
+++ b/tests/integrations/rq/test_rq.py
@@ -1,5 +1,6 @@
import pytest
from fakeredis import FakeStrictRedis
+from sentry_sdk import configure_scope, start_transaction
from sentry_sdk.integrations.rq import RqIntegration
import rq
@@ -58,13 +59,18 @@ def test_basic(sentry_init, capture_events):
assert exception["stacktrace"]["frames"][-1]["vars"]["foo"] == "42"
assert event["transaction"] == "tests.integrations.rq.test_rq.crashing_job"
- assert event["extra"]["rq-job"] == {
- "args": [],
- "description": "tests.integrations.rq.test_rq.crashing_job(foo=42)",
- "func": "tests.integrations.rq.test_rq.crashing_job",
- "job_id": event["extra"]["rq-job"]["job_id"],
- "kwargs": {"foo": 42},
- }
+
+ extra = event["extra"]["rq-job"]
+ assert extra["args"] == []
+ assert extra["kwargs"] == {"foo": 42}
+ assert extra["description"] == "tests.integrations.rq.test_rq.crashing_job(foo=42)"
+ assert extra["func"] == "tests.integrations.rq.test_rq.crashing_job"
+ assert "job_id" in extra
+ assert "enqueued_at" in extra
+
+ # older versions don't persist started_at correctly
+ if tuple(map(int, rq.VERSION.split("."))) >= (0, 9):
+ assert "started_at" in extra
def test_transport_shutdown(sentry_init, capture_events_forksafe):
@@ -88,7 +94,6 @@ def test_transport_shutdown(sentry_init, capture_events_forksafe):
def test_transaction_with_error(
sentry_init, capture_events, DictionaryContaining # noqa:N803
):
-
sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
events = capture_events()
@@ -101,7 +106,7 @@ def test_transaction_with_error(
error_event, envelope = events
assert error_event["transaction"] == "tests.integrations.rq.test_rq.chew_up_shoes"
- assert error_event["contexts"]["trace"]["op"] == "rq.task"
+ assert error_event["contexts"]["trace"]["op"] == "queue.task.rq"
assert error_event["exception"]["values"][0]["type"] == "Exception"
assert (
error_event["exception"]["values"][0]["value"]
@@ -121,6 +126,71 @@ def test_transaction_with_error(
)
+def test_error_has_trace_context_if_tracing_disabled(
+ sentry_init,
+ capture_events,
+):
+ sentry_init(integrations=[RqIntegration()])
+ events = capture_events()
+
+ queue = rq.Queue(connection=FakeStrictRedis())
+ worker = rq.SimpleWorker([queue], connection=queue.connection)
+
+ queue.enqueue(crashing_job, foo=None)
+ worker.work(burst=True)
+
+ (error_event,) = events
+
+ assert error_event["contexts"]["trace"]
+
+
+def test_tracing_enabled(
+ sentry_init,
+ capture_events,
+):
+ sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
+ events = capture_events()
+
+ queue = rq.Queue(connection=FakeStrictRedis())
+ worker = rq.SimpleWorker([queue], connection=queue.connection)
+
+ with start_transaction(op="rq transaction") as transaction:
+ queue.enqueue(crashing_job, foo=None)
+ worker.work(burst=True)
+
+ error_event, envelope, _ = events
+
+ assert error_event["transaction"] == "tests.integrations.rq.test_rq.crashing_job"
+ assert error_event["contexts"]["trace"]["trace_id"] == transaction.trace_id
+
+ assert envelope["contexts"]["trace"] == error_event["contexts"]["trace"]
+
+
+def test_tracing_disabled(
+ sentry_init,
+ capture_events,
+):
+ sentry_init(integrations=[RqIntegration()])
+ events = capture_events()
+
+ queue = rq.Queue(connection=FakeStrictRedis())
+ worker = rq.SimpleWorker([queue], connection=queue.connection)
+
+ with configure_scope() as scope:
+ queue.enqueue(crashing_job, foo=None)
+ worker.work(burst=True)
+
+ (error_event,) = events
+
+ assert (
+ error_event["transaction"] == "tests.integrations.rq.test_rq.crashing_job"
+ )
+ assert (
+ error_event["contexts"]["trace"]["trace_id"]
+ == scope._propagation_context["trace_id"]
+ )
+
+
def test_transaction_no_error(
sentry_init, capture_events, DictionaryContaining # noqa:N803
):
@@ -136,7 +206,7 @@ def test_transaction_no_error(
envelope = events[0]
assert envelope["type"] == "transaction"
- assert envelope["contexts"]["trace"]["op"] == "rq.task"
+ assert envelope["contexts"]["trace"]["op"] == "queue.task.rq"
assert envelope["transaction"] == "tests.integrations.rq.test_rq.do_trick"
assert envelope["extra"]["rq-job"] == DictionaryContaining(
{
diff --git a/tests/integrations/sanic/test_sanic.py b/tests/integrations/sanic/test_sanic.py
index b91f94bfe9..de84845cf4 100644
--- a/tests/integrations/sanic/test_sanic.py
+++ b/tests/integrations/sanic/test_sanic.py
@@ -1,5 +1,5 @@
+import os
import sys
-
import random
import asyncio
from unittest.mock import Mock
@@ -18,8 +18,22 @@
@pytest.fixture
def app():
- if SANIC_VERSION >= (20, 12):
- # Build (20.12.0) adds a feature where the instance is stored in an internal class
+ if SANIC_VERSION < (19,):
+ """
+ Older Sanic versions 0.8 and 18 bind to the same fixed port which
+ creates problems when we run tests concurrently.
+ """
+ old_test_client = Sanic.test_client.__get__
+
+ def new_test_client(self):
+ client = old_test_client(self, Sanic)
+ client.port += os.getpid() % 100
+ return client
+
+ Sanic.test_client = property(new_test_client)
+
+ if SANIC_VERSION >= (20, 12) and SANIC_VERSION < (22, 6):
+ # Some builds (20.12.0 intruduced and 22.6.0 removed again) have a feature where the instance is stored in an internal class
# registry for later retrieval, and so add register=False to disable that
app = Sanic("Test", register=False)
else:
@@ -30,6 +44,11 @@ def hi(request):
capture_message("hi")
return response.text("ok")
+ @app.route("/message/")
+ def hi_with_id(request, message_id):
+ capture_message("hi with id")
+ return response.text("ok with id")
+
return app
@@ -62,6 +81,27 @@ def test_request_data(sentry_init, app, capture_events):
assert "transaction" not in event
+@pytest.mark.parametrize(
+ "url,expected_transaction,expected_source",
+ [
+ ("/message", "hi", "component"),
+ ("/message/123456", "hi_with_id", "component"),
+ ],
+)
+def test_transaction(
+ sentry_init, app, capture_events, url, expected_transaction, expected_source
+):
+ sentry_init(integrations=[SanicIntegration()])
+ events = capture_events()
+
+ request, response = app.test_client.get(url)
+ assert response.status == 200
+
+ (event,) = events
+ assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
+
+
def test_errors(sentry_init, app, capture_events):
sentry_init(integrations=[SanicIntegration()])
events = capture_events()
@@ -189,7 +229,6 @@ def __init__(self, request_body):
def respond(self, response):
responses.append(response)
patched_response = HTTPResponse()
- patched_response.send = lambda end_stream: asyncio.sleep(0.001)
return patched_response
def __aiter__(self):
diff --git a/tests/integrations/socket/__init__.py b/tests/integrations/socket/__init__.py
new file mode 100644
index 0000000000..893069b21b
--- /dev/null
+++ b/tests/integrations/socket/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("socket")
diff --git a/tests/integrations/socket/test_socket.py b/tests/integrations/socket/test_socket.py
new file mode 100644
index 0000000000..914ba0bf84
--- /dev/null
+++ b/tests/integrations/socket/test_socket.py
@@ -0,0 +1,51 @@
+import socket
+
+from sentry_sdk import start_transaction
+from sentry_sdk.integrations.socket import SocketIntegration
+
+
+def test_getaddrinfo_trace(sentry_init, capture_events):
+ sentry_init(integrations=[SocketIntegration()], traces_sample_rate=1.0)
+ events = capture_events()
+
+ with start_transaction():
+ socket.getaddrinfo("example.com", 443)
+
+ (event,) = events
+ (span,) = event["spans"]
+
+ assert span["op"] == "socket.dns"
+ assert span["description"] == "example.com:443"
+ assert span["data"] == {
+ "host": "example.com",
+ "port": 443,
+ }
+
+
+def test_create_connection_trace(sentry_init, capture_events):
+ timeout = 10
+
+ sentry_init(integrations=[SocketIntegration()], traces_sample_rate=1.0)
+ events = capture_events()
+
+ with start_transaction():
+ socket.create_connection(("example.com", 443), timeout, None)
+
+ (event,) = events
+ (connect_span, dns_span) = event["spans"]
+ # as getaddrinfo gets called in create_connection it should also contain a dns span
+
+ assert connect_span["op"] == "socket.connection"
+ assert connect_span["description"] == "example.com:443"
+ assert connect_span["data"] == {
+ "address": ["example.com", 443],
+ "timeout": timeout,
+ "source_address": None,
+ }
+
+ assert dns_span["op"] == "socket.dns"
+ assert dns_span["description"] == "example.com:443"
+ assert dns_span["data"] == {
+ "host": "example.com",
+ "port": 443,
+ }
diff --git a/tests/integrations/sqlalchemy/test_sqlalchemy.py b/tests/integrations/sqlalchemy/test_sqlalchemy.py
index 421a72ebae..064af3c4f1 100644
--- a/tests/integrations/sqlalchemy/test_sqlalchemy.py
+++ b/tests/integrations/sqlalchemy/test_sqlalchemy.py
@@ -7,9 +7,10 @@
from sqlalchemy.orm import relationship, sessionmaker
from sentry_sdk import capture_message, start_transaction, configure_scope
+from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
-from sentry_sdk.utils import json_dumps, MAX_STRING_LENGTH
from sentry_sdk.serializer import MAX_EVENT_BYTES
+from sentry_sdk.utils import json_dumps, MAX_STRING_LENGTH
def test_orm_queries(sentry_init, capture_events):
@@ -74,7 +75,6 @@ class Address(Base):
sys.version_info < (3,), reason="This sqla usage seems to be broken on Py2"
)
def test_transactions(sentry_init, capture_events, render_span_tree):
-
sentry_init(
integrations=[SqlalchemyIntegration()],
_experiments={"record_sql_params": True},
@@ -119,6 +119,9 @@ class Address(Base):
(event,) = events
+ for span in event["spans"]:
+ assert span["data"][SPANDATA.DB_SYSTEM] == "sqlite"
+
assert (
render_span_tree(event)
== """\
@@ -143,7 +146,6 @@ def test_long_sql_query_preserved(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1,
integrations=[SqlalchemyIntegration()],
- _experiments={"smart_transaction_trimming": True},
)
events = capture_events()
@@ -158,11 +160,10 @@ def test_long_sql_query_preserved(sentry_init, capture_events):
assert description.endswith("SELECT 98 UNION SELECT 99")
-def test_too_large_event_truncated(sentry_init, capture_events):
+def test_large_event_not_truncated(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1,
integrations=[SqlalchemyIntegration()],
- _experiments={"smart_transaction_trimming": True},
)
events = capture_events()
@@ -178,49 +179,43 @@ def processor(event, hint):
engine = create_engine("sqlite:///:memory:")
with start_transaction(name="test"):
with engine.connect() as con:
- for _ in range(2000):
+ for _ in range(1500):
con.execute(" UNION ".join("SELECT {}".format(i) for i in range(100)))
(event,) = events
- # Because of attached metadata in the "_meta" key, we may send out a little
- # bit more than MAX_EVENT_BYTES.
- max_bytes = 1.2 * MAX_EVENT_BYTES
- assert len(json_dumps(event)) < max_bytes
+ assert len(json_dumps(event)) > MAX_EVENT_BYTES
# Some spans are discarded.
assert len(event["spans"]) == 1000
- # Some spans have their descriptions truncated. Because the test always
- # generates the same amount of descriptions and truncation is deterministic,
- # the number here should never change across test runs.
- #
- # Which exact span descriptions are truncated depends on the span durations
- # of each SQL query and is non-deterministic.
- assert len(event["_meta"]["spans"]) == 537
-
- for i, span in enumerate(event["spans"]):
- description = span["description"]
-
- assert description.startswith("SELECT ")
- if str(i) in event["_meta"]["spans"]:
- # Description must have been truncated
- assert len(description) == 10
- assert description.endswith("...")
- else:
- # Description was not truncated, check for original length
- assert len(description) == 1583
- assert description.endswith("SELECT 98 UNION SELECT 99")
-
- # Smoke check the meta info for one of the spans.
- assert next(iter(event["_meta"]["spans"].values())) == {
- "description": {"": {"len": 1583, "rem": [["!limit", "x", 7, 10]]}}
- }
+ # Span descriptions are not truncated.
+ description = event["spans"][0]["description"]
+ assert len(description) == 1583
+ assert description.startswith("SELECT 0")
+ assert description.endswith("SELECT 98 UNION SELECT 99")
+
+ description = event["spans"][999]["description"]
+ assert len(description) == 1583
+ assert description.startswith("SELECT 0")
+ assert description.endswith("SELECT 98 UNION SELECT 99")
# Smoke check that truncation of other fields has not changed.
assert len(event["message"]) == MAX_STRING_LENGTH
# The _meta for other truncated fields should be there as well.
assert event["_meta"]["message"] == {
- "": {"len": 522, "rem": [["!limit", "x", 509, 512]]}
+ "": {"len": 1034, "rem": [["!limit", "x", 1021, 1024]]}
}
+
+
+def test_engine_name_not_string(sentry_init):
+ sentry_init(
+ integrations=[SqlalchemyIntegration()],
+ )
+
+ engine = create_engine("sqlite:///:memory:")
+ engine.dialect.name = b"sqlite"
+
+ with engine.connect() as con:
+ con.execute("SELECT 0")
diff --git a/tests/integrations/starlette/__init__.py b/tests/integrations/starlette/__init__.py
new file mode 100644
index 0000000000..c89ddf99a8
--- /dev/null
+++ b/tests/integrations/starlette/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("starlette")
diff --git a/tests/integrations/starlette/photo.jpg b/tests/integrations/starlette/photo.jpg
new file mode 100644
index 0000000000..52fbeef721
Binary files /dev/null and b/tests/integrations/starlette/photo.jpg differ
diff --git a/tests/integrations/starlette/test_starlette.py b/tests/integrations/starlette/test_starlette.py
new file mode 100644
index 0000000000..77ff368e47
--- /dev/null
+++ b/tests/integrations/starlette/test_starlette.py
@@ -0,0 +1,905 @@
+import asyncio
+import base64
+import functools
+import json
+import logging
+import os
+import threading
+
+import pytest
+
+from sentry_sdk import last_event_id, capture_exception
+from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+from sentry_sdk import capture_message
+from sentry_sdk.integrations.starlette import (
+ StarletteIntegration,
+ StarletteRequestExtractor,
+)
+
+starlette = pytest.importorskip("starlette")
+from starlette.authentication import (
+ AuthCredentials,
+ AuthenticationBackend,
+ AuthenticationError,
+ SimpleUser,
+)
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.testclient import TestClient
+
+STARLETTE_VERSION = tuple([int(x) for x in starlette.__version__.split(".")])
+
+PICTURE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "photo.jpg")
+
+BODY_JSON = {"some": "json", "for": "testing", "nested": {"numbers": 123}}
+
+BODY_FORM = """--fd721ef49ea403a6\r\nContent-Disposition: form-data; name="username"\r\n\r\nJane\r\n--fd721ef49ea403a6\r\nContent-Disposition: form-data; name="password"\r\n\r\nhello123\r\n--fd721ef49ea403a6\r\nContent-Disposition: form-data; name="photo"; filename="photo.jpg"\r\nContent-Type: image/jpg\r\nContent-Transfer-Encoding: base64\r\n\r\n{{image_data}}\r\n--fd721ef49ea403a6--\r\n""".replace(
+ "{{image_data}}", str(base64.b64encode(open(PICTURE, "rb").read()))
+)
+
+FORM_RECEIVE_MESSAGES = [
+ {"type": "http.request", "body": BODY_FORM.encode("utf-8")},
+ {"type": "http.disconnect"},
+]
+
+JSON_RECEIVE_MESSAGES = [
+ {"type": "http.request", "body": json.dumps(BODY_JSON).encode("utf-8")},
+ {"type": "http.disconnect"},
+]
+
+PARSED_FORM = starlette.datastructures.FormData(
+ [
+ ("username", "Jane"),
+ ("password", "hello123"),
+ (
+ "photo",
+ starlette.datastructures.UploadFile(
+ filename="photo.jpg",
+ file=open(PICTURE, "rb"),
+ content_type="image/jpeg",
+ ),
+ ),
+ ]
+)
+
+# Dummy ASGI scope for creating mock Starlette requests
+SCOPE = {
+ "client": ("172.29.0.10", 34784),
+ "headers": [
+ [b"host", b"example.com"],
+ [b"user-agent", b"Mozilla/5.0 Gecko/20100101 Firefox/60.0"],
+ [b"content-type", b"application/json"],
+ [b"accept-language", b"en-US,en;q=0.5"],
+ [b"accept-encoding", b"gzip, deflate, br"],
+ [b"upgrade-insecure-requests", b"1"],
+ [b"cookie", b"yummy_cookie=choco; tasty_cookie=strawberry"],
+ ],
+ "http_version": "0.0",
+ "method": "GET",
+ "path": "/path",
+ "query_string": b"qs=hello",
+ "scheme": "http",
+ "server": ("172.28.0.10", 8000),
+ "type": "http",
+}
+
+
+async def _mock_receive(msg):
+ return msg
+
+
+def starlette_app_factory(middleware=None, debug=True):
+ async def _homepage(request):
+ 1 / 0
+ return starlette.responses.JSONResponse({"status": "ok"})
+
+ async def _custom_error(request):
+ raise Exception("Too Hot")
+
+ async def _message(request):
+ capture_message("hi")
+ return starlette.responses.JSONResponse({"status": "ok"})
+
+ async def _message_with_id(request):
+ capture_message("hi")
+ return starlette.responses.JSONResponse({"status": "ok"})
+
+ def _thread_ids_sync(request):
+ return starlette.responses.JSONResponse(
+ {
+ "main": threading.main_thread().ident,
+ "active": threading.current_thread().ident,
+ }
+ )
+
+ async def _thread_ids_async(request):
+ return starlette.responses.JSONResponse(
+ {
+ "main": threading.main_thread().ident,
+ "active": threading.current_thread().ident,
+ }
+ )
+
+ app = starlette.applications.Starlette(
+ debug=debug,
+ routes=[
+ starlette.routing.Route("/some_url", _homepage),
+ starlette.routing.Route("/custom_error", _custom_error),
+ starlette.routing.Route("/message", _message),
+ starlette.routing.Route("/message/{message_id}", _message_with_id),
+ starlette.routing.Route("/sync/thread_ids", _thread_ids_sync),
+ starlette.routing.Route("/async/thread_ids", _thread_ids_async),
+ ],
+ middleware=middleware,
+ )
+
+ return app
+
+
+def async_return(result):
+ f = asyncio.Future()
+ f.set_result(result)
+ return f
+
+
+class BasicAuthBackend(AuthenticationBackend):
+ async def authenticate(self, conn):
+ if "Authorization" not in conn.headers:
+ return
+
+ auth = conn.headers["Authorization"]
+ try:
+ scheme, credentials = auth.split()
+ if scheme.lower() != "basic":
+ return
+ decoded = base64.b64decode(credentials).decode("ascii")
+ except (ValueError, UnicodeDecodeError):
+ raise AuthenticationError("Invalid basic auth credentials")
+
+ username, _, password = decoded.partition(":")
+
+ # TODO: You'd want to verify the username and password here.
+
+ return AuthCredentials(["authenticated"]), SimpleUser(username)
+
+
+class AsyncIterator:
+ def __init__(self, data):
+ self.iter = iter(bytes(data, "utf-8"))
+
+ def __aiter__(self):
+ return self
+
+ async def __anext__(self):
+ try:
+ return bytes([next(self.iter)])
+ except StopIteration:
+ raise StopAsyncIteration
+
+
+class SampleMiddleware:
+ def __init__(self, app):
+ self.app = app
+
+ async def __call__(self, scope, receive, send):
+ # only handle http requests
+ if scope["type"] != "http":
+ await self.app(scope, receive, send)
+ return
+
+ async def do_stuff(message):
+ if message["type"] == "http.response.start":
+ # do something here.
+ pass
+
+ await send(message)
+
+ await self.app(scope, receive, do_stuff)
+
+
+class SampleReceiveSendMiddleware:
+ def __init__(self, app):
+ self.app = app
+
+ async def __call__(self, scope, receive, send):
+ message = await receive()
+ assert message
+ assert message["type"] == "http.request"
+
+ send_output = await send({"type": "something-unimportant"})
+ assert send_output is None
+
+ await self.app(scope, receive, send)
+
+
+class SamplePartialReceiveSendMiddleware:
+ def __init__(self, app):
+ self.app = app
+
+ async def __call__(self, scope, receive, send):
+ message = await receive()
+ assert message
+ assert message["type"] == "http.request"
+
+ send_output = await send({"type": "something-unimportant"})
+ assert send_output is None
+
+ async def my_receive(*args, **kwargs):
+ pass
+
+ async def my_send(*args, **kwargs):
+ pass
+
+ partial_receive = functools.partial(my_receive)
+ partial_send = functools.partial(my_send)
+
+ await self.app(scope, partial_receive, partial_send)
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_content_length(sentry_init):
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-length", str(len(json.dumps(BODY_JSON))).encode()],
+ ]
+ starlette_request = starlette.requests.Request(scope)
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ assert await extractor.content_length() == len(json.dumps(BODY_JSON))
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_cookies(sentry_init):
+ starlette_request = starlette.requests.Request(SCOPE)
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ assert extractor.cookies() == {
+ "tasty_cookie": "strawberry",
+ "yummy_cookie": "choco",
+ }
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_json(sentry_init):
+ starlette_request = starlette.requests.Request(SCOPE)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in JSON_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ assert extractor.is_json()
+ assert await extractor.json() == BODY_JSON
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_form(sentry_init):
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-type", b"multipart/form-data; boundary=fd721ef49ea403a6"],
+ ]
+ # TODO add test for content-type: "application/x-www-form-urlencoded"
+
+ starlette_request = starlette.requests.Request(scope)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in FORM_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ form_data = await extractor.form()
+ assert form_data.keys() == PARSED_FORM.keys()
+ assert form_data["username"] == PARSED_FORM["username"]
+ assert form_data["password"] == PARSED_FORM["password"]
+ assert form_data["photo"].filename == PARSED_FORM["photo"].filename
+
+ # Make sure we still can read the body
+ # after alreading it with extractor.form() above.
+ body = await extractor.request.body()
+ assert body
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_body_consumed_twice(
+ sentry_init, capture_events
+):
+ """
+ Starlette does cache when you read the request data via `request.json()`
+ or `request.body()`, but it does NOT when using `request.form()`.
+ So we have an edge case when the Sentry Starlette reads the body using `.form()`
+ and the user wants to read the body using `.body()`.
+ Because the underlying stream can not be consumed twice and is not cached.
+
+ We have fixed this in `StarletteRequestExtractor.form()` by consuming the body
+ first with `.body()` (to put it into the `_body` cache and then consume it with `.form()`.
+
+ If this behavior is changed in Starlette and the `request.form()` in Starlette
+ is also caching the body, this test will fail.
+
+ See also https://github.com/encode/starlette/discussions/1933
+ """
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-type", b"multipart/form-data; boundary=fd721ef49ea403a6"],
+ ]
+
+ starlette_request = starlette.requests.Request(scope)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in FORM_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ await extractor.request.form()
+
+ with pytest.raises(RuntimeError):
+ await extractor.request.body()
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_extract_request_info_too_big(sentry_init):
+ sentry_init(
+ send_default_pii=True,
+ integrations=[StarletteIntegration()],
+ )
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-type", b"multipart/form-data; boundary=fd721ef49ea403a6"],
+ [b"content-length", str(len(BODY_FORM)).encode()],
+ [b"cookie", b"yummy_cookie=choco; tasty_cookie=strawberry"],
+ ]
+ starlette_request = starlette.requests.Request(scope)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in FORM_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ request_info = await extractor.extract_request_info()
+
+ assert request_info
+ assert request_info["cookies"] == {
+ "tasty_cookie": "strawberry",
+ "yummy_cookie": "choco",
+ }
+ # Because request is too big only the AnnotatedValue is extracted.
+ assert request_info["data"].metadata == {"rem": [["!config", "x"]]}
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_extract_request_info(sentry_init):
+ sentry_init(
+ send_default_pii=True,
+ integrations=[StarletteIntegration()],
+ )
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-type", b"application/json"],
+ [b"content-length", str(len(json.dumps(BODY_JSON))).encode()],
+ [b"cookie", b"yummy_cookie=choco; tasty_cookie=strawberry"],
+ ]
+
+ starlette_request = starlette.requests.Request(scope)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in JSON_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ request_info = await extractor.extract_request_info()
+
+ assert request_info
+ assert request_info["cookies"] == {
+ "tasty_cookie": "strawberry",
+ "yummy_cookie": "choco",
+ }
+ assert request_info["data"] == BODY_JSON
+
+
+@pytest.mark.asyncio
+async def test_starlettrequestextractor_extract_request_info_no_pii(sentry_init):
+ sentry_init(
+ send_default_pii=False,
+ integrations=[StarletteIntegration()],
+ )
+ scope = SCOPE.copy()
+ scope["headers"] = [
+ [b"content-type", b"application/json"],
+ [b"content-length", str(len(json.dumps(BODY_JSON))).encode()],
+ [b"cookie", b"yummy_cookie=choco; tasty_cookie=strawberry"],
+ ]
+
+ starlette_request = starlette.requests.Request(scope)
+
+ # Mocking async `_receive()` that works in Python 3.7+
+ side_effect = [_mock_receive(msg) for msg in JSON_RECEIVE_MESSAGES]
+ starlette_request._receive = mock.Mock(side_effect=side_effect)
+
+ extractor = StarletteRequestExtractor(starlette_request)
+
+ request_info = await extractor.extract_request_info()
+
+ assert request_info
+ assert "cookies" not in request_info
+ assert request_info["data"] == BODY_JSON
+
+
+@pytest.mark.parametrize(
+ "url,transaction_style,expected_transaction,expected_source",
+ [
+ (
+ "/message",
+ "url",
+ "/message",
+ "route",
+ ),
+ (
+ "/message",
+ "endpoint",
+ "tests.integrations.starlette.test_starlette.starlette_app_factory.._message",
+ "component",
+ ),
+ (
+ "/message/123456",
+ "url",
+ "/message/{message_id}",
+ "route",
+ ),
+ (
+ "/message/123456",
+ "endpoint",
+ "tests.integrations.starlette.test_starlette.starlette_app_factory.._message_with_id",
+ "component",
+ ),
+ ],
+)
+def test_transaction_style(
+ sentry_init,
+ capture_events,
+ url,
+ transaction_style,
+ expected_transaction,
+ expected_source,
+):
+ sentry_init(
+ integrations=[StarletteIntegration(transaction_style=transaction_style)],
+ )
+ starlette_app = starlette_app_factory()
+
+ events = capture_events()
+
+ client = TestClient(starlette_app)
+ client.get(url)
+
+ (event,) = events
+ assert event["transaction"] == expected_transaction
+ assert event["transaction_info"] == {"source": expected_source}
+
+
+@pytest.mark.parametrize(
+ "test_url,expected_error,expected_message",
+ [
+ ("/some_url", ZeroDivisionError, "division by zero"),
+ ("/custom_error", Exception, "Too Hot"),
+ ],
+)
+def test_catch_exceptions(
+ sentry_init,
+ capture_exceptions,
+ capture_events,
+ test_url,
+ expected_error,
+ expected_message,
+):
+ sentry_init(integrations=[StarletteIntegration()])
+ starlette_app = starlette_app_factory()
+ exceptions = capture_exceptions()
+ events = capture_events()
+
+ client = TestClient(starlette_app)
+ try:
+ client.get(test_url)
+ except Exception:
+ pass
+
+ (exc,) = exceptions
+ assert isinstance(exc, expected_error)
+ assert str(exc) == expected_message
+
+ (event,) = events
+ assert event["exception"]["values"][0]["mechanism"]["type"] == "starlette"
+
+
+def test_user_information_error(sentry_init, capture_events):
+ sentry_init(
+ send_default_pii=True,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/custom_error", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+ (event,) = events
+ user = event.get("user", None)
+ assert user
+ assert "username" in user
+ assert user["username"] == "Gabriela"
+
+
+def test_user_information_error_no_pii(sentry_init, capture_events):
+ sentry_init(
+ send_default_pii=False,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/custom_error", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+ (event,) = events
+ assert "user" not in event
+
+
+def test_user_information_transaction(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ send_default_pii=True,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ client.get("/message", auth=("Gabriela", "hello123"))
+
+ (_, transaction_event) = events
+ user = transaction_event.get("user", None)
+ assert user
+ assert "username" in user
+ assert user["username"] == "Gabriela"
+
+
+def test_user_information_transaction_no_pii(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ send_default_pii=False,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ client.get("/message", auth=("Gabriela", "hello123"))
+
+ (_, transaction_event) = events
+ assert "user" not in transaction_event
+
+
+def test_middleware_spans(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/message", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = [
+ "ServerErrorMiddleware",
+ "AuthenticationMiddleware",
+ "ExceptionMiddleware",
+ ]
+
+ idx = 0
+ for span in transaction_event["spans"]:
+ if span["op"] == "middleware.starlette":
+ assert span["description"] == expected[idx]
+ assert span["tags"]["starlette.middleware_name"] == expected[idx]
+ idx += 1
+
+
+def test_middleware_callback_spans(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(middleware=[Middleware(SampleMiddleware)])
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/message", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = [
+ {
+ "op": "middleware.starlette",
+ "description": "ServerErrorMiddleware",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ {
+ "op": "middleware.starlette",
+ "description": "SampleMiddleware",
+ "tags": {"starlette.middleware_name": "SampleMiddleware"},
+ },
+ {
+ "op": "middleware.starlette",
+ "description": "ExceptionMiddleware",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "SampleMiddleware.__call__..do_stuff",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "ServerErrorMiddleware.__call__.._send",
+ "tags": {"starlette.middleware_name": "SampleMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "_ASGIAdapter.send..send"
+ if STARLETTE_VERSION < (0, 21)
+ else "_TestClientTransport.handle_request..send",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "SampleMiddleware.__call__..do_stuff",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "ServerErrorMiddleware.__call__.._send",
+ "tags": {"starlette.middleware_name": "SampleMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "_ASGIAdapter.send..send"
+ if STARLETTE_VERSION < (0, 21)
+ else "_TestClientTransport.handle_request..send",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ ]
+
+ idx = 0
+ for span in transaction_event["spans"]:
+ assert span["op"] == expected[idx]["op"]
+ assert span["description"] == expected[idx]["description"]
+ assert span["tags"] == expected[idx]["tags"]
+ idx += 1
+
+
+def test_middleware_receive_send(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(SampleReceiveSendMiddleware)]
+ )
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ # NOTE: the assert statements checking
+ # for correct behaviour are in `SampleReceiveSendMiddleware`!
+ client.get("/message", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+
+def test_middleware_partial_receive_send(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarletteIntegration()],
+ )
+ starlette_app = starlette_app_factory(
+ middleware=[Middleware(SamplePartialReceiveSendMiddleware)]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/message", auth=("Gabriela", "hello123"))
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = [
+ {
+ "op": "middleware.starlette",
+ "description": "ServerErrorMiddleware",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ {
+ "op": "middleware.starlette",
+ "description": "SamplePartialReceiveSendMiddleware",
+ "tags": {"starlette.middleware_name": "SamplePartialReceiveSendMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.receive",
+ "description": "_ASGIAdapter.send..receive"
+ if STARLETTE_VERSION < (0, 21)
+ else "_TestClientTransport.handle_request..receive",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "ServerErrorMiddleware.__call__.._send",
+ "tags": {"starlette.middleware_name": "SamplePartialReceiveSendMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "_ASGIAdapter.send..send"
+ if STARLETTE_VERSION < (0, 21)
+ else "_TestClientTransport.handle_request..send",
+ "tags": {"starlette.middleware_name": "ServerErrorMiddleware"},
+ },
+ {
+ "op": "middleware.starlette",
+ "description": "ExceptionMiddleware",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "functools.partial(.my_send at ",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ {
+ "op": "middleware.starlette.send",
+ "description": "functools.partial(.my_send at ",
+ "tags": {"starlette.middleware_name": "ExceptionMiddleware"},
+ },
+ ]
+
+ idx = 0
+ for span in transaction_event["spans"]:
+ assert span["op"] == expected[idx]["op"]
+ assert span["description"].startswith(expected[idx]["description"])
+ assert span["tags"] == expected[idx]["tags"]
+ idx += 1
+
+
+def test_last_event_id(sentry_init, capture_events):
+ sentry_init(
+ integrations=[StarletteIntegration()],
+ )
+ events = capture_events()
+
+ def handler(request, exc):
+ capture_exception(exc)
+ return starlette.responses.PlainTextResponse(last_event_id(), status_code=500)
+
+ app = starlette_app_factory(debug=False)
+ app.add_exception_handler(500, handler)
+
+ client = TestClient(SentryAsgiMiddleware(app), raise_server_exceptions=False)
+ response = client.get("/custom_error")
+ assert response.status_code == 500
+
+ event = events[0]
+ assert response.content.strip().decode("ascii") == event["event_id"]
+ (exception,) = event["exception"]["values"]
+ assert exception["type"] == "Exception"
+ assert exception["value"] == "Too Hot"
+
+
+def test_legacy_setup(
+ sentry_init,
+ capture_events,
+):
+ # Check that behaviour does not change
+ # if the user just adds the new Integration
+ # and forgets to remove SentryAsgiMiddleware
+ sentry_init()
+ app = starlette_app_factory()
+ asgi_app = SentryAsgiMiddleware(app)
+
+ events = capture_events()
+
+ client = TestClient(asgi_app)
+ client.get("/message/123456")
+
+ (event,) = events
+ assert event["transaction"] == "/message/{message_id}"
+
+
+@pytest.mark.parametrize("endpoint", ["/sync/thread_ids", "/async/thread_ids"])
+@mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0)
+def test_active_thread_id(sentry_init, capture_envelopes, teardown_profiling, endpoint):
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+ app = starlette_app_factory()
+ asgi_app = SentryAsgiMiddleware(app)
+
+ envelopes = capture_envelopes()
+
+ client = TestClient(asgi_app)
+ response = client.get(endpoint)
+ assert response.status_code == 200
+
+ data = json.loads(response.content)
+
+ envelopes = [envelope for envelope in envelopes]
+ assert len(envelopes) == 1
+
+ profiles = [item for item in envelopes[0].items if item.type == "profile"]
+ assert len(profiles) == 1
+
+ for profile in profiles:
+ transactions = profile.payload.json["transactions"]
+ assert len(transactions) == 1
+ assert str(data["active"]) == transactions[0]["active_thread_id"]
+
+
+def test_original_request_not_scrubbed(sentry_init, capture_events):
+ sentry_init(integrations=[StarletteIntegration()])
+
+ events = capture_events()
+
+ async def _error(request):
+ logging.critical("Oh no!")
+ assert request.headers["Authorization"] == "Bearer ohno"
+ assert await request.json() == {"password": "ohno"}
+ return starlette.responses.JSONResponse({"status": "Oh no!"})
+
+ app = starlette.applications.Starlette(
+ routes=[
+ starlette.routing.Route("/error", _error, methods=["POST"]),
+ ],
+ )
+
+ client = TestClient(app)
+ client.post(
+ "/error",
+ json={"password": "ohno"},
+ headers={"Authorization": "Bearer ohno"},
+ )
+
+ event = events[0]
+ assert event["request"]["data"] == {"password": "[Filtered]"}
+ assert event["request"]["headers"]["authorization"] == "[Filtered]"
diff --git a/tests/integrations/starlite/__init__.py b/tests/integrations/starlite/__init__.py
new file mode 100644
index 0000000000..4c1037671d
--- /dev/null
+++ b/tests/integrations/starlite/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("starlite")
diff --git a/tests/integrations/starlite/test_starlite.py b/tests/integrations/starlite/test_starlite.py
new file mode 100644
index 0000000000..603697ce8b
--- /dev/null
+++ b/tests/integrations/starlite/test_starlite.py
@@ -0,0 +1,325 @@
+import functools
+
+import pytest
+
+from sentry_sdk import capture_exception, capture_message, last_event_id
+from sentry_sdk.integrations.starlite import StarliteIntegration
+
+starlite = pytest.importorskip("starlite")
+
+from typing import Any, Dict
+
+from starlite import AbstractMiddleware, LoggingConfig, Starlite, get, Controller
+from starlite.middleware import LoggingMiddlewareConfig, RateLimitConfig
+from starlite.middleware.session.memory_backend import MemoryBackendConfig
+from starlite.status_codes import HTTP_500_INTERNAL_SERVER_ERROR
+from starlite.testing import TestClient
+
+
+class SampleMiddleware(AbstractMiddleware):
+ async def __call__(self, scope, receive, send) -> None:
+ async def do_stuff(message):
+ if message["type"] == "http.response.start":
+ # do something here.
+ pass
+ await send(message)
+
+ await self.app(scope, receive, do_stuff)
+
+
+class SampleReceiveSendMiddleware(AbstractMiddleware):
+ async def __call__(self, scope, receive, send):
+ message = await receive()
+ assert message
+ assert message["type"] == "http.request"
+
+ send_output = await send({"type": "something-unimportant"})
+ assert send_output is None
+
+ await self.app(scope, receive, send)
+
+
+class SamplePartialReceiveSendMiddleware(AbstractMiddleware):
+ async def __call__(self, scope, receive, send):
+ message = await receive()
+ assert message
+ assert message["type"] == "http.request"
+
+ send_output = await send({"type": "something-unimportant"})
+ assert send_output is None
+
+ async def my_receive(*args, **kwargs):
+ pass
+
+ async def my_send(*args, **kwargs):
+ pass
+
+ partial_receive = functools.partial(my_receive)
+ partial_send = functools.partial(my_send)
+
+ await self.app(scope, partial_receive, partial_send)
+
+
+def starlite_app_factory(middleware=None, debug=True, exception_handlers=None):
+ class MyController(Controller):
+ path = "/controller"
+
+ @get("/error")
+ async def controller_error(self) -> None:
+ raise Exception("Whoa")
+
+ @get("/some_url")
+ async def homepage_handler() -> Dict[str, Any]:
+ 1 / 0
+ return {"status": "ok"}
+
+ @get("/custom_error", name="custom_name")
+ async def custom_error() -> Any:
+ raise Exception("Too Hot")
+
+ @get("/message")
+ async def message() -> Dict[str, Any]:
+ capture_message("hi")
+ return {"status": "ok"}
+
+ @get("/message/{message_id:str}")
+ async def message_with_id() -> Dict[str, Any]:
+ capture_message("hi")
+ return {"status": "ok"}
+
+ logging_config = LoggingConfig()
+
+ app = Starlite(
+ route_handlers=[
+ homepage_handler,
+ custom_error,
+ message,
+ message_with_id,
+ MyController,
+ ],
+ debug=debug,
+ middleware=middleware,
+ logging_config=logging_config,
+ exception_handlers=exception_handlers,
+ )
+
+ return app
+
+
+@pytest.mark.parametrize(
+ "test_url,expected_error,expected_message,expected_tx_name",
+ [
+ (
+ "/some_url",
+ ZeroDivisionError,
+ "division by zero",
+ "tests.integrations.starlite.test_starlite.starlite_app_factory..homepage_handler",
+ ),
+ (
+ "/custom_error",
+ Exception,
+ "Too Hot",
+ "custom_name",
+ ),
+ (
+ "/controller/error",
+ Exception,
+ "Whoa",
+ "partial(.MyController.controller_error>)",
+ ),
+ ],
+)
+def test_catch_exceptions(
+ sentry_init,
+ capture_exceptions,
+ capture_events,
+ test_url,
+ expected_error,
+ expected_message,
+ expected_tx_name,
+):
+ sentry_init(integrations=[StarliteIntegration()])
+ starlite_app = starlite_app_factory()
+ exceptions = capture_exceptions()
+ events = capture_events()
+
+ client = TestClient(starlite_app)
+ try:
+ client.get(test_url)
+ except Exception:
+ pass
+
+ (exc,) = exceptions
+ assert isinstance(exc, expected_error)
+ assert str(exc) == expected_message
+
+ (event,) = events
+ assert event["exception"]["values"][0]["mechanism"]["type"] == "starlite"
+ assert event["transaction"] == expected_tx_name
+
+
+def test_middleware_spans(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarliteIntegration()],
+ )
+
+ logging_config = LoggingMiddlewareConfig()
+ session_config = MemoryBackendConfig()
+ rate_limit_config = RateLimitConfig(rate_limit=("hour", 5))
+
+ starlite_app = starlite_app_factory(
+ middleware=[
+ session_config.middleware,
+ logging_config.middleware,
+ rate_limit_config.middleware,
+ ]
+ )
+ events = capture_events()
+
+ client = TestClient(
+ starlite_app, raise_server_exceptions=False, base_url="http://testserver.local"
+ )
+ try:
+ client.get("/message")
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = ["SessionMiddleware", "LoggingMiddleware", "RateLimitMiddleware"]
+
+ idx = 0
+ for span in transaction_event["spans"]:
+ if span["op"] == "middleware.starlite":
+ assert span["description"] == expected[idx]
+ assert span["tags"]["starlite.middleware_name"] == expected[idx]
+ idx += 1
+
+
+def test_middleware_callback_spans(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarliteIntegration()],
+ )
+ starlette_app = starlite_app_factory(middleware=[SampleMiddleware])
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/message")
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = [
+ {
+ "op": "middleware.starlite",
+ "description": "SampleMiddleware",
+ "tags": {"starlite.middleware_name": "SampleMiddleware"},
+ },
+ {
+ "op": "middleware.starlite.send",
+ "description": "TestClientTransport.create_send..send",
+ "tags": {"starlite.middleware_name": "SampleMiddleware"},
+ },
+ {
+ "op": "middleware.starlite.send",
+ "description": "TestClientTransport.create_send..send",
+ "tags": {"starlite.middleware_name": "SampleMiddleware"},
+ },
+ ]
+ print(transaction_event["spans"])
+ idx = 0
+ for span in transaction_event["spans"]:
+ assert span["op"] == expected[idx]["op"]
+ assert span["description"] == expected[idx]["description"]
+ assert span["tags"] == expected[idx]["tags"]
+ idx += 1
+
+
+def test_middleware_receive_send(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarliteIntegration()],
+ )
+ starlette_app = starlite_app_factory(middleware=[SampleReceiveSendMiddleware])
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ # NOTE: the assert statements checking
+ # for correct behaviour are in `SampleReceiveSendMiddleware`!
+ client.get("/message")
+ except Exception:
+ pass
+
+
+def test_middleware_partial_receive_send(sentry_init, capture_events):
+ sentry_init(
+ traces_sample_rate=1.0,
+ integrations=[StarliteIntegration()],
+ )
+ starlette_app = starlite_app_factory(
+ middleware=[SamplePartialReceiveSendMiddleware]
+ )
+ events = capture_events()
+
+ client = TestClient(starlette_app, raise_server_exceptions=False)
+ try:
+ client.get("/message")
+ except Exception:
+ pass
+
+ (_, transaction_event) = events
+
+ expected = [
+ {
+ "op": "middleware.starlite",
+ "description": "SamplePartialReceiveSendMiddleware",
+ "tags": {"starlite.middleware_name": "SamplePartialReceiveSendMiddleware"},
+ },
+ {
+ "op": "middleware.starlite.receive",
+ "description": "TestClientTransport.create_receive..receive",
+ "tags": {"starlite.middleware_name": "SamplePartialReceiveSendMiddleware"},
+ },
+ {
+ "op": "middleware.starlite.send",
+ "description": "TestClientTransport.create_send..send",
+ "tags": {"starlite.middleware_name": "SamplePartialReceiveSendMiddleware"},
+ },
+ ]
+
+ print(transaction_event["spans"])
+ idx = 0
+ for span in transaction_event["spans"]:
+ assert span["op"] == expected[idx]["op"]
+ assert span["description"].startswith(expected[idx]["description"])
+ assert span["tags"] == expected[idx]["tags"]
+ idx += 1
+
+
+def test_last_event_id(sentry_init, capture_events):
+ sentry_init(
+ integrations=[StarliteIntegration()],
+ )
+ events = capture_events()
+
+ def handler(request, exc):
+ capture_exception(exc)
+ return starlite.response.Response(last_event_id(), status_code=500)
+
+ app = starlite_app_factory(
+ debug=False, exception_handlers={HTTP_500_INTERNAL_SERVER_ERROR: handler}
+ )
+
+ client = TestClient(app, raise_server_exceptions=False)
+ response = client.get("/custom_error")
+ assert response.status_code == 500
+ print(events)
+ event = events[-1]
+ assert response.content.strip().decode("ascii").strip('"') == event["event_id"]
+ (exception,) = event["exception"]["values"]
+ assert exception["type"] == "Exception"
+ assert exception["value"] == "Too Hot"
diff --git a/tests/integrations/stdlib/test_httplib.py b/tests/integrations/stdlib/test_httplib.py
index c90f9eb891..fe3f1e196f 100644
--- a/tests/integrations/stdlib/test_httplib.py
+++ b/tests/integrations/stdlib/test_httplib.py
@@ -1,5 +1,4 @@
-import platform
-import sys
+import random
import pytest
@@ -12,38 +11,48 @@
try:
# py2
- from httplib import HTTPSConnection
+ from httplib import HTTPConnection, HTTPSConnection
except ImportError:
# py3
- from http.client import HTTPSConnection
+ from http.client import HTTPConnection, HTTPSConnection
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
+
from sentry_sdk import capture_message, start_transaction
+from sentry_sdk.consts import MATCH_ALL, SPANDATA
+from sentry_sdk.tracing import Transaction
from sentry_sdk.integrations.stdlib import StdlibIntegration
+from tests.conftest import create_mock_http_server
+
+PORT = create_mock_http_server()
+
def test_crumb_capture(sentry_init, capture_events):
sentry_init(integrations=[StdlibIntegration()])
events = capture_events()
- url = "https://httpbin.org/status/200"
- response = urlopen(url)
- assert response.getcode() == 200
+ url = "http://localhost:{}/some/random/url".format(PORT)
+ urlopen(url)
+
capture_message("Testing!")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
+
assert crumb["type"] == "http"
assert crumb["category"] == "httplib"
assert crumb["data"] == {
"url": url,
- "method": "GET",
- "status_code": 200,
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_STATUS_CODE: 200,
"reason": "OK",
+ SPANDATA.HTTP_FRAGMENT: "",
+ SPANDATA.HTTP_QUERY: "",
}
@@ -55,9 +64,9 @@ def before_breadcrumb(crumb, hint):
sentry_init(integrations=[StdlibIntegration()], before_breadcrumb=before_breadcrumb)
events = capture_events()
- url = "https://httpbin.org/status/200"
- response = urlopen(url)
- assert response.getcode() == 200
+ url = "http://localhost:{}/some/random/url".format(PORT)
+ urlopen(url)
+
capture_message("Testing!")
(event,) = events
@@ -66,14 +75,23 @@ def before_breadcrumb(crumb, hint):
assert crumb["category"] == "httplib"
assert crumb["data"] == {
"url": url,
- "method": "GET",
- "status_code": 200,
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_STATUS_CODE: 200,
"reason": "OK",
"extra": "foo",
+ SPANDATA.HTTP_FRAGMENT: "",
+ SPANDATA.HTTP_QUERY: "",
}
- if platform.python_implementation() != "PyPy":
- assert sys.getrefcount(response) == 2
+
+def test_empty_realurl(sentry_init, capture_events):
+ """
+ Ensure that after using sentry_sdk.init you can putrequest a
+ None url.
+ """
+
+ sentry_init(dsn="")
+ HTTPConnection("example.com", port=443).putrequest("POST", None)
def test_httplib_misuse(sentry_init, capture_events, request):
@@ -89,19 +107,19 @@ def test_httplib_misuse(sentry_init, capture_events, request):
sentry_init()
events = capture_events()
- conn = HTTPSConnection("httpbin.org", 443)
+ conn = HTTPConnection("localhost", PORT)
# make sure we release the resource, even if the test fails
request.addfinalizer(conn.close)
- conn.request("GET", "/anything/foo")
+ conn.request("GET", "/200")
with pytest.raises(Exception):
# This raises an exception, because we didn't call `getresponse` for
# the previous request yet.
#
# This call should not affect our breadcrumb.
- conn.request("POST", "/anything/bar")
+ conn.request("POST", "/200")
response = conn.getresponse()
assert response._method == "GET"
@@ -114,16 +132,16 @@ def test_httplib_misuse(sentry_init, capture_events, request):
assert crumb["type"] == "http"
assert crumb["category"] == "httplib"
assert crumb["data"] == {
- "url": "https://httpbin.org/anything/foo",
- "method": "GET",
- "status_code": 200,
+ "url": "http://localhost:{}/200".format(PORT),
+ SPANDATA.HTTP_METHOD: "GET",
+ SPANDATA.HTTP_STATUS_CODE: 200,
"reason": "OK",
+ SPANDATA.HTTP_FRAGMENT: "",
+ SPANDATA.HTTP_QUERY: "",
}
-def test_outgoing_trace_headers(
- sentry_init, monkeypatch, StringContaining # noqa: N803
-):
+def test_outgoing_trace_headers(sentry_init, monkeypatch):
# HTTPSConnection.send is passed a string containing (among other things)
# the headers on the request. Mock it so we can check the headers, and also
# so it doesn't try to actually talk to the internet.
@@ -132,22 +150,193 @@ def test_outgoing_trace_headers(
sentry_init(traces_sample_rate=1.0)
+ headers = {}
+ headers["baggage"] = (
+ "other-vendor-value-1=foo;bar;baz, sentry-trace_id=771a43a4192642f0b136d5159a501700, "
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3, sentry-sample_rate=0.01337, "
+ "sentry-user_id=Am%C3%A9lie, other-vendor-value-2=foo;bar;"
+ )
+
+ transaction = Transaction.continue_from_headers(headers)
+
with start_transaction(
+ transaction=transaction,
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
trace_id="12312012123120121231201212312012",
) as transaction:
+ HTTPSConnection("www.squirrelchasers.com").request("GET", "/top-chasers")
+
+ (request_str,) = mock_send.call_args[0]
+ request_headers = {}
+ for line in request_str.decode("utf-8").split("\r\n")[1:]:
+ if line:
+ key, val = line.split(": ")
+ request_headers[key] = val
+ request_span = transaction._span_recorder.spans[-1]
+ expected_sentry_trace = "{trace_id}-{parent_span_id}-{sampled}".format(
+ trace_id=transaction.trace_id,
+ parent_span_id=request_span.span_id,
+ sampled=1,
+ )
+ assert request_headers["sentry-trace"] == expected_sentry_trace
+
+ expected_outgoing_baggage_items = [
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700",
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3",
+ "sentry-sample_rate=0.01337",
+ "sentry-user_id=Am%C3%A9lie",
+ ]
+
+ assert sorted(request_headers["baggage"].split(",")) == sorted(
+ expected_outgoing_baggage_items
+ )
+
+
+def test_outgoing_trace_headers_head_sdk(sentry_init, monkeypatch):
+ # HTTPSConnection.send is passed a string containing (among other things)
+ # the headers on the request. Mock it so we can check the headers, and also
+ # so it doesn't try to actually talk to the internet.
+ mock_send = mock.Mock()
+ monkeypatch.setattr(HTTPSConnection, "send", mock_send)
+
+ # make sure transaction is always sampled
+ monkeypatch.setattr(random, "random", lambda: 0.1)
+
+ sentry_init(traces_sample_rate=0.5, release="foo")
+ transaction = Transaction.continue_from_headers({})
+
+ with start_transaction(transaction=transaction, name="Head SDK tx") as transaction:
HTTPSConnection("www.squirrelchasers.com").request("GET", "/top-chasers")
+ (request_str,) = mock_send.call_args[0]
+ request_headers = {}
+ for line in request_str.decode("utf-8").split("\r\n")[1:]:
+ if line:
+ key, val = line.split(": ")
+ request_headers[key] = val
+
request_span = transaction._span_recorder.spans[-1]
+ expected_sentry_trace = "{trace_id}-{parent_span_id}-{sampled}".format(
+ trace_id=transaction.trace_id,
+ parent_span_id=request_span.span_id,
+ sampled=1,
+ )
+ assert request_headers["sentry-trace"] == expected_sentry_trace
+
+ expected_outgoing_baggage_items = [
+ "sentry-trace_id=%s" % transaction.trace_id,
+ "sentry-sample_rate=0.5",
+ "sentry-release=foo",
+ "sentry-environment=production",
+ ]
- expected_sentry_trace = (
- "sentry-trace: {trace_id}-{parent_span_id}-{sampled}".format(
- trace_id=transaction.trace_id,
- parent_span_id=request_span.span_id,
- sampled=1,
- )
+ assert sorted(request_headers["baggage"].split(",")) == sorted(
+ expected_outgoing_baggage_items
)
- mock_send.assert_called_with(StringContaining(expected_sentry_trace))
+
+@pytest.mark.parametrize(
+ "trace_propagation_targets,host,path,trace_propagated",
+ [
+ [
+ [],
+ "example.com",
+ "/",
+ False,
+ ],
+ [
+ None,
+ "example.com",
+ "/",
+ False,
+ ],
+ [
+ [MATCH_ALL],
+ "example.com",
+ "/",
+ True,
+ ],
+ [
+ ["https://example.com/"],
+ "example.com",
+ "/",
+ True,
+ ],
+ [
+ ["https://example.com/"],
+ "example.com",
+ "",
+ False,
+ ],
+ [
+ ["https://example.com"],
+ "example.com",
+ "",
+ True,
+ ],
+ [
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "example.net",
+ "",
+ False,
+ ],
+ [
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "good.example.net",
+ "",
+ True,
+ ],
+ [
+ ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+ "good.example.net",
+ "/some/thing",
+ True,
+ ],
+ ],
+)
+def test_option_trace_propagation_targets(
+ sentry_init, monkeypatch, trace_propagation_targets, host, path, trace_propagated
+):
+ # HTTPSConnection.send is passed a string containing (among other things)
+ # the headers on the request. Mock it so we can check the headers, and also
+ # so it doesn't try to actually talk to the internet.
+ mock_send = mock.Mock()
+ monkeypatch.setattr(HTTPSConnection, "send", mock_send)
+
+ sentry_init(
+ trace_propagation_targets=trace_propagation_targets,
+ traces_sample_rate=1.0,
+ )
+
+ headers = {
+ "baggage": (
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700, "
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3, sentry-sample_rate=0.01337, "
+ )
+ }
+
+ transaction = Transaction.continue_from_headers(headers)
+
+ with start_transaction(
+ transaction=transaction,
+ name="/interactions/other-dogs/new-dog",
+ op="greeting.sniff",
+ trace_id="12312012123120121231201212312012",
+ ) as transaction:
+ HTTPSConnection(host).request("GET", path)
+
+ (request_str,) = mock_send.call_args[0]
+ request_headers = {}
+ for line in request_str.decode("utf-8").split("\r\n")[1:]:
+ if line:
+ key, val = line.split(": ")
+ request_headers[key] = val
+
+ if trace_propagated:
+ assert "sentry-trace" in request_headers
+ assert "baggage" in request_headers
+ else:
+ assert "sentry-trace" not in request_headers
+ assert "baggage" not in request_headers
diff --git a/tests/integrations/threading/test_threading.py b/tests/integrations/threading/test_threading.py
index 67b79e2080..912717dddd 100644
--- a/tests/integrations/threading/test_threading.py
+++ b/tests/integrations/threading/test_threading.py
@@ -1,5 +1,5 @@
import gc
-
+import sys
from threading import Thread
import pytest
@@ -7,6 +7,9 @@
from sentry_sdk import configure_scope, capture_message
from sentry_sdk.integrations.threading import ThreadingIntegration
+original_start = Thread.start
+original_run = Thread.run
+
@pytest.mark.forked
@pytest.mark.parametrize("integrations", [[ThreadingIntegration()], []])
@@ -26,7 +29,8 @@ def crash():
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
- assert exception["mechanism"] == {"type": "threading", "handled": False}
+ assert exception["mechanism"]["type"] == "threading"
+ assert not exception["mechanism"]["handled"]
else:
assert not events
@@ -60,7 +64,8 @@ def stage2():
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
- assert exception["mechanism"] == {"type": "threading", "handled": False}
+ assert exception["mechanism"]["type"] == "threading"
+ assert not exception["mechanism"]["handled"]
if propagate_hub:
assert event["tags"]["stage1"] == "true"
@@ -114,3 +119,47 @@ def run(self):
for event in events:
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
+
+
+@pytest.mark.skipif(sys.version_info < (3, 2), reason="no __qualname__ in older python")
+def test_wrapper_attributes(sentry_init):
+ sentry_init(default_integrations=False, integrations=[ThreadingIntegration()])
+
+ def target():
+ assert t.run.__name__ == "run"
+ assert t.run.__qualname__ == original_run.__qualname__
+
+ t = Thread(target=target)
+ t.start()
+ t.join()
+
+ assert Thread.start.__name__ == "start"
+ assert Thread.start.__qualname__ == original_start.__qualname__
+ assert t.start.__name__ == "start"
+ assert t.start.__qualname__ == original_start.__qualname__
+
+ assert Thread.run.__name__ == "run"
+ assert Thread.run.__qualname__ == original_run.__qualname__
+ assert t.run.__name__ == "run"
+ assert t.run.__qualname__ == original_run.__qualname__
+
+
+@pytest.mark.skipif(
+ sys.version_info > (2, 7),
+ reason="simpler test for py2.7 without py3 only __qualname__",
+)
+def test_wrapper_attributes_no_qualname(sentry_init):
+ sentry_init(default_integrations=False, integrations=[ThreadingIntegration()])
+
+ def target():
+ assert t.run.__name__ == "run"
+
+ t = Thread(target=target)
+ t.start()
+ t.join()
+
+ assert Thread.start.__name__ == "start"
+ assert t.start.__name__ == "start"
+
+ assert Thread.run.__name__ == "run"
+ assert t.run.__name__ == "run"
diff --git a/tests/integrations/tornado/test_tornado.py b/tests/integrations/tornado/test_tornado.py
index 1c5137f2b2..2160154933 100644
--- a/tests/integrations/tornado/test_tornado.py
+++ b/tests/integrations/tornado/test_tornado.py
@@ -2,7 +2,7 @@
import pytest
-from sentry_sdk import configure_scope, start_transaction
+from sentry_sdk import configure_scope, start_transaction, capture_message
from sentry_sdk.integrations.tornado import TornadoIntegration
from tornado.web import RequestHandler, Application, HTTPError
@@ -46,6 +46,12 @@ def post(self):
1 / 0
+class CrashingWithMessageHandler(RequestHandler):
+ def get(self):
+ capture_message("hi")
+ 1 / 0
+
+
class HelloHandler(RequestHandler):
async def get(self):
with configure_scope() as scope:
@@ -96,6 +102,7 @@ def test_basic(tornado_testcase, sentry_init, capture_events):
event["transaction"]
== "tests.integrations.tornado.test_tornado.CrashingHandler.get"
)
+ assert event["transaction_info"] == {"source": "component"}
with configure_scope() as scope:
assert not scope._tags
@@ -129,6 +136,9 @@ def test_transactions(tornado_testcase, sentry_init, capture_events, handler, co
assert client_tx["type"] == "transaction"
assert client_tx["transaction"] == "client"
+ assert client_tx["transaction_info"] == {
+ "source": "custom"
+ } # because this is just the start_transaction() above.
if server_error is not None:
assert server_error["exception"]["values"][0]["type"] == "ZeroDivisionError"
@@ -136,6 +146,7 @@ def test_transactions(tornado_testcase, sentry_init, capture_events, handler, co
server_error["transaction"]
== "tests.integrations.tornado.test_tornado.CrashingHandler.post"
)
+ assert server_error["transaction_info"] == {"source": "component"}
if code == 200:
assert (
@@ -148,6 +159,7 @@ def test_transactions(tornado_testcase, sentry_init, capture_events, handler, co
== "tests.integrations.tornado.test_tornado.CrashingHandler.post"
)
+ assert server_tx["transaction_info"] == {"source": "component"}
assert server_tx["type"] == "transaction"
request = server_tx["request"]
@@ -286,3 +298,145 @@ def post(self):
assert exception["value"] == "[]"
assert event
assert event["request"]["data"] == {"foo": {"bar": 42}}
+
+
+def test_error_has_new_trace_context_performance_enabled(
+ tornado_testcase, sentry_init, capture_events
+):
+ """
+ Check if an 'trace' context is added to errros and transactions when performance monitoring is enabled.
+ """
+ sentry_init(
+ integrations=[TornadoIntegration()],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ client = tornado_testcase(Application([(r"/hi", CrashingWithMessageHandler)]))
+ client.fetch("/hi")
+
+ (msg_event, error_event, transaction_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_new_trace_context_performance_disabled(
+ tornado_testcase, sentry_init, capture_events
+):
+ """
+ Check if an 'trace' context is added to errros and transactions when performance monitoring is disabled.
+ """
+ sentry_init(
+ integrations=[TornadoIntegration()],
+ traces_sample_rate=None, # this is the default, just added for clarity
+ )
+ events = capture_events()
+
+ client = tornado_testcase(Application([(r"/hi", CrashingWithMessageHandler)]))
+ client.fetch("/hi")
+
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_error_has_existing_trace_context_performance_enabled(
+ tornado_testcase, sentry_init, capture_events
+):
+ """
+ Check if an 'trace' context is added to errros and transactions
+ from the incoming 'sentry-trace' header when performance monitoring is enabled.
+ """
+ sentry_init(
+ integrations=[TornadoIntegration()],
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ headers = {"sentry-trace": sentry_trace_header}
+
+ client = tornado_testcase(Application([(r"/hi", CrashingWithMessageHandler)]))
+ client.fetch("/hi", headers=headers)
+
+ (msg_event, error_event, transaction_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert "trace" in transaction_event["contexts"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
+
+
+def test_error_has_existing_trace_context_performance_disabled(
+ tornado_testcase, sentry_init, capture_events
+):
+ """
+ Check if an 'trace' context is added to errros and transactions
+ from the incoming 'sentry-trace' header when performance monitoring is disabled.
+ """
+ sentry_init(
+ integrations=[TornadoIntegration()],
+ traces_sample_rate=None, # this is the default, just added for clarity
+ )
+ events = capture_events()
+
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ sentry_trace_header = "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled)
+
+ headers = {"sentry-trace": sentry_trace_header}
+
+ client = tornado_testcase(Application([(r"/hi", CrashingWithMessageHandler)]))
+ client.fetch("/hi", headers=headers)
+
+ (msg_event, error_event) = events
+
+ assert "trace" in msg_event["contexts"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert "trace" in error_event["contexts"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == "471a43a4192642f0b136d5159a501701"
+ )
diff --git a/tests/integrations/wsgi/test_wsgi.py b/tests/integrations/wsgi/test_wsgi.py
index 66cc1a1de7..3616c7cc2f 100644
--- a/tests/integrations/wsgi/test_wsgi.py
+++ b/tests/integrations/wsgi/test_wsgi.py
@@ -1,7 +1,11 @@
+import sys
+
from werkzeug.test import Client
+
import pytest
import sentry_sdk
+from sentry_sdk import capture_message
from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
from collections import Counter
@@ -137,6 +141,8 @@ def dogpark(environ, start_response):
assert error_event["transaction"] == "generic WSGI request"
assert error_event["contexts"]["trace"]["op"] == "http.server"
assert error_event["exception"]["values"][0]["type"] == "Exception"
+ assert error_event["exception"]["values"][0]["mechanism"]["type"] == "wsgi"
+ assert error_event["exception"]["values"][0]["mechanism"]["handled"] is False
assert (
error_event["exception"]["values"][0]["value"]
== "Fetch aborted. The ball was not returned."
@@ -177,8 +183,139 @@ def dogpark(environ, start_response):
)
+def test_has_trace_if_performance_enabled(
+ sentry_init,
+ capture_events,
+):
+ def dogpark(environ, start_response):
+ capture_message("Attempting to fetch the ball")
+ raise Exception("Fetch aborted. The ball was not returned.")
+
+ sentry_init(traces_sample_rate=1.0)
+ app = SentryWsgiMiddleware(dogpark)
+ client = Client(app)
+ events = capture_events()
+
+ with pytest.raises(Exception):
+ client.get("http://dogs.are.great/sit/stay/rollover/")
+
+ msg_event, error_event, transaction_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert (
+ msg_event["contexts"]["trace"]["trace_id"]
+ == error_event["contexts"]["trace"]["trace_id"]
+ == transaction_event["contexts"]["trace"]["trace_id"]
+ )
+
+
+def test_has_trace_if_performance_disabled(
+ sentry_init,
+ capture_events,
+):
+ def dogpark(environ, start_response):
+ capture_message("Attempting to fetch the ball")
+ raise Exception("Fetch aborted. The ball was not returned.")
+
+ sentry_init()
+ app = SentryWsgiMiddleware(dogpark)
+ client = Client(app)
+ events = capture_events()
+
+ with pytest.raises(Exception):
+ client.get("http://dogs.are.great/sit/stay/rollover/")
+
+ msg_event, error_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+
+def test_trace_from_headers_if_performance_enabled(
+ sentry_init,
+ capture_events,
+):
+ def dogpark(environ, start_response):
+ capture_message("Attempting to fetch the ball")
+ raise Exception("Fetch aborted. The ball was not returned.")
+
+ sentry_init(traces_sample_rate=1.0)
+ app = SentryWsgiMiddleware(dogpark)
+ client = Client(app)
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ with pytest.raises(Exception):
+ client.get(
+ "http://dogs.are.great/sit/stay/rollover/",
+ headers={"sentry-trace": sentry_trace_header},
+ )
+
+ msg_event, error_event, transaction_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+
+ assert transaction_event["contexts"]["trace"]
+ assert "trace_id" in transaction_event["contexts"]["trace"]
+
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+ assert transaction_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
+def test_trace_from_headers_if_performance_disabled(
+ sentry_init,
+ capture_events,
+):
+ def dogpark(environ, start_response):
+ capture_message("Attempting to fetch the ball")
+ raise Exception("Fetch aborted. The ball was not returned.")
+
+ sentry_init()
+ app = SentryWsgiMiddleware(dogpark)
+ client = Client(app)
+ events = capture_events()
+
+ trace_id = "582b43a4192642f0b136d5159a501701"
+ sentry_trace_header = "{}-{}-{}".format(trace_id, "6e8f22c393e68f19", 1)
+
+ with pytest.raises(Exception):
+ client.get(
+ "http://dogs.are.great/sit/stay/rollover/",
+ headers={"sentry-trace": sentry_trace_header},
+ )
+
+ msg_event, error_event = events
+
+ assert msg_event["contexts"]["trace"]
+ assert "trace_id" in msg_event["contexts"]["trace"]
+ assert msg_event["contexts"]["trace"]["trace_id"] == trace_id
+
+ assert error_event["contexts"]["trace"]
+ assert "trace_id" in error_event["contexts"]["trace"]
+ assert error_event["contexts"]["trace"]["trace_id"] == trace_id
+
+
def test_traces_sampler_gets_correct_values_in_sampling_context(
- sentry_init, DictionaryContaining, ObjectDescribedBy # noqa:N803
+ sentry_init,
+ DictionaryContaining, # noqa:N803
):
def app(environ, start_response):
start_response("200 OK", [])
@@ -279,3 +416,33 @@ def sample_app(environ, start_response):
assert session_aggregates[0]["exited"] == 2
assert session_aggregates[0]["crashed"] == 1
assert len(session_aggregates) == 1
+
+
+@pytest.mark.skipif(
+ sys.version_info < (3, 3), reason="Profiling is only supported in Python >= 3.3"
+)
+@mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0)
+def test_profile_sent(
+ sentry_init,
+ capture_envelopes,
+ teardown_profiling,
+):
+ def test_app(environ, start_response):
+ start_response("200 OK", [])
+ return ["Go get the ball! Good dog!"]
+
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+ app = SentryWsgiMiddleware(test_app)
+ envelopes = capture_envelopes()
+
+ client = Client(app)
+ client.get("/")
+
+ envelopes = [envelope for envelope in envelopes]
+ assert len(envelopes) == 1
+
+ profiles = [item for item in envelopes[0].items if item.type == "profile"]
+ assert len(profiles) == 1
diff --git a/tests/test_api.py b/tests/test_api.py
new file mode 100644
index 0000000000..ef3d413444
--- /dev/null
+++ b/tests/test_api.py
@@ -0,0 +1,115 @@
+from sentry_sdk import (
+ configure_scope,
+ continue_trace,
+ get_baggage,
+ get_current_span,
+ get_traceparent,
+ start_transaction,
+)
+from sentry_sdk.hub import Hub
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+
+def test_get_current_span():
+ fake_hub = mock.MagicMock()
+ fake_hub.scope = mock.MagicMock()
+
+ fake_hub.scope.span = mock.MagicMock()
+ assert get_current_span(fake_hub) == fake_hub.scope.span
+
+ fake_hub.scope.span = None
+ assert get_current_span(fake_hub) is None
+
+
+def test_get_current_span_default_hub(sentry_init):
+ sentry_init()
+
+ assert get_current_span() is None
+
+ with configure_scope() as scope:
+ fake_span = mock.MagicMock()
+ scope.span = fake_span
+
+ assert get_current_span() == fake_span
+
+
+def test_get_current_span_default_hub_with_transaction(sentry_init):
+ sentry_init()
+
+ assert get_current_span() is None
+
+ with start_transaction() as new_transaction:
+ assert get_current_span() == new_transaction
+
+
+def test_traceparent_with_tracing_enabled(sentry_init):
+ sentry_init(traces_sample_rate=1.0)
+
+ with start_transaction() as transaction:
+ expected_traceparent = "%s-%s-1" % (
+ transaction.trace_id,
+ transaction.span_id,
+ )
+ assert get_traceparent() == expected_traceparent
+
+
+def test_traceparent_with_tracing_disabled(sentry_init):
+ sentry_init()
+
+ propagation_context = Hub.current.scope._propagation_context
+ expected_traceparent = "%s-%s" % (
+ propagation_context["trace_id"],
+ propagation_context["span_id"],
+ )
+ assert get_traceparent() == expected_traceparent
+
+
+def test_baggage_with_tracing_disabled(sentry_init):
+ sentry_init(release="1.0.0", environment="dev")
+ propagation_context = Hub.current.scope._propagation_context
+ expected_baggage = (
+ "sentry-trace_id={},sentry-environment=dev,sentry-release=1.0.0".format(
+ propagation_context["trace_id"]
+ )
+ )
+ # order not guaranteed in older python versions
+ assert sorted(get_baggage().split(",")) == sorted(expected_baggage.split(","))
+
+
+def test_baggage_with_tracing_enabled(sentry_init):
+ sentry_init(traces_sample_rate=1.0, release="1.0.0", environment="dev")
+ with start_transaction() as transaction:
+ expected_baggage = "sentry-trace_id={},sentry-environment=dev,sentry-release=1.0.0,sentry-sample_rate=1.0".format(
+ transaction.trace_id
+ )
+ # order not guaranteed in older python versions
+ assert sorted(get_baggage().split(",")) == sorted(expected_baggage.split(","))
+
+
+def test_continue_trace(sentry_init):
+ sentry_init()
+
+ trace_id = "471a43a4192642f0b136d5159a501701"
+ parent_span_id = "6e8f22c393e68f19"
+ parent_sampled = 1
+ transaction = continue_trace(
+ {
+ "sentry-trace": "{}-{}-{}".format(trace_id, parent_span_id, parent_sampled),
+ "baggage": "sentry-trace_id=566e3688a61d4bc888951642d6f14a19",
+ },
+ name="some name",
+ )
+ with start_transaction(transaction):
+ assert transaction.name == "some name"
+
+ propagation_context = Hub.current.scope._propagation_context
+ assert propagation_context["trace_id"] == transaction.trace_id == trace_id
+ assert propagation_context["parent_span_id"] == parent_span_id
+ assert propagation_context["parent_sampled"] == parent_sampled
+ assert propagation_context["dynamic_sampling_context"] == {
+ "trace_id": "566e3688a61d4bc888951642d6f14a19"
+ }
diff --git a/tests/test_basics.py b/tests/test_basics.py
index 7991a58f75..751b0a617b 100644
--- a/tests/test_basics.py
+++ b/tests/test_basics.py
@@ -1,6 +1,7 @@
+import logging
import os
import sys
-import logging
+import time
import pytest
@@ -16,7 +17,6 @@
last_event_id,
Hub,
)
-
from sentry_sdk._compat import reraise
from sentry_sdk.integrations import _AUTO_ENABLING_INTEGRATIONS
from sentry_sdk.integrations.logging import LoggingIntegration
@@ -24,6 +24,8 @@
add_global_event_processor,
global_event_processors,
)
+from sentry_sdk.utils import get_sdk_name
+from sentry_sdk.tracing_utils import has_tracing_enabled
def test_processors(sentry_init, capture_events):
@@ -50,16 +52,22 @@ def error_processor(event, exc_info):
def test_auto_enabling_integrations_catches_import_error(sentry_init, caplog):
caplog.set_level(logging.DEBUG)
+ REDIS = 12 # noqa: N806
sentry_init(auto_enabling_integrations=True, debug=True)
for import_string in _AUTO_ENABLING_INTEGRATIONS:
+ # Ignore redis in the test case, because it is installed as a
+ # dependency for running tests, and therefore always enabled.
+ if _AUTO_ENABLING_INTEGRATIONS[REDIS] == import_string:
+ continue
+
assert any(
record.message.startswith(
"Did not import default integration {}:".format(import_string)
)
for record in caplog.records
- )
+ ), "Problem with checking auto enabling {}".format(import_string)
def test_event_id(sentry_init, capture_events):
@@ -84,7 +92,93 @@ def test_event_id(sentry_init, capture_events):
assert Hub.current.last_event_id() == event_id
-def test_option_callback(sentry_init, capture_events, monkeypatch):
+def test_generic_mechanism(sentry_init, capture_events):
+ sentry_init()
+ events = capture_events()
+
+ try:
+ raise ValueError("aha!")
+ except Exception:
+ capture_exception()
+
+ (event,) = events
+ assert event["exception"]["values"][0]["mechanism"]["type"] == "generic"
+ assert event["exception"]["values"][0]["mechanism"]["handled"]
+
+
+def test_option_before_send(sentry_init, capture_events):
+ def before_send(event, hint):
+ event["extra"] = {"before_send_called": True}
+ return event
+
+ def do_this():
+ try:
+ raise ValueError("aha!")
+ except Exception:
+ capture_exception()
+
+ sentry_init(before_send=before_send)
+ events = capture_events()
+
+ do_this()
+
+ (event,) = events
+ assert event["extra"] == {"before_send_called": True}
+
+
+def test_option_before_send_discard(sentry_init, capture_events):
+ def before_send_discard(event, hint):
+ return None
+
+ def do_this():
+ try:
+ raise ValueError("aha!")
+ except Exception:
+ capture_exception()
+
+ sentry_init(before_send=before_send_discard)
+ events = capture_events()
+
+ do_this()
+
+ assert len(events) == 0
+
+
+def test_option_before_send_transaction(sentry_init, capture_events):
+ def before_send_transaction(event, hint):
+ assert event["type"] == "transaction"
+ event["extra"] = {"before_send_transaction_called": True}
+ return event
+
+ sentry_init(
+ before_send_transaction=before_send_transaction,
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+ transaction = start_transaction(name="foo")
+ transaction.finish()
+
+ (event,) = events
+ assert event["transaction"] == "foo"
+ assert event["extra"] == {"before_send_transaction_called": True}
+
+
+def test_option_before_send_transaction_discard(sentry_init, capture_events):
+ def before_send_transaction_discard(event, hint):
+ return None
+
+ sentry_init(
+ before_send_transaction=before_send_transaction_discard,
+ traces_sample_rate=1.0,
+ )
+ events = capture_events()
+ transaction = start_transaction(name="foo")
+ transaction.finish()
+
+ assert len(events) == 0
+
+
+def test_option_before_breadcrumb(sentry_init, capture_events, monkeypatch):
drop_events = False
drop_breadcrumbs = False
reports = []
@@ -136,6 +230,32 @@ def do_this():
assert crumb["type"] == "default"
+@pytest.mark.parametrize(
+ "enable_tracing, traces_sample_rate, tracing_enabled, updated_traces_sample_rate",
+ [
+ (None, None, False, None),
+ (False, 0.0, False, 0.0),
+ (False, 1.0, False, 1.0),
+ (None, 1.0, True, 1.0),
+ (True, 1.0, True, 1.0),
+ (None, 0.0, True, 0.0), # We use this as - it's configured but turned off
+ (True, 0.0, True, 0.0), # We use this as - it's configured but turned off
+ (True, None, True, 1.0),
+ ],
+)
+def test_option_enable_tracing(
+ sentry_init,
+ enable_tracing,
+ traces_sample_rate,
+ tracing_enabled,
+ updated_traces_sample_rate,
+):
+ sentry_init(enable_tracing=enable_tracing, traces_sample_rate=traces_sample_rate)
+ options = Hub.current.client.options
+ assert has_tracing_enabled(options) is tracing_enabled
+ assert options["traces_sample_rate"] == updated_traces_sample_rate
+
+
def test_breadcrumb_arguments(sentry_init, capture_events):
assert_hint = {"bar": 42}
@@ -431,3 +551,136 @@ def foo(event, hint):
assert reports == [("event_processor", "error"), ("event_processor", "transaction")]
global_event_processors.pop()
+
+
+@pytest.mark.parametrize(
+ "installed_integrations, expected_name",
+ [
+ # integrations with own name
+ (["django"], "sentry.python.django"),
+ (["flask"], "sentry.python.flask"),
+ (["fastapi"], "sentry.python.fastapi"),
+ (["bottle"], "sentry.python.bottle"),
+ (["falcon"], "sentry.python.falcon"),
+ (["quart"], "sentry.python.quart"),
+ (["sanic"], "sentry.python.sanic"),
+ (["starlette"], "sentry.python.starlette"),
+ (["chalice"], "sentry.python.chalice"),
+ (["serverless"], "sentry.python.serverless"),
+ (["pyramid"], "sentry.python.pyramid"),
+ (["tornado"], "sentry.python.tornado"),
+ (["aiohttp"], "sentry.python.aiohttp"),
+ (["aws_lambda"], "sentry.python.aws_lambda"),
+ (["gcp"], "sentry.python.gcp"),
+ (["beam"], "sentry.python.beam"),
+ (["asgi"], "sentry.python.asgi"),
+ (["wsgi"], "sentry.python.wsgi"),
+ # integrations without name
+ (["argv"], "sentry.python"),
+ (["atexit"], "sentry.python"),
+ (["boto3"], "sentry.python"),
+ (["celery"], "sentry.python"),
+ (["dedupe"], "sentry.python"),
+ (["excepthook"], "sentry.python"),
+ (["executing"], "sentry.python"),
+ (["modules"], "sentry.python"),
+ (["pure_eval"], "sentry.python"),
+ (["redis"], "sentry.python"),
+ (["rq"], "sentry.python"),
+ (["sqlalchemy"], "sentry.python"),
+ (["stdlib"], "sentry.python"),
+ (["threading"], "sentry.python"),
+ (["trytond"], "sentry.python"),
+ (["logging"], "sentry.python"),
+ (["gnu_backtrace"], "sentry.python"),
+ (["httpx"], "sentry.python"),
+ # precedence of frameworks
+ (["flask", "django", "celery"], "sentry.python.django"),
+ (["fastapi", "flask", "redis"], "sentry.python.flask"),
+ (["bottle", "fastapi", "httpx"], "sentry.python.fastapi"),
+ (["falcon", "bottle", "logging"], "sentry.python.bottle"),
+ (["quart", "falcon", "gnu_backtrace"], "sentry.python.falcon"),
+ (["sanic", "quart", "sqlalchemy"], "sentry.python.quart"),
+ (["starlette", "sanic", "rq"], "sentry.python.sanic"),
+ (["chalice", "starlette", "modules"], "sentry.python.starlette"),
+ (["serverless", "chalice", "pure_eval"], "sentry.python.chalice"),
+ (["pyramid", "serverless", "modules"], "sentry.python.serverless"),
+ (["tornado", "pyramid", "executing"], "sentry.python.pyramid"),
+ (["aiohttp", "tornado", "dedupe"], "sentry.python.tornado"),
+ (["aws_lambda", "aiohttp", "boto3"], "sentry.python.aiohttp"),
+ (["gcp", "aws_lambda", "atexit"], "sentry.python.aws_lambda"),
+ (["beam", "gcp", "argv"], "sentry.python.gcp"),
+ (["asgi", "beam", "stdtlib"], "sentry.python.beam"),
+ (["wsgi", "asgi", "boto3"], "sentry.python.asgi"),
+ (["wsgi", "celery", "redis"], "sentry.python.wsgi"),
+ ],
+)
+def test_get_sdk_name(installed_integrations, expected_name):
+ assert get_sdk_name(installed_integrations) == expected_name
+
+
+def _hello_world(word):
+ return "Hello, {}".format(word)
+
+
+def test_functions_to_trace(sentry_init, capture_events):
+ functions_to_trace = [
+ {"qualified_name": "tests.test_basics._hello_world"},
+ {"qualified_name": "time.sleep"},
+ ]
+
+ sentry_init(
+ traces_sample_rate=1.0,
+ functions_to_trace=functions_to_trace,
+ )
+
+ events = capture_events()
+
+ with start_transaction(name="something"):
+ time.sleep(0)
+
+ for word in ["World", "You"]:
+ _hello_world(word)
+
+ assert len(events) == 1
+
+ (event,) = events
+
+ assert len(event["spans"]) == 3
+ assert event["spans"][0]["description"] == "time.sleep"
+ assert event["spans"][1]["description"] == "tests.test_basics._hello_world"
+ assert event["spans"][2]["description"] == "tests.test_basics._hello_world"
+
+
+class WorldGreeter:
+ def __init__(self, word):
+ self.word = word
+
+ def greet(self, new_word=None):
+ return "Hello, {}".format(new_word if new_word else self.word)
+
+
+def test_functions_to_trace_with_class(sentry_init, capture_events):
+ functions_to_trace = [
+ {"qualified_name": "tests.test_basics.WorldGreeter.greet"},
+ ]
+
+ sentry_init(
+ traces_sample_rate=1.0,
+ functions_to_trace=functions_to_trace,
+ )
+
+ events = capture_events()
+
+ with start_transaction(name="something"):
+ wg = WorldGreeter("World")
+ wg.greet()
+ wg.greet("You")
+
+ assert len(events) == 1
+
+ (event,) = events
+
+ assert len(event["spans"]) == 2
+ assert event["spans"][0]["description"] == "tests.test_basics.WorldGreeter.greet"
+ assert event["spans"][1]["description"] == "tests.test_basics.WorldGreeter.greet"
diff --git a/tests/test_client.py b/tests/test_client.py
index 9137f4115a..835a75e6fa 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -22,9 +22,15 @@
from sentry_sdk.transport import Transport
from sentry_sdk._compat import reraise, text_type, PY2
from sentry_sdk.utils import HAS_CHAINED_EXCEPTIONS
+from sentry_sdk.utils import logger
from sentry_sdk.serializer import MAX_DATABAG_BREADTH
from sentry_sdk.consts import DEFAULT_MAX_BREADCRUMBS
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
if PY2:
# Importing ABCs from collections is deprecated, and will stop working in 3.8
# https://github.com/python/cpython/blob/master/Lib/collections/__init__.py#L49
@@ -35,13 +41,13 @@
from collections.abc import Mapping
-class EventCaptured(Exception):
+class EventCapturedError(Exception):
pass
class _TestTransport(Transport):
def capture_event(self, event):
- raise EventCaptured(event)
+ raise EventCapturedError(event)
def test_transport_option(monkeypatch):
@@ -227,6 +233,16 @@ def test_transport_option(monkeypatch):
"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"},
+ },
],
)
def test_proxy(monkeypatch, testcase):
@@ -241,12 +257,17 @@ def test_proxy(monkeypatch, testcase):
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)
if testcase["expected_proxy_scheme"] is None:
assert client.transport._pool.proxy is None
else:
assert client.transport._pool.proxy.scheme == testcase["expected_proxy_scheme"]
+ if testcase.get("arg_proxy_headers") is not None:
+ assert client.transport._pool.proxy_headers == testcase["arg_proxy_headers"]
+
def test_simple_transport(sentry_init):
events = []
@@ -273,11 +294,51 @@ def e(exc):
e(ZeroDivisionError())
e(MyDivisionError())
- pytest.raises(EventCaptured, lambda: e(ValueError()))
+ pytest.raises(EventCapturedError, lambda: e(ValueError()))
+
+
+def test_with_locals_deprecation_enabled(sentry_init):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ sentry_init(with_locals=True)
+
+ client = Hub.current.client
+ assert "with_locals" not in client.options
+ assert "include_local_variables" in client.options
+ assert client.options["include_local_variables"]
+
+ fake_warning.assert_called_once_with(
+ "Deprecated: The option 'with_locals' was renamed to 'include_local_variables'. Please use 'include_local_variables'. The option 'with_locals' will be removed in the future."
+ )
+
+
+def test_with_locals_deprecation_disabled(sentry_init):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ sentry_init(with_locals=False)
+
+ client = Hub.current.client
+ assert "with_locals" not in client.options
+ assert "include_local_variables" in client.options
+ assert not client.options["include_local_variables"]
+
+ fake_warning.assert_called_once_with(
+ "Deprecated: The option 'with_locals' was renamed to 'include_local_variables'. Please use 'include_local_variables'. The option 'with_locals' will be removed in the future."
+ )
+
+
+def test_include_local_variables_deprecation(sentry_init):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ sentry_init(include_local_variables=False)
+
+ client = Hub.current.client
+ assert "with_locals" not in client.options
+ assert "include_local_variables" in client.options
+ assert not client.options["include_local_variables"]
+ fake_warning.assert_not_called()
-def test_with_locals_enabled(sentry_init, capture_events):
- sentry_init(with_locals=True)
+
+def test_include_local_variables_enabled(sentry_init, capture_events):
+ sentry_init(include_local_variables=True)
events = capture_events()
try:
1 / 0
@@ -292,8 +353,8 @@ def test_with_locals_enabled(sentry_init, capture_events):
)
-def test_with_locals_disabled(sentry_init, capture_events):
- sentry_init(with_locals=False)
+def test_include_local_variables_disabled(sentry_init, capture_events):
+ sentry_init(include_local_variables=False)
events = capture_events()
try:
1 / 0
@@ -308,6 +369,38 @@ def test_with_locals_disabled(sentry_init, capture_events):
)
+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)
@@ -357,7 +450,7 @@ def bar():
def test_attach_stacktrace_enabled_no_locals(sentry_init, capture_events):
- sentry_init(attach_stacktrace=True, with_locals=False)
+ sentry_init(attach_stacktrace=True, include_local_variables=False)
events = capture_events()
def foo():
@@ -386,7 +479,6 @@ def test_attach_stacktrace_in_app(sentry_init, capture_events):
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)
- assert any(f["in_app"] for f in frames)
def test_attach_stacktrace_disabled(sentry_init, capture_events):
@@ -400,8 +492,8 @@ def test_attach_stacktrace_disabled(sentry_init, capture_events):
def test_capture_event_works(sentry_init):
sentry_init(transport=_TestTransport())
- pytest.raises(EventCaptured, lambda: capture_event({}))
- pytest.raises(EventCaptured, lambda: capture_event({}))
+ pytest.raises(EventCapturedError, lambda: capture_event({}))
+ pytest.raises(EventCapturedError, lambda: capture_event({}))
@pytest.mark.parametrize("num_messages", [10, 20])
@@ -496,7 +588,9 @@ def test_scope_initialized_before_client(sentry_init, capture_events):
def test_weird_chars(sentry_init, capture_events):
sentry_init()
events = capture_events()
+ # fmt: off
capture_message(u"föö".encode("latin1"))
+ # fmt: on
(event,) = events
assert json.loads(json.dumps(event)) == event
@@ -742,10 +836,10 @@ def test_errno_errors(sentry_init, capture_events):
sentry_init()
events = capture_events()
- class Foo(Exception):
+ class FooError(Exception):
errno = 69
- capture_exception(Foo())
+ capture_exception(FooError())
(event,) = events
@@ -812,7 +906,7 @@ def __repr__(self):
"dsn",
[
"http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2",
- u"http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2",
+ "http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2",
],
)
def test_init_string_types(dsn, sentry_init):
@@ -828,7 +922,7 @@ def test_init_string_types(dsn, sentry_init):
)
-def test_envelope_types():
+def test_sending_events_with_tracing():
"""
Tests for calling the right transport method (capture_event vs
capture_envelope) from the SDK client for different data types.
@@ -844,8 +938,56 @@ def capture_envelope(self, envelope):
def capture_event(self, event):
events.append(event)
- with Hub(Client(traces_sample_rate=1.0, transport=CustomTransport())):
- event_id = capture_message("hello")
+ with Hub(Client(enable_tracing=True, transport=CustomTransport())):
+ try:
+ 1 / 0
+ except Exception:
+ event_id = capture_exception()
+
+ # Assert error events get passed in via capture_envelope
+ assert not events
+ envelope = envelopes.pop()
+ (item,) = envelope.items
+ assert item.data_category == "error"
+ assert item.headers.get("type") == "event"
+ assert item.get_event()["event_id"] == event_id
+
+ with start_transaction(name="foo"):
+ pass
+
+ # Assert transactions get passed in via capture_envelope
+ assert not events
+ envelope = envelopes.pop()
+
+ (item,) = envelope.items
+ assert item.data_category == "transaction"
+ assert item.headers.get("type") == "transaction"
+
+ assert not envelopes
+ assert not events
+
+
+def test_sending_events_with_no_tracing():
+ """
+ Tests for calling the right transport method (capture_event vs
+ capture_envelope) from the SDK client for different data types.
+ """
+
+ envelopes = []
+ events = []
+
+ class CustomTransport(Transport):
+ def capture_envelope(self, envelope):
+ envelopes.append(envelope)
+
+ def capture_event(self, event):
+ events.append(event)
+
+ with Hub(Client(enable_tracing=False, transport=CustomTransport())):
+ try:
+ 1 / 0
+ except Exception:
+ event_id = capture_exception()
# Assert error events get passed in via capture_event
assert not envelopes
@@ -859,11 +1001,7 @@ def capture_event(self, event):
# Assert transactions get passed in via capture_envelope
assert not events
- envelope = envelopes.pop()
-
- (item,) = envelope.items
- assert item.data_category == "transaction"
- assert item.headers.get("type") == "transaction"
+ assert not envelopes
assert not envelopes
assert not events
@@ -885,3 +1023,9 @@ def test_max_breadcrumbs_option(
capture_message("dogs are great")
assert len(events[0]["breadcrumbs"]["values"]) == expected_breadcrumbs
+
+
+def test_multiple_positional_args(sentry_init):
+ with pytest.raises(TypeError) as exinfo:
+ sentry_init(1, None)
+ assert "Only single positional argument is expected" in str(exinfo.value)
diff --git a/tests/test_conftest.py b/tests/test_conftest.py
index 8a2d4cee24..1b006ed12e 100644
--- a/tests/test_conftest.py
+++ b/tests/test_conftest.py
@@ -24,7 +24,6 @@
def test_string_containing(
test_string, expected_result, StringContaining # noqa: N803
):
-
assert (test_string == StringContaining("dogs")) is expected_result
@@ -49,7 +48,6 @@ def test_string_containing(
def test_dictionary_containing(
test_dict, expected_result, DictionaryContaining # noqa: N803
):
-
assert (
test_dict == DictionaryContaining({"dogs": "yes", "cats": "maybe"})
) is expected_result
@@ -98,7 +96,6 @@ def test_object_described_by(
attrs_only_result,
ObjectDescribedBy, # noqa: N803
):
-
assert (
test_obj == ObjectDescribedBy(type=Dog, attrs={"name": "Maisey", "age": 7})
) is type_and_attrs_result
diff --git a/tests/test_crons.py b/tests/test_crons.py
new file mode 100644
index 0000000000..7688ac8a72
--- /dev/null
+++ b/tests/test_crons.py
@@ -0,0 +1,151 @@
+import pytest
+import uuid
+
+import sentry_sdk
+from sentry_sdk.crons import capture_checkin
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+
+@sentry_sdk.monitor(monitor_slug="abc123")
+def _hello_world(name):
+ return "Hello, {}".format(name)
+
+
+@sentry_sdk.monitor(monitor_slug="def456")
+def _break_world(name):
+ 1 / 0
+ return "Hello, {}".format(name)
+
+
+def test_decorator(sentry_init):
+ sentry_init()
+
+ with mock.patch(
+ "sentry_sdk.crons.decorator.capture_checkin"
+ ) as fake_capture_checking:
+ result = _hello_world("Grace")
+ assert result == "Hello, Grace"
+
+ # Check for initial checkin
+ fake_capture_checking.assert_has_calls(
+ [
+ mock.call(monitor_slug="abc123", status="in_progress"),
+ ]
+ )
+
+ # Check for final checkin
+ assert fake_capture_checking.call_args[1]["monitor_slug"] == "abc123"
+ assert fake_capture_checking.call_args[1]["status"] == "ok"
+ assert fake_capture_checking.call_args[1]["duration"]
+ assert fake_capture_checking.call_args[1]["check_in_id"]
+
+
+def test_decorator_error(sentry_init):
+ sentry_init()
+
+ with mock.patch(
+ "sentry_sdk.crons.decorator.capture_checkin"
+ ) as fake_capture_checking:
+ with pytest.raises(Exception):
+ result = _break_world("Grace")
+
+ assert "result" not in locals()
+
+ # Check for initial checkin
+ fake_capture_checking.assert_has_calls(
+ [
+ mock.call(monitor_slug="def456", status="in_progress"),
+ ]
+ )
+
+ # Check for final checkin
+ assert fake_capture_checking.call_args[1]["monitor_slug"] == "def456"
+ assert fake_capture_checking.call_args[1]["status"] == "error"
+ assert fake_capture_checking.call_args[1]["duration"]
+ assert fake_capture_checking.call_args[1]["check_in_id"]
+
+
+def test_capture_checkin_simple(sentry_init):
+ sentry_init()
+
+ check_in_id = capture_checkin(
+ monitor_slug="abc123",
+ check_in_id="112233",
+ status=None,
+ duration=None,
+ )
+ assert check_in_id == "112233"
+
+
+def test_capture_checkin_new_id(sentry_init):
+ sentry_init()
+
+ with mock.patch("uuid.uuid4") as mock_uuid:
+ mock_uuid.return_value = uuid.UUID("a8098c1a-f86e-11da-bd1a-00112444be1e")
+ check_in_id = capture_checkin(
+ monitor_slug="abc123",
+ check_in_id=None,
+ status=None,
+ duration=None,
+ )
+
+ assert check_in_id == "a8098c1af86e11dabd1a00112444be1e"
+
+
+def test_end_to_end(sentry_init, capture_envelopes):
+ sentry_init()
+ envelopes = capture_envelopes()
+
+ capture_checkin(
+ monitor_slug="abc123",
+ check_in_id="112233",
+ duration=123,
+ status="ok",
+ )
+
+ check_in = envelopes[0].items[0].payload.json
+
+ # Check for final checkin
+ assert check_in["check_in_id"] == "112233"
+ assert check_in["monitor_slug"] == "abc123"
+ assert check_in["status"] == "ok"
+ assert check_in["duration"] == 123
+
+
+def test_monitor_config(sentry_init, capture_envelopes):
+ sentry_init()
+ envelopes = capture_envelopes()
+
+ monitor_config = {
+ "schedule": {"type": "crontab", "value": "0 0 * * *"},
+ }
+
+ capture_checkin(monitor_slug="abc123", monitor_config=monitor_config)
+ check_in = envelopes[0].items[0].payload.json
+
+ # Check for final checkin
+ assert check_in["monitor_slug"] == "abc123"
+ assert check_in["monitor_config"] == monitor_config
+
+ # Without passing a monitor_config the field is not in the checkin
+ capture_checkin(monitor_slug="abc123")
+ check_in = envelopes[1].items[0].payload.json
+
+ assert check_in["monitor_slug"] == "abc123"
+ assert "monitor_config" not in check_in
+
+
+def test_capture_checkin_sdk_not_initialized():
+ # Tests that the capture_checkin does not raise an error when Sentry SDK is not initialized.
+ # sentry_init() is intentionally omitted.
+ check_in_id = capture_checkin(
+ monitor_slug="abc123",
+ check_in_id="112233",
+ status=None,
+ duration=None,
+ )
+ assert check_in_id == "112233"
diff --git a/tests/test_envelope.py b/tests/test_envelope.py
index 582fe6236f..a8b3ac11f4 100644
--- a/tests/test_envelope.py
+++ b/tests/test_envelope.py
@@ -1,16 +1,8 @@
from sentry_sdk.envelope import Envelope
from sentry_sdk.session import Session
from sentry_sdk import capture_event
-from sentry_sdk.tracing_utils import compute_tracestate_value
import sentry_sdk.client
-import pytest
-
-try:
- from unittest import mock # python 3.3 and above
-except ImportError:
- import mock # python < 3.3
-
def generate_transaction_item():
return {
@@ -26,16 +18,15 @@ def generate_transaction_item():
"parent_span_id": None,
"description": "",
"op": "greeting.sniff",
- "tracestate": compute_tracestate_value(
- {
- "trace_id": "12312012123120121231201212312012",
- "environment": "dogpark",
- "release": "off.leash.park",
- "public_key": "dogsarebadatkeepingsecrets",
- "user": {"id": 12312013, "segment": "bigs"},
- "transaction": "/interactions/other-dogs/new-dog",
- }
- ),
+ "dynamic_sampling_context": {
+ "trace_id": "12312012123120121231201212312012",
+ "sample_rate": "1.0",
+ "environment": "dogpark",
+ "release": "off.leash.park",
+ "public_key": "dogsarebadatkeepingsecrets",
+ "user_segment": "bigs",
+ "transaction": "/interactions/other-dogs/new-dog",
+ },
}
},
"spans": [
@@ -88,25 +79,16 @@ def test_add_and_get_session():
assert item.payload.json == expected.to_json()
-# TODO (kmclb) remove this parameterization once tracestate is a real feature
-@pytest.mark.parametrize("tracestate_enabled", [True, False])
-def test_envelope_headers(
- sentry_init, capture_envelopes, monkeypatch, tracestate_enabled
-):
+def test_envelope_headers(sentry_init, capture_envelopes, monkeypatch):
monkeypatch.setattr(
sentry_sdk.client,
"format_timestamp",
lambda x: "2012-11-21T12:31:12.415908Z",
)
- monkeypatch.setattr(
- sentry_sdk.client,
- "has_tracestate_enabled",
- mock.Mock(return_value=tracestate_enabled),
- )
-
sentry_init(
dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
+ traces_sample_rate=1.0,
)
envelopes = capture_envelopes()
@@ -114,24 +96,19 @@ def test_envelope_headers(
assert len(envelopes) == 1
- if tracestate_enabled:
- assert envelopes[0].headers == {
- "event_id": "15210411201320122115110420122013",
- "sent_at": "2012-11-21T12:31:12.415908Z",
- "trace": {
- "trace_id": "12312012123120121231201212312012",
- "environment": "dogpark",
- "release": "off.leash.park",
- "public_key": "dogsarebadatkeepingsecrets",
- "user": {"id": 12312013, "segment": "bigs"},
- "transaction": "/interactions/other-dogs/new-dog",
- },
- }
- else:
- assert envelopes[0].headers == {
- "event_id": "15210411201320122115110420122013",
- "sent_at": "2012-11-21T12:31:12.415908Z",
- }
+ assert envelopes[0].headers == {
+ "event_id": "15210411201320122115110420122013",
+ "sent_at": "2012-11-21T12:31:12.415908Z",
+ "trace": {
+ "trace_id": "12312012123120121231201212312012",
+ "sample_rate": "1.0",
+ "environment": "dogpark",
+ "release": "off.leash.park",
+ "public_key": "dogsarebadatkeepingsecrets",
+ "user_segment": "bigs",
+ "transaction": "/interactions/other-dogs/new-dog",
+ },
+ }
def test_envelope_with_sized_items():
@@ -141,15 +118,15 @@ def test_envelope_with_sized_items():
"""
envelope_raw = (
b'{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n'
- + b'{"type":"type1","length":4 }\n1234\n'
- + b'{"type":"type2","length":4 }\nabcd\n'
- + b'{"type":"type3","length":0}\n\n'
- + b'{"type":"type4","length":4 }\nab12\n'
+ b'{"type":"type1","length":4 }\n1234\n'
+ b'{"type":"type2","length":4 }\nabcd\n'
+ b'{"type":"type3","length":0}\n\n'
+ b'{"type":"type4","length":4 }\nab12\n'
)
envelope_raw_eof_terminated = envelope_raw[:-1]
- for envelope_raw in (envelope_raw, envelope_raw_eof_terminated):
- actual = Envelope.deserialize(envelope_raw)
+ for envelope in (envelope_raw, envelope_raw_eof_terminated):
+ actual = Envelope.deserialize(envelope)
items = [item for item in actual]
@@ -177,15 +154,15 @@ def test_envelope_with_implicitly_sized_items():
"""
envelope_raw = (
b'{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n'
- + b'{"type":"type1"}\n1234\n'
- + b'{"type":"type2"}\nabcd\n'
- + b'{"type":"type3"}\n\n'
- + b'{"type":"type4"}\nab12\n'
+ b'{"type":"type1"}\n1234\n'
+ b'{"type":"type2"}\nabcd\n'
+ b'{"type":"type3"}\n\n'
+ b'{"type":"type4"}\nab12\n'
)
envelope_raw_eof_terminated = envelope_raw[:-1]
- for envelope_raw in (envelope_raw, envelope_raw_eof_terminated):
- actual = Envelope.deserialize(envelope_raw)
+ for envelope in (envelope_raw, envelope_raw_eof_terminated):
+ actual = Envelope.deserialize(envelope)
assert actual.headers["event_id"] == "9ec79c33ec9942ab8353589fcb2e04dc"
items = [item for item in actual]
diff --git a/tests/test_exceptiongroup.py b/tests/test_exceptiongroup.py
new file mode 100644
index 0000000000..8d4734762a
--- /dev/null
+++ b/tests/test_exceptiongroup.py
@@ -0,0 +1,304 @@
+import sys
+import pytest
+
+from sentry_sdk.utils import event_from_exception
+
+
+try:
+ # Python 3.11
+ from builtins import ExceptionGroup # type: ignore
+except ImportError:
+ # Python 3.10 and below
+ ExceptionGroup = None
+
+
+minimum_python_311 = pytest.mark.skipif(
+ sys.version_info < (3, 11), reason="ExceptionGroup tests need Python >= 3.11"
+)
+
+
+@minimum_python_311
+def test_exceptiongroup():
+ exception_group = None
+
+ try:
+ try:
+ raise RuntimeError("something")
+ except RuntimeError:
+ raise ExceptionGroup(
+ "nested",
+ [
+ ValueError(654),
+ ExceptionGroup(
+ "imports",
+ [
+ ImportError("no_such_module"),
+ ModuleNotFoundError("another_module"),
+ ],
+ ),
+ TypeError("int"),
+ ],
+ )
+ except ExceptionGroup as e:
+ exception_group = e
+
+ (event, _) = event_from_exception(
+ exception_group,
+ client_options={
+ "include_local_variables": True,
+ "include_source_context": True,
+ },
+ mechanism={"type": "test_suite", "handled": False},
+ )
+
+ values = event["exception"]["values"]
+
+ # For this test the stacktrace and the module is not important
+ for x in values:
+ if "stacktrace" in x:
+ del x["stacktrace"]
+ if "module" in x:
+ del x["module"]
+
+ expected_values = [
+ {
+ "mechanism": {
+ "exception_id": 6,
+ "handled": False,
+ "parent_id": 0,
+ "source": "exceptions[2]",
+ "type": "chained",
+ },
+ "type": "TypeError",
+ "value": "int",
+ },
+ {
+ "mechanism": {
+ "exception_id": 5,
+ "handled": False,
+ "parent_id": 3,
+ "source": "exceptions[1]",
+ "type": "chained",
+ },
+ "type": "ModuleNotFoundError",
+ "value": "another_module",
+ },
+ {
+ "mechanism": {
+ "exception_id": 4,
+ "handled": False,
+ "parent_id": 3,
+ "source": "exceptions[0]",
+ "type": "chained",
+ },
+ "type": "ImportError",
+ "value": "no_such_module",
+ },
+ {
+ "mechanism": {
+ "exception_id": 3,
+ "handled": False,
+ "is_exception_group": True,
+ "parent_id": 0,
+ "source": "exceptions[1]",
+ "type": "chained",
+ },
+ "type": "ExceptionGroup",
+ "value": "imports",
+ },
+ {
+ "mechanism": {
+ "exception_id": 2,
+ "handled": False,
+ "parent_id": 0,
+ "source": "exceptions[0]",
+ "type": "chained",
+ },
+ "type": "ValueError",
+ "value": "654",
+ },
+ {
+ "mechanism": {
+ "exception_id": 1,
+ "handled": False,
+ "parent_id": 0,
+ "source": "__context__",
+ "type": "chained",
+ },
+ "type": "RuntimeError",
+ "value": "something",
+ },
+ {
+ "mechanism": {
+ "exception_id": 0,
+ "handled": False,
+ "is_exception_group": True,
+ "type": "test_suite",
+ },
+ "type": "ExceptionGroup",
+ "value": "nested",
+ },
+ ]
+
+ assert values == expected_values
+
+
+@minimum_python_311
+def test_exceptiongroup_simple():
+ exception_group = None
+
+ try:
+ raise ExceptionGroup(
+ "simple",
+ [
+ RuntimeError("something strange's going on"),
+ ],
+ )
+ except ExceptionGroup as e:
+ exception_group = e
+
+ (event, _) = event_from_exception(
+ exception_group,
+ client_options={
+ "include_local_variables": True,
+ "include_source_context": True,
+ },
+ mechanism={"type": "test_suite", "handled": False},
+ )
+
+ exception_values = event["exception"]["values"]
+
+ assert len(exception_values) == 2
+
+ assert exception_values[0]["type"] == "RuntimeError"
+ assert exception_values[0]["value"] == "something strange's going on"
+ assert exception_values[0]["mechanism"] == {
+ "type": "chained",
+ "handled": False,
+ "exception_id": 1,
+ "source": "exceptions[0]",
+ "parent_id": 0,
+ }
+
+ assert exception_values[1]["type"] == "ExceptionGroup"
+ assert exception_values[1]["value"] == "simple"
+ assert exception_values[1]["mechanism"] == {
+ "type": "test_suite",
+ "handled": False,
+ "exception_id": 0,
+ "is_exception_group": True,
+ }
+ frame = exception_values[1]["stacktrace"]["frames"][0]
+ assert frame["module"] == "tests.test_exceptiongroup"
+ assert frame["lineno"] == 151
+ assert frame["context_line"] == " raise ExceptionGroup("
+
+
+@minimum_python_311
+def test_exception_chain_cause():
+ exception_chain_cause = ValueError("Exception with cause")
+ exception_chain_cause.__context__ = TypeError("Exception in __context__")
+ exception_chain_cause.__cause__ = TypeError(
+ "Exception in __cause__"
+ ) # this implicitly sets exception_chain_cause.__suppress_context__=True
+
+ (event, _) = event_from_exception(
+ exception_chain_cause,
+ client_options={
+ "include_local_variables": True,
+ "include_source_context": True,
+ },
+ mechanism={"type": "test_suite", "handled": False},
+ )
+
+ expected_exception_values = [
+ {
+ "mechanism": {
+ "handled": False,
+ "type": "test_suite",
+ },
+ "module": None,
+ "type": "TypeError",
+ "value": "Exception in __cause__",
+ },
+ {
+ "mechanism": {
+ "handled": False,
+ "type": "test_suite",
+ },
+ "module": None,
+ "type": "ValueError",
+ "value": "Exception with cause",
+ },
+ ]
+
+ exception_values = event["exception"]["values"]
+ assert exception_values == expected_exception_values
+
+
+@minimum_python_311
+def test_exception_chain_context():
+ exception_chain_context = ValueError("Exception with context")
+ exception_chain_context.__context__ = TypeError("Exception in __context__")
+
+ (event, _) = event_from_exception(
+ exception_chain_context,
+ client_options={
+ "include_local_variables": True,
+ "include_source_context": True,
+ },
+ mechanism={"type": "test_suite", "handled": False},
+ )
+
+ expected_exception_values = [
+ {
+ "mechanism": {
+ "handled": False,
+ "type": "test_suite",
+ },
+ "module": None,
+ "type": "TypeError",
+ "value": "Exception in __context__",
+ },
+ {
+ "mechanism": {
+ "handled": False,
+ "type": "test_suite",
+ },
+ "module": None,
+ "type": "ValueError",
+ "value": "Exception with context",
+ },
+ ]
+
+ exception_values = event["exception"]["values"]
+ assert exception_values == expected_exception_values
+
+
+@minimum_python_311
+def test_simple_exception():
+ simple_excpetion = ValueError("A simple exception")
+
+ (event, _) = event_from_exception(
+ simple_excpetion,
+ client_options={
+ "include_local_variables": True,
+ "include_source_context": True,
+ },
+ mechanism={"type": "test_suite", "handled": False},
+ )
+
+ expected_exception_values = [
+ {
+ "mechanism": {
+ "handled": False,
+ "type": "test_suite",
+ },
+ "module": None,
+ "type": "ValueError",
+ "value": "A simple exception",
+ },
+ ]
+
+ exception_values = event["exception"]["values"]
+ assert exception_values == expected_exception_values
diff --git a/tests/test_lru_cache.py b/tests/test_lru_cache.py
new file mode 100644
index 0000000000..5343e76169
--- /dev/null
+++ b/tests/test_lru_cache.py
@@ -0,0 +1,37 @@
+import pytest
+
+from sentry_sdk._lru_cache import LRUCache
+
+
+@pytest.mark.parametrize("max_size", [-10, -1, 0])
+def test_illegal_size(max_size):
+ with pytest.raises(AssertionError):
+ LRUCache(max_size=max_size)
+
+
+def test_simple_set_get():
+ cache = LRUCache(1)
+ assert cache.get(1) is None
+ cache.set(1, 1)
+ assert cache.get(1) == 1
+
+
+def test_overwrite():
+ cache = LRUCache(1)
+ assert cache.get(1) is None
+ cache.set(1, 1)
+ assert cache.get(1) == 1
+ cache.set(1, 2)
+ assert cache.get(1) == 2
+
+
+def test_cache_eviction():
+ cache = LRUCache(3)
+ cache.set(1, 1)
+ cache.set(2, 2)
+ cache.set(3, 3)
+ assert cache.get(1) == 1
+ assert cache.get(2) == 2
+ cache.set(4, 4)
+ assert cache.get(3) is None
+ assert cache.get(4) == 4
diff --git a/tests/test_profiler.py b/tests/test_profiler.py
new file mode 100644
index 0000000000..8ddbc333da
--- /dev/null
+++ b/tests/test_profiler.py
@@ -0,0 +1,817 @@
+import inspect
+import os
+import sys
+import threading
+import time
+
+import pytest
+
+from collections import defaultdict
+from sentry_sdk import start_transaction
+from sentry_sdk.profiler import (
+ GeventScheduler,
+ Profile,
+ Scheduler,
+ ThreadScheduler,
+ extract_frame,
+ extract_stack,
+ frame_id,
+ get_current_thread_id,
+ get_frame_name,
+ setup_profiler,
+)
+from sentry_sdk.tracing import Transaction
+from sentry_sdk._lru_cache import LRUCache
+from sentry_sdk._queue import Queue
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+try:
+ import gevent
+except ImportError:
+ gevent = None
+
+
+def requires_python_version(major, minor, reason=None):
+ if reason is None:
+ reason = "Requires Python {}.{}".format(major, minor)
+ return pytest.mark.skipif(sys.version_info < (major, minor), reason=reason)
+
+
+requires_gevent = pytest.mark.skipif(gevent is None, reason="gevent not enabled")
+
+
+def process_test_sample(sample):
+ # insert a mock hashable for the stack
+ return [(tid, (stack, stack)) for tid, stack in sample]
+
+
+def non_experimental_options(mode=None, sample_rate=None):
+ return {"profiler_mode": mode, "profiles_sample_rate": sample_rate}
+
+
+def experimental_options(mode=None, sample_rate=None):
+ return {
+ "_experiments": {"profiler_mode": mode, "profiles_sample_rate": sample_rate}
+ }
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ "mode",
+ [
+ pytest.param("foo"),
+ pytest.param(
+ "gevent",
+ marks=pytest.mark.skipif(gevent is not None, reason="gevent not enabled"),
+ ),
+ ],
+)
+@pytest.mark.parametrize(
+ "make_options",
+ [
+ pytest.param(experimental_options, id="experiment"),
+ pytest.param(non_experimental_options, id="non experimental"),
+ ],
+)
+def test_profiler_invalid_mode(mode, make_options, teardown_profiling):
+ with pytest.raises(ValueError):
+ setup_profiler(make_options(mode))
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ "mode",
+ [
+ pytest.param("thread"),
+ pytest.param("sleep"),
+ pytest.param("gevent", marks=requires_gevent),
+ ],
+)
+@pytest.mark.parametrize(
+ "make_options",
+ [
+ pytest.param(experimental_options, id="experiment"),
+ pytest.param(non_experimental_options, id="non experimental"),
+ ],
+)
+def test_profiler_valid_mode(mode, make_options, teardown_profiling):
+ # should not raise any exceptions
+ setup_profiler(make_options(mode))
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ "make_options",
+ [
+ pytest.param(experimental_options, id="experiment"),
+ pytest.param(non_experimental_options, id="non experimental"),
+ ],
+)
+def test_profiler_setup_twice(make_options, teardown_profiling):
+ # setting up the first time should return True to indicate success
+ assert setup_profiler(make_options())
+ # setting up the second time should return False to indicate no-op
+ assert not setup_profiler(make_options())
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ "mode",
+ [
+ pytest.param("thread"),
+ pytest.param("gevent", marks=requires_gevent),
+ ],
+)
+@pytest.mark.parametrize(
+ ("profiles_sample_rate", "profile_count"),
+ [
+ pytest.param(1.00, 1, id="profiler sampled at 1.00"),
+ pytest.param(0.75, 1, id="profiler sampled at 0.75"),
+ pytest.param(0.25, 0, id="profiler sampled at 0.25"),
+ pytest.param(0.00, 0, id="profiler sampled at 0.00"),
+ pytest.param(None, 0, id="profiler not enabled"),
+ ],
+)
+@pytest.mark.parametrize(
+ "make_options",
+ [
+ pytest.param(experimental_options, id="experiment"),
+ pytest.param(non_experimental_options, id="non experimental"),
+ ],
+)
+@mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0)
+def test_profiles_sample_rate(
+ sentry_init,
+ capture_envelopes,
+ teardown_profiling,
+ profiles_sample_rate,
+ profile_count,
+ make_options,
+ mode,
+):
+ options = make_options(mode=mode, sample_rate=profiles_sample_rate)
+ sentry_init(
+ traces_sample_rate=1.0,
+ profiler_mode=options.get("profiler_mode"),
+ profiles_sample_rate=options.get("profiles_sample_rate"),
+ _experiments=options.get("_experiments", {}),
+ )
+
+ envelopes = capture_envelopes()
+
+ with mock.patch("sentry_sdk.profiler.random.random", return_value=0.5):
+ with start_transaction(name="profiling"):
+ pass
+
+ items = defaultdict(list)
+ for envelope in envelopes:
+ for item in envelope.items:
+ items[item.type].append(item)
+
+ assert len(items["transaction"]) == 1
+ assert len(items["profile"]) == profile_count
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ "mode",
+ [
+ pytest.param("thread"),
+ pytest.param("gevent", marks=requires_gevent),
+ ],
+)
+@pytest.mark.parametrize(
+ ("profiles_sampler", "profile_count"),
+ [
+ pytest.param(lambda _: 1.00, 1, id="profiler sampled at 1.00"),
+ pytest.param(lambda _: 0.75, 1, id="profiler sampled at 0.75"),
+ pytest.param(lambda _: 0.25, 0, id="profiler sampled at 0.25"),
+ pytest.param(lambda _: 0.00, 0, id="profiler sampled at 0.00"),
+ pytest.param(lambda _: None, 0, id="profiler not enabled"),
+ pytest.param(
+ lambda ctx: 1 if ctx["transaction_context"]["name"] == "profiling" else 0,
+ 1,
+ id="profiler sampled for transaction name",
+ ),
+ pytest.param(
+ lambda ctx: 0 if ctx["transaction_context"]["name"] == "profiling" else 1,
+ 0,
+ id="profiler not sampled for transaction name",
+ ),
+ pytest.param(
+ lambda _: "1", 0, id="profiler not sampled because string sample rate"
+ ),
+ pytest.param(lambda _: True, 1, id="profiler sampled at True"),
+ pytest.param(lambda _: False, 0, id="profiler sampled at False"),
+ ],
+)
+@mock.patch("sentry_sdk.profiler.PROFILE_MINIMUM_SAMPLES", 0)
+def test_profiles_sampler(
+ sentry_init,
+ capture_envelopes,
+ teardown_profiling,
+ profiles_sampler,
+ profile_count,
+ mode,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ profiles_sampler=profiles_sampler,
+ )
+
+ envelopes = capture_envelopes()
+
+ with mock.patch("sentry_sdk.profiler.random.random", return_value=0.5):
+ with start_transaction(name="profiling"):
+ pass
+
+ items = defaultdict(list)
+ for envelope in envelopes:
+ for item in envelope.items:
+ items[item.type].append(item)
+
+ assert len(items["transaction"]) == 1
+ assert len(items["profile"]) == profile_count
+
+
+@requires_python_version(3, 3)
+def test_minimum_unique_samples_required(
+ sentry_init,
+ capture_envelopes,
+ teardown_profiling,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+
+ envelopes = capture_envelopes()
+
+ with start_transaction(name="profiling"):
+ pass
+
+ items = defaultdict(list)
+ for envelope in envelopes:
+ for item in envelope.items:
+ items[item.type].append(item)
+
+ assert len(items["transaction"]) == 1
+ # because we dont leave any time for the profiler to
+ # take any samples, it should be not be sent
+ assert len(items["profile"]) == 0
+
+
+@requires_python_version(3, 3)
+def test_profile_captured(
+ sentry_init,
+ capture_envelopes,
+ teardown_profiling,
+):
+ sentry_init(
+ traces_sample_rate=1.0,
+ _experiments={"profiles_sample_rate": 1.0},
+ )
+
+ envelopes = capture_envelopes()
+
+ with start_transaction(name="profiling"):
+ time.sleep(0.05)
+
+ items = defaultdict(list)
+ for envelope in envelopes:
+ for item in envelope.items:
+ items[item.type].append(item)
+
+ assert len(items["transaction"]) == 1
+ assert len(items["profile"]) == 1
+
+
+def get_frame(depth=1):
+ """
+ This function is not exactly true to its name. Depending on
+ how it is called, the true depth of the stack can be deeper
+ than the argument implies.
+ """
+ if depth <= 0:
+ raise ValueError("only positive integers allowed")
+ if depth > 1:
+ return get_frame(depth=depth - 1)
+ return inspect.currentframe()
+
+
+class GetFrameBase:
+ def inherited_instance_method(self):
+ return inspect.currentframe()
+
+ def inherited_instance_method_wrapped(self):
+ def wrapped():
+ return inspect.currentframe()
+
+ return wrapped
+
+ @classmethod
+ def inherited_class_method(cls):
+ return inspect.currentframe()
+
+ @classmethod
+ def inherited_class_method_wrapped(cls):
+ def wrapped():
+ return inspect.currentframe()
+
+ return wrapped
+
+ @staticmethod
+ def inherited_static_method():
+ return inspect.currentframe()
+
+
+class GetFrame(GetFrameBase):
+ def instance_method(self):
+ return inspect.currentframe()
+
+ def instance_method_wrapped(self):
+ def wrapped():
+ return inspect.currentframe()
+
+ return wrapped
+
+ @classmethod
+ def class_method(cls):
+ return inspect.currentframe()
+
+ @classmethod
+ def class_method_wrapped(cls):
+ def wrapped():
+ return inspect.currentframe()
+
+ return wrapped
+
+ @staticmethod
+ def static_method():
+ return inspect.currentframe()
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("frame", "frame_name"),
+ [
+ pytest.param(
+ get_frame(),
+ "get_frame",
+ id="function",
+ ),
+ pytest.param(
+ (lambda: inspect.currentframe())(),
+ "",
+ id="lambda",
+ ),
+ pytest.param(
+ GetFrame().instance_method(),
+ "GetFrame.instance_method",
+ id="instance_method",
+ ),
+ pytest.param(
+ GetFrame().instance_method_wrapped()(),
+ "wrapped"
+ if sys.version_info < (3, 11)
+ else "GetFrame.instance_method_wrapped..wrapped",
+ id="instance_method_wrapped",
+ ),
+ pytest.param(
+ GetFrame().class_method(),
+ "GetFrame.class_method",
+ id="class_method",
+ ),
+ pytest.param(
+ GetFrame().class_method_wrapped()(),
+ "wrapped"
+ if sys.version_info < (3, 11)
+ else "GetFrame.class_method_wrapped..wrapped",
+ id="class_method_wrapped",
+ ),
+ pytest.param(
+ GetFrame().static_method(),
+ "static_method" if sys.version_info < (3, 11) else "GetFrame.static_method",
+ id="static_method",
+ ),
+ pytest.param(
+ GetFrame().inherited_instance_method(),
+ "GetFrameBase.inherited_instance_method",
+ id="inherited_instance_method",
+ ),
+ pytest.param(
+ GetFrame().inherited_instance_method_wrapped()(),
+ "wrapped"
+ if sys.version_info < (3, 11)
+ else "GetFrameBase.inherited_instance_method_wrapped..wrapped",
+ id="instance_method_wrapped",
+ ),
+ pytest.param(
+ GetFrame().inherited_class_method(),
+ "GetFrameBase.inherited_class_method",
+ id="inherited_class_method",
+ ),
+ pytest.param(
+ GetFrame().inherited_class_method_wrapped()(),
+ "wrapped"
+ if sys.version_info < (3, 11)
+ else "GetFrameBase.inherited_class_method_wrapped..wrapped",
+ id="inherited_class_method_wrapped",
+ ),
+ pytest.param(
+ GetFrame().inherited_static_method(),
+ "inherited_static_method"
+ if sys.version_info < (3, 11)
+ else "GetFrameBase.inherited_static_method",
+ id="inherited_static_method",
+ ),
+ ],
+)
+def test_get_frame_name(frame, frame_name):
+ assert get_frame_name(frame) == frame_name
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("get_frame", "function"),
+ [
+ pytest.param(lambda: get_frame(depth=1), "get_frame", id="simple"),
+ ],
+)
+def test_extract_frame(get_frame, function):
+ cwd = os.getcwd()
+ frame = get_frame()
+ extracted_frame = extract_frame(frame_id(frame), frame, cwd)
+
+ # the abs_path should be equal toe the normalized path of the co_filename
+ assert extracted_frame["abs_path"] == os.path.normpath(frame.f_code.co_filename)
+
+ # the module should be pull from this test module
+ assert extracted_frame["module"] == __name__
+
+ # the filename should be the file starting after the cwd
+ assert extracted_frame["filename"] == __file__[len(cwd) + 1 :]
+
+ assert extracted_frame["function"] == function
+
+ # the lineno will shift over time as this file is modified so just check
+ # that it is an int
+ assert isinstance(extracted_frame["lineno"], int)
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("depth", "max_stack_depth", "actual_depth"),
+ [
+ pytest.param(1, 128, 1, id="less than"),
+ pytest.param(256, 128, 128, id="greater than"),
+ pytest.param(128, 128, 128, id="equals"),
+ ],
+)
+def test_extract_stack_with_max_depth(depth, max_stack_depth, actual_depth):
+ # introduce a lambda that we'll be looking for in the stack
+ frame = (lambda: get_frame(depth=depth))()
+
+ # plus 1 because we introduced a lambda intentionally that we'll
+ # look for in the final stack to make sure its in the right position
+ base_stack_depth = len(inspect.stack()) + 1
+
+ # increase the max_depth by the `base_stack_depth` to account
+ # for the extra frames pytest will add
+ _, frame_ids, frames = extract_stack(
+ frame, LRUCache(max_size=1), max_stack_depth=max_stack_depth + base_stack_depth
+ )
+ assert len(frame_ids) == base_stack_depth + actual_depth
+ assert len(frames) == base_stack_depth + actual_depth
+
+ for i in range(actual_depth):
+ assert frames[i]["function"] == "get_frame", i
+
+ # index 0 contains the inner most frame on the stack, so the lamdba
+ # should be at index `actual_depth`
+ if sys.version_info >= (3, 11):
+ assert (
+ frames[actual_depth]["function"]
+ == "test_extract_stack_with_max_depth.."
+ ), actual_depth
+ else:
+ assert frames[actual_depth]["function"] == "", actual_depth
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("frame", "depth"),
+ [(get_frame(depth=1), len(inspect.stack()))],
+)
+def test_extract_stack_with_cache(frame, depth):
+ # make sure cache has enough room or this test will fail
+ cache = LRUCache(max_size=depth)
+ _, _, frames1 = extract_stack(frame, cache)
+ _, _, frames2 = extract_stack(frame, cache)
+
+ assert len(frames1) > 0
+ assert len(frames2) > 0
+ assert len(frames1) == len(frames2)
+ for i, (frame1, frame2) in enumerate(zip(frames1, frames2)):
+ # DO NOT use `==` for the assertion here since we are
+ # testing for identity, and using `==` would test for
+ # equality which would always pass since we're extract
+ # the same stack.
+ assert frame1 is frame2, i
+
+
+@requires_python_version(3, 3)
+def test_get_current_thread_id_explicit_thread():
+ results = Queue(maxsize=1)
+
+ def target1():
+ pass
+
+ def target2():
+ results.put(get_current_thread_id(thread1))
+
+ thread1 = threading.Thread(target=target1)
+ thread1.start()
+
+ thread2 = threading.Thread(target=target2)
+ thread2.start()
+
+ thread2.join()
+ thread1.join()
+
+ assert thread1.ident == results.get(timeout=1)
+
+
+@requires_python_version(3, 3)
+@requires_gevent
+def test_get_current_thread_id_gevent_in_thread():
+ results = Queue(maxsize=1)
+
+ def target():
+ job = gevent.spawn(get_current_thread_id)
+ job.join()
+ results.put(job.value)
+
+ thread = threading.Thread(target=target)
+ thread.start()
+ thread.join()
+ assert thread.ident == results.get(timeout=1)
+
+
+@requires_python_version(3, 3)
+def test_get_current_thread_id_running_thread():
+ results = Queue(maxsize=1)
+
+ def target():
+ results.put(get_current_thread_id())
+
+ thread = threading.Thread(target=target)
+ thread.start()
+ thread.join()
+ assert thread.ident == results.get(timeout=1)
+
+
+@requires_python_version(3, 3)
+def test_get_current_thread_id_main_thread():
+ results = Queue(maxsize=1)
+
+ def target():
+ # mock that somehow the current thread doesn't exist
+ with mock.patch("threading.current_thread", side_effect=[None]):
+ results.put(get_current_thread_id())
+
+ thread_id = threading.main_thread().ident if sys.version_info >= (3, 4) else None
+
+ thread = threading.Thread(target=target)
+ thread.start()
+ thread.join()
+ assert thread_id == results.get(timeout=1)
+
+
+def get_scheduler_threads(scheduler):
+ return [thread for thread in threading.enumerate() if thread.name == scheduler.name]
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("scheduler_class",),
+ [
+ pytest.param(ThreadScheduler, id="thread scheduler"),
+ pytest.param(
+ GeventScheduler,
+ marks=[
+ requires_gevent,
+ pytest.mark.skip(
+ reason="cannot find this thread via threading.enumerate()"
+ ),
+ ],
+ id="gevent scheduler",
+ ),
+ ],
+)
+def test_thread_scheduler_single_background_thread(scheduler_class):
+ scheduler = scheduler_class(frequency=1000)
+
+ # not yet setup, no scheduler threads yet
+ assert len(get_scheduler_threads(scheduler)) == 0
+
+ scheduler.setup()
+
+ # setup but no profiles started so still no threads
+ assert len(get_scheduler_threads(scheduler)) == 0
+
+ scheduler.ensure_running()
+
+ # the scheduler will start always 1 thread
+ assert len(get_scheduler_threads(scheduler)) == 1
+
+ scheduler.ensure_running()
+
+ # the scheduler still only has 1 thread
+ assert len(get_scheduler_threads(scheduler)) == 1
+
+ scheduler.teardown()
+
+ # once finished, the thread should stop
+ assert len(get_scheduler_threads(scheduler)) == 0
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("scheduler_class",),
+ [
+ pytest.param(ThreadScheduler, id="thread scheduler"),
+ pytest.param(GeventScheduler, marks=requires_gevent, id="gevent scheduler"),
+ ],
+)
+@mock.patch("sentry_sdk.profiler.MAX_PROFILE_DURATION_NS", 1)
+def test_max_profile_duration_reached(scheduler_class):
+ sample = [("1", extract_stack(get_frame(), LRUCache(max_size=1)))]
+
+ with scheduler_class(frequency=1000) as scheduler:
+ transaction = Transaction(sampled=True)
+ with Profile(transaction, scheduler=scheduler) as profile:
+ # profile just started, it's active
+ assert profile.active
+
+ # write a sample at the start time, so still active
+ profile.write(profile.start_ns + 0, sample)
+ assert profile.active
+
+ # write a sample at max time, so still active
+ profile.write(profile.start_ns + 1, sample)
+ assert profile.active
+
+ # write a sample PAST the max time, so now inactive
+ profile.write(profile.start_ns + 2, sample)
+ assert not profile.active
+
+
+class NoopScheduler(Scheduler):
+ def setup(self):
+ # type: () -> None
+ pass
+
+ def teardown(self):
+ # type: () -> None
+ pass
+
+ def ensure_running(self):
+ # type: () -> None
+ pass
+
+
+current_thread = threading.current_thread()
+thread_metadata = {
+ str(current_thread.ident): {
+ "name": str(current_thread.name),
+ },
+}
+
+
+sample_stacks = [
+ extract_stack(get_frame(), LRUCache(max_size=1), max_stack_depth=1),
+ extract_stack(get_frame(), LRUCache(max_size=1), max_stack_depth=2),
+]
+
+
+@requires_python_version(3, 3)
+@pytest.mark.parametrize(
+ ("samples", "expected"),
+ [
+ pytest.param(
+ [],
+ {
+ "frames": [],
+ "samples": [],
+ "stacks": [],
+ "thread_metadata": thread_metadata,
+ },
+ id="empty",
+ ),
+ pytest.param(
+ [(6, [("1", sample_stacks[0])])],
+ {
+ "frames": [],
+ "samples": [],
+ "stacks": [],
+ "thread_metadata": thread_metadata,
+ },
+ id="single sample out of range",
+ ),
+ pytest.param(
+ [(0, [("1", sample_stacks[0])])],
+ {
+ "frames": [sample_stacks[0][2][0]],
+ "samples": [
+ {
+ "elapsed_since_start_ns": "0",
+ "thread_id": "1",
+ "stack_id": 0,
+ },
+ ],
+ "stacks": [[0]],
+ "thread_metadata": thread_metadata,
+ },
+ id="single sample in range",
+ ),
+ pytest.param(
+ [
+ (0, [("1", sample_stacks[0])]),
+ (1, [("1", sample_stacks[0])]),
+ ],
+ {
+ "frames": [sample_stacks[0][2][0]],
+ "samples": [
+ {
+ "elapsed_since_start_ns": "0",
+ "thread_id": "1",
+ "stack_id": 0,
+ },
+ {
+ "elapsed_since_start_ns": "1",
+ "thread_id": "1",
+ "stack_id": 0,
+ },
+ ],
+ "stacks": [[0]],
+ "thread_metadata": thread_metadata,
+ },
+ id="two identical stacks",
+ ),
+ pytest.param(
+ [
+ (0, [("1", sample_stacks[0])]),
+ (1, [("1", sample_stacks[1])]),
+ ],
+ {
+ "frames": [
+ sample_stacks[0][2][0],
+ sample_stacks[1][2][0],
+ ],
+ "samples": [
+ {
+ "elapsed_since_start_ns": "0",
+ "thread_id": "1",
+ "stack_id": 0,
+ },
+ {
+ "elapsed_since_start_ns": "1",
+ "thread_id": "1",
+ "stack_id": 1,
+ },
+ ],
+ "stacks": [[0], [1, 0]],
+ "thread_metadata": thread_metadata,
+ },
+ id="two identical stacks",
+ ),
+ ],
+)
+@mock.patch("sentry_sdk.profiler.MAX_PROFILE_DURATION_NS", 5)
+def test_profile_processing(
+ DictionaryContaining, # noqa: N803
+ samples,
+ expected,
+):
+ with NoopScheduler(frequency=1000) as scheduler:
+ transaction = Transaction(sampled=True)
+ with Profile(transaction, scheduler=scheduler) as profile:
+ for ts, sample in samples:
+ # force the sample to be written at a time relative to the
+ # start of the profile
+ now = profile.start_ns + ts
+ profile.write(now, sample)
+
+ processed = profile.process()
+
+ assert processed["thread_metadata"] == DictionaryContaining(
+ expected["thread_metadata"]
+ )
+ assert processed["frames"] == expected["frames"]
+ assert processed["stacks"] == expected["stacks"]
+ assert processed["samples"] == expected["samples"]
diff --git a/tests/test_scrubber.py b/tests/test_scrubber.py
new file mode 100644
index 0000000000..4b2dfff450
--- /dev/null
+++ b/tests/test_scrubber.py
@@ -0,0 +1,171 @@
+import sys
+import logging
+
+from sentry_sdk import capture_exception, capture_event, start_transaction, start_span
+from sentry_sdk.utils import event_from_exception
+from sentry_sdk.scrubber import EventScrubber
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+
+def test_request_scrubbing(sentry_init, capture_events):
+ sentry_init()
+ events = capture_events()
+
+ try:
+ 1 / 0
+ except ZeroDivisionError:
+ ev, _hint = event_from_exception(sys.exc_info())
+
+ ev["request"] = {
+ "headers": {
+ "COOKIE": "secret",
+ "authorization": "Bearer bla",
+ "ORIGIN": "google.com",
+ },
+ "cookies": {
+ "sessionid": "secret",
+ "foo": "bar",
+ },
+ "data": {
+ "token": "secret",
+ "foo": "bar",
+ },
+ }
+
+ capture_event(ev)
+
+ (event,) = events
+
+ assert event["request"] == {
+ "headers": {
+ "COOKIE": "[Filtered]",
+ "authorization": "[Filtered]",
+ "ORIGIN": "google.com",
+ },
+ "cookies": {"sessionid": "[Filtered]", "foo": "bar"},
+ "data": {"token": "[Filtered]", "foo": "bar"},
+ }
+
+ assert event["_meta"]["request"] == {
+ "headers": {
+ "COOKIE": {"": {"rem": [["!config", "s"]]}},
+ "authorization": {"": {"rem": [["!config", "s"]]}},
+ },
+ "cookies": {"sessionid": {"": {"rem": [["!config", "s"]]}}},
+ "data": {"token": {"": {"rem": [["!config", "s"]]}}},
+ }
+
+
+def test_stack_var_scrubbing(sentry_init, capture_events):
+ sentry_init()
+ events = capture_events()
+
+ try:
+ password = "supersecret" # noqa
+ api_key = "1231231231" # noqa
+ safe = "keepthis" # noqa
+ 1 / 0
+ except ZeroDivisionError:
+ capture_exception()
+
+ (event,) = events
+
+ frames = event["exception"]["values"][0]["stacktrace"]["frames"]
+ (frame,) = frames
+ assert frame["vars"]["password"] == "[Filtered]"
+ assert frame["vars"]["api_key"] == "[Filtered]"
+ assert frame["vars"]["safe"] == "'keepthis'"
+
+ meta = event["_meta"]["exception"]["values"]["0"]["stacktrace"]["frames"]["0"][
+ "vars"
+ ]
+ assert meta == {
+ "password": {"": {"rem": [["!config", "s"]]}},
+ "api_key": {"": {"rem": [["!config", "s"]]}},
+ }
+
+
+def test_breadcrumb_extra_scrubbing(sentry_init, capture_events):
+ sentry_init()
+ events = capture_events()
+
+ logger.info("bread", extra=dict(foo=42, password="secret"))
+ logger.critical("whoops", extra=dict(bar=69, auth="secret"))
+
+ (event,) = events
+
+ assert event["extra"]["bar"] == 69
+ assert event["extra"]["auth"] == "[Filtered]"
+
+ assert event["breadcrumbs"]["values"][0]["data"] == {
+ "foo": 42,
+ "password": "[Filtered]",
+ }
+
+ assert event["_meta"]["extra"]["auth"] == {"": {"rem": [["!config", "s"]]}}
+ assert event["_meta"]["breadcrumbs"] == {
+ "values": {"0": {"data": {"password": {"": {"rem": [["!config", "s"]]}}}}}
+ }
+
+
+def test_span_data_scrubbing(sentry_init, capture_events):
+ sentry_init(traces_sample_rate=1.0)
+ events = capture_events()
+
+ with start_transaction(name="hi"):
+ with start_span(op="foo", description="bar") as span:
+ span.set_data("password", "secret")
+ span.set_data("datafoo", "databar")
+
+ (event,) = events
+ assert event["spans"][0]["data"] == {"password": "[Filtered]", "datafoo": "databar"}
+ assert event["_meta"]["spans"] == {
+ "0": {"data": {"password": {"": {"rem": [["!config", "s"]]}}}}
+ }
+
+
+def test_custom_denylist(sentry_init, capture_events):
+ sentry_init(event_scrubber=EventScrubber(denylist=["my_sensitive_var"]))
+ events = capture_events()
+
+ try:
+ my_sensitive_var = "secret" # noqa
+ safe = "keepthis" # noqa
+ 1 / 0
+ except ZeroDivisionError:
+ capture_exception()
+
+ (event,) = events
+
+ frames = event["exception"]["values"][0]["stacktrace"]["frames"]
+ (frame,) = frames
+ assert frame["vars"]["my_sensitive_var"] == "[Filtered]"
+ assert frame["vars"]["safe"] == "'keepthis'"
+
+ meta = event["_meta"]["exception"]["values"]["0"]["stacktrace"]["frames"]["0"][
+ "vars"
+ ]
+ assert meta == {
+ "my_sensitive_var": {"": {"rem": [["!config", "s"]]}},
+ }
+
+
+def test_scrubbing_doesnt_affect_local_vars(sentry_init, capture_events):
+ sentry_init()
+ events = capture_events()
+
+ try:
+ password = "cat123"
+ 1 / 0
+ except ZeroDivisionError:
+ capture_exception()
+
+ (event,) = events
+
+ frames = event["exception"]["values"][0]["stacktrace"]["frames"]
+ (frame,) = frames
+ assert frame["vars"]["password"] == "[Filtered]"
+ assert password == "cat123"
diff --git a/tests/test_serializer.py b/tests/test_serializer.py
index 1cc20c4b4a..cc62c4663d 100644
--- a/tests/test_serializer.py
+++ b/tests/test_serializer.py
@@ -1,7 +1,8 @@
+import re
import sys
import pytest
-from sentry_sdk.serializer import serialize
+from sentry_sdk.serializer import MAX_DATABAG_BREADTH, MAX_DATABAG_DEPTH, serialize
try:
from hypothesis import given
@@ -39,18 +40,30 @@ def inner(message, **kwargs):
@pytest.fixture
def extra_normalizer(validate_event_schema):
- def inner(message, **kwargs):
- event = serialize({"extra": {"foo": message}}, **kwargs)
+ def inner(extra, **kwargs):
+ event = serialize({"extra": {"foo": extra}}, **kwargs)
validate_event_schema(event)
return event["extra"]["foo"]
return inner
+@pytest.fixture
+def body_normalizer(validate_event_schema):
+ def inner(body, **kwargs):
+ event = serialize({"request": {"data": body}}, **kwargs)
+ validate_event_schema(event)
+ return event["request"]["data"]
+
+ return inner
+
+
def test_bytes_serialization_decode(message_normalizer):
binary = b"abc123\x80\xf0\x9f\x8d\x95"
result = message_normalizer(binary, should_repr_strings=False)
+ # fmt: off
assert result == u"abc123\ufffd\U0001f355"
+ # fmt: on
@pytest.mark.xfail(sys.version_info < (3,), reason="Known safe_repr bugs in Py2.7")
@@ -60,6 +73,27 @@ def test_bytes_serialization_repr(message_normalizer):
assert result == r"b'abc123\x80\xf0\x9f\x8d\x95'"
+def test_bytearray_serialization_decode(message_normalizer):
+ binary = bytearray(b"abc123\x80\xf0\x9f\x8d\x95")
+ result = message_normalizer(binary, should_repr_strings=False)
+ # fmt: off
+ assert result == u"abc123\ufffd\U0001f355"
+ # fmt: on
+
+
+@pytest.mark.xfail(sys.version_info < (3,), reason="Known safe_repr bugs in Py2.7")
+def test_bytearray_serialization_repr(message_normalizer):
+ binary = bytearray(b"abc123\x80\xf0\x9f\x8d\x95")
+ result = message_normalizer(binary, should_repr_strings=True)
+ assert result == r"bytearray(b'abc123\x80\xf0\x9f\x8d\x95')"
+
+
+def test_memoryview_serialization_repr(message_normalizer):
+ binary = memoryview(b"abc123\x80\xf0\x9f\x8d\x95")
+ result = message_normalizer(binary, should_repr_strings=False)
+ assert re.match(r"^$", result)
+
+
def test_serialize_sets(extra_normalizer):
result = extra_normalizer({1, 2, 3})
assert result == [1, 2, 3]
@@ -84,3 +118,29 @@ def test_custom_mapping_doesnt_mess_with_mock(extra_normalizer):
m = mock.Mock()
extra_normalizer(m)
assert len(m.mock_calls) == 0
+
+
+def test_trim_databag_breadth(body_normalizer):
+ data = {
+ "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
+ }
+
+ result = body_normalizer(data)
+
+ assert len(result) == MAX_DATABAG_BREADTH
+ for key, value in result.items():
+ assert data.get(key) == value
+
+
+def test_no_trimming_if_request_bodies_is_always(body_normalizer):
+ data = {
+ "key{}".format(i): "value{}".format(i) for i in range(MAX_DATABAG_BREADTH + 10)
+ }
+ curr = data
+ for _ in range(MAX_DATABAG_DEPTH + 5):
+ curr["nested"] = {}
+ curr = curr["nested"]
+
+ result = body_normalizer(data, request_bodies="always")
+
+ assert result == data
diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 0000000000..47460d39b0
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,425 @@
+import pytest
+import re
+import sys
+
+from sentry_sdk.utils import (
+ Components,
+ is_valid_sample_rate,
+ logger,
+ match_regex_list,
+ parse_url,
+ parse_version,
+ sanitize_url,
+ serialize_frame,
+)
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+
+@pytest.mark.parametrize(
+ ("url", "expected_result"),
+ [
+ ("http://localhost:8000", "http://localhost:8000"),
+ ("http://example.com", "http://example.com"),
+ ("https://example.com", "https://example.com"),
+ (
+ "example.com?token=abc&sessionid=123&save=true",
+ "example.com?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ (
+ "http://example.com?token=abc&sessionid=123&save=true",
+ "http://example.com?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ (
+ "https://example.com?token=abc&sessionid=123&save=true",
+ "https://example.com?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ (
+ "http://localhost:8000/?token=abc&sessionid=123&save=true",
+ "http://localhost:8000/?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ (
+ "ftp://username:password@ftp.example.com:9876/bla/blub#foo",
+ "ftp://[Filtered]:[Filtered]@ftp.example.com:9876/bla/blub#foo",
+ ),
+ (
+ "https://username:password@example.com/bla/blub?token=abc&sessionid=123&save=true#fragment",
+ "https://[Filtered]:[Filtered]@example.com/bla/blub?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]#fragment",
+ ),
+ ("bla/blub/foo", "bla/blub/foo"),
+ ("/bla/blub/foo/", "/bla/blub/foo/"),
+ (
+ "bla/blub/foo?token=abc&sessionid=123&save=true",
+ "bla/blub/foo?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ (
+ "/bla/blub/foo/?token=abc&sessionid=123&save=true",
+ "/bla/blub/foo/?token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ ),
+ ],
+)
+def test_sanitize_url(url, expected_result):
+ # sort parts because old Python versions (<3.6) don't preserve order
+ sanitized_url = sanitize_url(url)
+ parts = sorted(re.split(r"\&|\?|\#", sanitized_url))
+ expected_parts = sorted(re.split(r"\&|\?|\#", expected_result))
+
+ assert parts == expected_parts
+
+
+@pytest.mark.parametrize(
+ ("url", "expected_result"),
+ [
+ (
+ "http://localhost:8000",
+ Components(
+ scheme="http", netloc="localhost:8000", path="", query="", fragment=""
+ ),
+ ),
+ (
+ "http://example.com",
+ Components(
+ scheme="http", netloc="example.com", path="", query="", fragment=""
+ ),
+ ),
+ (
+ "https://example.com",
+ Components(
+ scheme="https", netloc="example.com", path="", query="", fragment=""
+ ),
+ ),
+ (
+ "example.com?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="",
+ netloc="",
+ path="example.com",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ (
+ "http://example.com?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="http",
+ netloc="example.com",
+ path="",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ (
+ "https://example.com?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="https",
+ netloc="example.com",
+ path="",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ (
+ "http://localhost:8000/?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="http",
+ netloc="localhost:8000",
+ path="/",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ (
+ "ftp://username:password@ftp.example.com:9876/bla/blub#foo",
+ Components(
+ scheme="ftp",
+ netloc="[Filtered]:[Filtered]@ftp.example.com:9876",
+ path="/bla/blub",
+ query="",
+ fragment="foo",
+ ),
+ ),
+ (
+ "https://username:password@example.com/bla/blub?token=abc&sessionid=123&save=true#fragment",
+ Components(
+ scheme="https",
+ netloc="[Filtered]:[Filtered]@example.com",
+ path="/bla/blub",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="fragment",
+ ),
+ ),
+ (
+ "bla/blub/foo",
+ Components(
+ scheme="", netloc="", path="bla/blub/foo", query="", fragment=""
+ ),
+ ),
+ (
+ "bla/blub/foo?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="",
+ netloc="",
+ path="bla/blub/foo",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ (
+ "/bla/blub/foo/?token=abc&sessionid=123&save=true",
+ Components(
+ scheme="",
+ netloc="",
+ path="/bla/blub/foo/",
+ query="token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ fragment="",
+ ),
+ ),
+ ],
+)
+def test_sanitize_url_and_split(url, expected_result):
+ sanitized_url = sanitize_url(url, split=True)
+ # sort query because old Python versions (<3.6) don't preserve order
+ query = sorted(sanitized_url.query.split("&"))
+ expected_query = sorted(expected_result.query.split("&"))
+
+ assert sanitized_url.scheme == expected_result.scheme
+ assert sanitized_url.netloc == expected_result.netloc
+ assert query == expected_query
+ assert sanitized_url.path == expected_result.path
+ assert sanitized_url.fragment == expected_result.fragment
+
+
+@pytest.mark.parametrize(
+ ("url", "sanitize", "expected_url", "expected_query", "expected_fragment"),
+ [
+ # Test with sanitize=True
+ (
+ "https://example.com",
+ True,
+ "https://example.com",
+ "",
+ "",
+ ),
+ (
+ "example.com?token=abc&sessionid=123&save=true",
+ True,
+ "example.com",
+ "token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ "",
+ ),
+ (
+ "https://example.com?token=abc&sessionid=123&save=true",
+ True,
+ "https://example.com",
+ "token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ "",
+ ),
+ (
+ "https://username:password@example.com/bla/blub?token=abc&sessionid=123&save=true#fragment",
+ True,
+ "https://[Filtered]:[Filtered]@example.com/bla/blub",
+ "token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ "fragment",
+ ),
+ (
+ "bla/blub/foo",
+ True,
+ "bla/blub/foo",
+ "",
+ "",
+ ),
+ (
+ "/bla/blub/foo/#baz",
+ True,
+ "/bla/blub/foo/",
+ "",
+ "baz",
+ ),
+ (
+ "bla/blub/foo?token=abc&sessionid=123&save=true",
+ True,
+ "bla/blub/foo",
+ "token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ "",
+ ),
+ (
+ "/bla/blub/foo/?token=abc&sessionid=123&save=true",
+ True,
+ "/bla/blub/foo/",
+ "token=[Filtered]&sessionid=[Filtered]&save=[Filtered]",
+ "",
+ ),
+ # Test with sanitize=False
+ (
+ "https://example.com",
+ False,
+ "https://example.com",
+ "",
+ "",
+ ),
+ (
+ "example.com?token=abc&sessionid=123&save=true",
+ False,
+ "example.com",
+ "token=abc&sessionid=123&save=true",
+ "",
+ ),
+ (
+ "https://example.com?token=abc&sessionid=123&save=true",
+ False,
+ "https://example.com",
+ "token=abc&sessionid=123&save=true",
+ "",
+ ),
+ (
+ "https://username:password@example.com/bla/blub?token=abc&sessionid=123&save=true#fragment",
+ False,
+ "https://[Filtered]:[Filtered]@example.com/bla/blub",
+ "token=abc&sessionid=123&save=true",
+ "fragment",
+ ),
+ (
+ "bla/blub/foo",
+ False,
+ "bla/blub/foo",
+ "",
+ "",
+ ),
+ (
+ "/bla/blub/foo/#baz",
+ False,
+ "/bla/blub/foo/",
+ "",
+ "baz",
+ ),
+ (
+ "bla/blub/foo?token=abc&sessionid=123&save=true",
+ False,
+ "bla/blub/foo",
+ "token=abc&sessionid=123&save=true",
+ "",
+ ),
+ (
+ "/bla/blub/foo/?token=abc&sessionid=123&save=true",
+ False,
+ "/bla/blub/foo/",
+ "token=abc&sessionid=123&save=true",
+ "",
+ ),
+ ],
+)
+def test_parse_url(url, sanitize, expected_url, expected_query, expected_fragment):
+ assert parse_url(url, sanitize=sanitize).url == expected_url
+ assert parse_url(url, sanitize=sanitize).fragment == expected_fragment
+
+ # sort parts because old Python versions (<3.6) don't preserve order
+ sanitized_query = parse_url(url, sanitize=sanitize).query
+ query_parts = sorted(re.split(r"\&|\?|\#", sanitized_query))
+ expected_query_parts = sorted(re.split(r"\&|\?|\#", expected_query))
+
+ assert query_parts == expected_query_parts
+
+
+@pytest.mark.parametrize(
+ "rate",
+ [0.0, 0.1231, 1.0, True, False],
+)
+def test_accepts_valid_sample_rate(rate):
+ with mock.patch.object(logger, "warning", mock.Mock()):
+ result = is_valid_sample_rate(rate, source="Testing")
+ assert logger.warning.called is False
+ assert result is True
+
+
+@pytest.mark.parametrize(
+ "rate",
+ [
+ "dogs are great", # wrong type
+ (0, 1), # wrong type
+ {"Maisey": "Charllie"}, # wrong type
+ [True, True], # wrong type
+ {0.2012}, # wrong type
+ float("NaN"), # wrong type
+ None, # wrong type
+ -1.121, # wrong value
+ 1.231, # wrong value
+ ],
+)
+def test_warns_on_invalid_sample_rate(rate, StringContaining): # noqa: N803
+ with mock.patch.object(logger, "warning", mock.Mock()):
+ result = is_valid_sample_rate(rate, source="Testing")
+ logger.warning.assert_any_call(StringContaining("Given sample rate is invalid"))
+ assert result is False
+
+
+@pytest.mark.parametrize(
+ "include_source_context",
+ [True, False],
+)
+def test_include_source_context_when_serializing_frame(include_source_context):
+ frame = sys._getframe()
+ result = serialize_frame(frame, include_source_context=include_source_context)
+
+ assert include_source_context ^ ("pre_context" in result) ^ True
+ assert include_source_context ^ ("context_line" in result) ^ True
+ assert include_source_context ^ ("post_context" in result) ^ True
+
+
+@pytest.mark.parametrize(
+ "item,regex_list,expected_result",
+ [
+ ["", [], False],
+ [None, [], False],
+ ["", None, False],
+ [None, None, False],
+ ["some-string", [], False],
+ ["some-string", None, False],
+ ["some-string", ["some-string"], True],
+ ["some-string", ["some"], False],
+ ["some-string", ["some$"], False], # same as above
+ ["some-string", ["some.*"], True],
+ ["some-string", ["Some"], False], # we do case sensitive matching
+ ["some-string", [".*string$"], True],
+ ],
+)
+def test_match_regex_list(item, regex_list, expected_result):
+ assert match_regex_list(item, regex_list) == expected_result
+
+
+@pytest.mark.parametrize(
+ "version,expected_result",
+ [
+ ["3.5.15", (3, 5, 15)],
+ ["2.0.9", (2, 0, 9)],
+ ["2.0.0", (2, 0, 0)],
+ ["0.6.0", (0, 6, 0)],
+ ["2.0.0.post1", (2, 0, 0)],
+ ["2.0.0rc3", (2, 0, 0)],
+ ["2.0.0rc2", (2, 0, 0)],
+ ["2.0.0rc1", (2, 0, 0)],
+ ["2.0.0b4", (2, 0, 0)],
+ ["2.0.0b3", (2, 0, 0)],
+ ["2.0.0b2", (2, 0, 0)],
+ ["2.0.0b1", (2, 0, 0)],
+ ["0.6beta3", (0, 6)],
+ ["0.6beta2", (0, 6)],
+ ["0.6beta1", (0, 6)],
+ ["0.4.2b", (0, 4, 2)],
+ ["0.4.2a", (0, 4, 2)],
+ ["0.0.1", (0, 0, 1)],
+ ["0.0.0", (0, 0, 0)],
+ ["1", (1,)],
+ ["1.0", (1, 0)],
+ ["1.0.0", (1, 0, 0)],
+ [" 1.0.0 ", (1, 0, 0)],
+ [" 1.0.0 ", (1, 0, 0)],
+ ["x1.0.0", None],
+ ["1.0.0x", None],
+ ["x1.0.0x", None],
+ ],
+)
+def test_parse_version(version, expected_result):
+ assert parse_version(version) == expected_result
diff --git a/tests/tracing/test_baggage.py b/tests/tracing/test_baggage.py
new file mode 100644
index 0000000000..fa856e0af4
--- /dev/null
+++ b/tests/tracing/test_baggage.py
@@ -0,0 +1,80 @@
+# coding: utf-8
+from sentry_sdk.tracing_utils import Baggage
+
+
+def test_third_party_baggage():
+ header = "other-vendor-value-1=foo;bar;baz, other-vendor-value-2=foo;bar;"
+ baggage = Baggage.from_incoming_header(header)
+
+ assert baggage.mutable
+ assert baggage.sentry_items == {}
+ assert sorted(baggage.third_party_items.split(",")) == sorted(
+ "other-vendor-value-1=foo;bar;baz,other-vendor-value-2=foo;bar;".split(",")
+ )
+
+ assert baggage.dynamic_sampling_context() == {}
+ assert baggage.serialize() == ""
+ assert sorted(baggage.serialize(include_third_party=True).split(",")) == sorted(
+ "other-vendor-value-1=foo;bar;baz,other-vendor-value-2=foo;bar;".split(",")
+ )
+
+
+def test_mixed_baggage():
+ header = (
+ "other-vendor-value-1=foo;bar;baz, sentry-trace_id=771a43a4192642f0b136d5159a501700, "
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3, sentry-sample_rate=0.01337, "
+ "sentry-user_id=Am%C3%A9lie, sentry-foo=bar, other-vendor-value-2=foo;bar;"
+ )
+
+ baggage = Baggage.from_incoming_header(header)
+
+ assert not baggage.mutable
+
+ assert baggage.sentry_items == {
+ "public_key": "49d0f7386ad645858ae85020e393bef3",
+ "trace_id": "771a43a4192642f0b136d5159a501700",
+ "user_id": "Amélie",
+ "sample_rate": "0.01337",
+ "foo": "bar",
+ }
+
+ assert (
+ baggage.third_party_items
+ == "other-vendor-value-1=foo;bar;baz,other-vendor-value-2=foo;bar;"
+ )
+
+ assert baggage.dynamic_sampling_context() == {
+ "public_key": "49d0f7386ad645858ae85020e393bef3",
+ "trace_id": "771a43a4192642f0b136d5159a501700",
+ "user_id": "Amélie",
+ "sample_rate": "0.01337",
+ "foo": "bar",
+ }
+
+ assert sorted(baggage.serialize().split(",")) == sorted(
+ (
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700,"
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3,"
+ "sentry-sample_rate=0.01337,sentry-user_id=Am%C3%A9lie,"
+ "sentry-foo=bar"
+ ).split(",")
+ )
+
+ assert sorted(baggage.serialize(include_third_party=True).split(",")) == sorted(
+ (
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700,"
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3,"
+ "sentry-sample_rate=0.01337,sentry-user_id=Am%C3%A9lie,sentry-foo=bar,"
+ "other-vendor-value-1=foo;bar;baz,other-vendor-value-2=foo;bar;"
+ ).split(",")
+ )
+
+
+def test_malformed_baggage():
+ header = ","
+
+ baggage = Baggage.from_incoming_header(header)
+
+ assert baggage.sentry_items == {}
+ assert baggage.third_party_items == ""
+ assert baggage.mutable
diff --git a/tests/tracing/test_decorator_py2.py b/tests/tracing/test_decorator_py2.py
new file mode 100644
index 0000000000..9969786623
--- /dev/null
+++ b/tests/tracing/test_decorator_py2.py
@@ -0,0 +1,54 @@
+from sentry_sdk.tracing_utils_py2 import (
+ start_child_span_decorator as start_child_span_decorator_py2,
+)
+from sentry_sdk.utils import logger
+
+try:
+ from unittest import mock # python 3.3 and above
+except ImportError:
+ import mock # python < 3.3
+
+
+def my_example_function():
+ return "return_of_sync_function"
+
+
+def test_trace_decorator_py2():
+ fake_start_child = mock.MagicMock()
+ fake_transaction = mock.MagicMock()
+ fake_transaction.start_child = fake_start_child
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py2.get_current_span",
+ return_value=fake_transaction,
+ ):
+ result = my_example_function()
+ fake_start_child.assert_not_called()
+ assert result == "return_of_sync_function"
+
+ result2 = start_child_span_decorator_py2(my_example_function)()
+ fake_start_child.assert_called_once_with(
+ op="function", description="test_decorator_py2.my_example_function"
+ )
+ assert result2 == "return_of_sync_function"
+
+
+def test_trace_decorator_py2_no_trx():
+ fake_transaction = None
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py2.get_current_span",
+ return_value=fake_transaction,
+ ):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ result = my_example_function()
+ fake_warning.assert_not_called()
+ assert result == "return_of_sync_function"
+
+ result2 = start_child_span_decorator_py2(my_example_function)()
+ fake_warning.assert_called_once_with(
+ "Can not create a child span for %s. "
+ "Please start a Sentry transaction before calling this function.",
+ "test_decorator_py2.my_example_function",
+ )
+ assert result2 == "return_of_sync_function"
diff --git a/tests/tracing/test_decorator_py3.py b/tests/tracing/test_decorator_py3.py
new file mode 100644
index 0000000000..c458e8add4
--- /dev/null
+++ b/tests/tracing/test_decorator_py3.py
@@ -0,0 +1,103 @@
+from unittest import mock
+import pytest
+import sys
+
+from sentry_sdk.tracing_utils_py3 import (
+ start_child_span_decorator as start_child_span_decorator_py3,
+)
+from sentry_sdk.utils import logger
+
+if sys.version_info < (3, 6):
+ pytest.skip("Async decorator only works on Python 3.6+", allow_module_level=True)
+
+
+def my_example_function():
+ return "return_of_sync_function"
+
+
+async def my_async_example_function():
+ return "return_of_async_function"
+
+
+def test_trace_decorator_sync_py3():
+ fake_start_child = mock.MagicMock()
+ fake_transaction = mock.MagicMock()
+ fake_transaction.start_child = fake_start_child
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py3.get_current_span",
+ return_value=fake_transaction,
+ ):
+ result = my_example_function()
+ fake_start_child.assert_not_called()
+ assert result == "return_of_sync_function"
+
+ result2 = start_child_span_decorator_py3(my_example_function)()
+ fake_start_child.assert_called_once_with(
+ op="function", description="test_decorator_py3.my_example_function"
+ )
+ assert result2 == "return_of_sync_function"
+
+
+def test_trace_decorator_sync_py3_no_trx():
+ fake_transaction = None
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py3.get_current_span",
+ return_value=fake_transaction,
+ ):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ result = my_example_function()
+ fake_warning.assert_not_called()
+ assert result == "return_of_sync_function"
+
+ result2 = start_child_span_decorator_py3(my_example_function)()
+ fake_warning.assert_called_once_with(
+ "Can not create a child span for %s. "
+ "Please start a Sentry transaction before calling this function.",
+ "test_decorator_py3.my_example_function",
+ )
+ assert result2 == "return_of_sync_function"
+
+
+@pytest.mark.asyncio
+async def test_trace_decorator_async_py3():
+ fake_start_child = mock.MagicMock()
+ fake_transaction = mock.MagicMock()
+ fake_transaction.start_child = fake_start_child
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py3.get_current_span",
+ return_value=fake_transaction,
+ ):
+ result = await my_async_example_function()
+ fake_start_child.assert_not_called()
+ assert result == "return_of_async_function"
+
+ result2 = await start_child_span_decorator_py3(my_async_example_function)()
+ fake_start_child.assert_called_once_with(
+ op="function", description="test_decorator_py3.my_async_example_function"
+ )
+ assert result2 == "return_of_async_function"
+
+
+@pytest.mark.asyncio
+async def test_trace_decorator_async_py3_no_trx():
+ fake_transaction = None
+
+ with mock.patch(
+ "sentry_sdk.tracing_utils_py3.get_current_span",
+ return_value=fake_transaction,
+ ):
+ with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
+ result = await my_async_example_function()
+ fake_warning.assert_not_called()
+ assert result == "return_of_async_function"
+
+ result2 = await start_child_span_decorator_py3(my_async_example_function)()
+ fake_warning.assert_called_once_with(
+ "Can not create a child span for %s. "
+ "Please start a Sentry transaction before calling this function.",
+ "test_decorator_py3.my_async_example_function",
+ )
+ assert result2 == "return_of_async_function"
diff --git a/tests/tracing/test_http_headers.py b/tests/tracing/test_http_headers.py
index 3db967b24b..443bb163e8 100644
--- a/tests/tracing/test_http_headers.py
+++ b/tests/tracing/test_http_headers.py
@@ -1,16 +1,7 @@
-import json
-
import pytest
-import sentry_sdk
-from sentry_sdk.tracing import Transaction, Span
-from sentry_sdk.tracing_utils import (
- compute_tracestate_value,
- extract_sentrytrace_data,
- extract_tracestate_data,
- reinflate_tracestate,
-)
-from sentry_sdk.utils import from_base64, to_base64
+from sentry_sdk.tracing import Transaction
+from sentry_sdk.tracing_utils import extract_sentrytrace_data
try:
@@ -19,142 +10,8 @@
import mock # python < 3.3
-def test_tracestate_computation(sentry_init):
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- sentry_sdk.set_user({"id": 12312013, "segment": "bigs"})
-
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- trace_id="12312012123120121231201212312012",
- )
-
- # force lazy computation to create a value
- transaction.to_tracestate()
-
- computed_value = transaction._sentry_tracestate.replace("sentry=", "")
- # we have to decode and reinflate the data because we can guarantee that the
- # order of the entries in the jsonified dict will be the same here as when
- # the tracestate is computed
- reinflated_trace_data = json.loads(from_base64(computed_value))
-
- assert reinflated_trace_data == {
- "trace_id": "12312012123120121231201212312012",
- "environment": "dogpark",
- "release": "off.leash.park",
- "public_key": "dogsarebadatkeepingsecrets",
- "user": {"id": 12312013, "segment": "bigs"},
- "transaction": "/interactions/other-dogs/new-dog",
- }
-
-
-def test_doesnt_add_new_tracestate_to_transaction_when_none_given(sentry_init):
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- # sentry_tracestate=< value would be passed here >
- )
-
- assert transaction._sentry_tracestate is None
-
-
-def test_adds_tracestate_to_transaction_when_to_traceparent_called(sentry_init):
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- )
-
- # no inherited tracestate, and none created in Transaction constructor
- assert transaction._sentry_tracestate is None
-
- transaction.to_tracestate()
-
- assert transaction._sentry_tracestate is not None
-
-
-def test_adds_tracestate_to_transaction_when_getting_trace_context(sentry_init):
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- )
-
- # no inherited tracestate, and none created in Transaction constructor
- assert transaction._sentry_tracestate is None
-
- transaction.get_trace_context()
-
- assert transaction._sentry_tracestate is not None
-
-
-@pytest.mark.parametrize(
- "set_by", ["inheritance", "to_tracestate", "get_trace_context"]
-)
-def test_tracestate_is_immutable_once_set(sentry_init, monkeypatch, set_by):
- monkeypatch.setattr(
- sentry_sdk.tracing,
- "compute_tracestate_entry",
- mock.Mock(return_value="sentry=doGsaREgReaT"),
- )
-
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- # for each scenario, get to the point where tracestate has been set
- if set_by == "inheritance":
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- sentry_tracestate=("sentry=doGsaREgReaT"),
- )
- else:
- transaction = Transaction(
- name="/interactions/other-dogs/new-dog",
- op="greeting.sniff",
- )
-
- if set_by == "to_tracestate":
- transaction.to_tracestate()
- if set_by == "get_trace_context":
- transaction.get_trace_context()
-
- assert transaction._sentry_tracestate == "sentry=doGsaREgReaT"
-
- # user data would be included in tracestate if it were recomputed at this point
- sentry_sdk.set_user({"id": 12312013, "segment": "bigs"})
-
- # value hasn't changed
- assert transaction._sentry_tracestate == "sentry=doGsaREgReaT"
-
-
@pytest.mark.parametrize("sampled", [True, False, None])
-def test_to_traceparent(sentry_init, sampled):
-
+def test_to_traceparent(sampled):
transaction = Transaction(
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
@@ -164,56 +21,13 @@ def test_to_traceparent(sentry_init, sampled):
traceparent = transaction.to_traceparent()
- trace_id, parent_span_id, parent_sampled = traceparent.split("-")
- assert trace_id == "12312012123120121231201212312012"
- assert parent_span_id == transaction.span_id
- assert parent_sampled == (
- "1" if sampled is True else "0" if sampled is False else ""
- )
-
-
-def test_to_tracestate(sentry_init):
- sentry_init(
- dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
- environment="dogpark",
- release="off.leash.park",
- )
-
- # it correctly uses the value from the transaction itself or the span's
- # containing transaction
- transaction_no_third_party = Transaction(
- trace_id="12312012123120121231201212312012",
- sentry_tracestate="sentry=doGsaREgReaT",
- )
- non_orphan_span = Span()
- non_orphan_span._containing_transaction = transaction_no_third_party
- assert transaction_no_third_party.to_tracestate() == "sentry=doGsaREgReaT"
- assert non_orphan_span.to_tracestate() == "sentry=doGsaREgReaT"
-
- # it combines sentry and third-party values correctly
- transaction_with_third_party = Transaction(
- trace_id="12312012123120121231201212312012",
- sentry_tracestate="sentry=doGsaREgReaT",
- third_party_tracestate="maisey=silly",
- )
- assert (
- transaction_with_third_party.to_tracestate()
- == "sentry=doGsaREgReaT,maisey=silly"
- )
-
- # it computes a tracestate from scratch for orphan transactions
- orphan_span = Span(
- trace_id="12312012123120121231201212312012",
- )
- assert orphan_span._containing_transaction is None
- assert orphan_span.to_tracestate() == "sentry=" + compute_tracestate_value(
- {
- "trace_id": "12312012123120121231201212312012",
- "environment": "dogpark",
- "release": "off.leash.park",
- "public_key": "dogsarebadatkeepingsecrets",
- }
- )
+ parts = traceparent.split("-")
+ assert parts[0] == "12312012123120121231201212312012" # trace_id
+ assert parts[1] == transaction.span_id # parent_span_id
+ if sampled is None:
+ assert len(parts) == 2
+ else:
+ assert parts[2] == "1" if sampled is True else "0" # sampled
@pytest.mark.parametrize("sampling_decision", [True, False])
@@ -228,78 +42,12 @@ def test_sentrytrace_extraction(sampling_decision):
}
-@pytest.mark.parametrize(
- ("incoming_header", "expected_sentry_value", "expected_third_party"),
- [
- # sentry only
- ("sentry=doGsaREgReaT", "sentry=doGsaREgReaT", None),
- # sentry only, invalid (`!` isn't a valid base64 character)
- ("sentry=doGsaREgReaT!", None, None),
- # stuff before
- ("maisey=silly,sentry=doGsaREgReaT", "sentry=doGsaREgReaT", "maisey=silly"),
- # stuff after
- ("sentry=doGsaREgReaT,maisey=silly", "sentry=doGsaREgReaT", "maisey=silly"),
- # stuff before and after
- (
- "charlie=goofy,sentry=doGsaREgReaT,maisey=silly",
- "sentry=doGsaREgReaT",
- "charlie=goofy,maisey=silly",
- ),
- # multiple before
- (
- "charlie=goofy,maisey=silly,sentry=doGsaREgReaT",
- "sentry=doGsaREgReaT",
- "charlie=goofy,maisey=silly",
- ),
- # multiple after
- (
- "sentry=doGsaREgReaT,charlie=goofy,maisey=silly",
- "sentry=doGsaREgReaT",
- "charlie=goofy,maisey=silly",
- ),
- # multiple before and after
- (
- "charlie=goofy,maisey=silly,sentry=doGsaREgReaT,bodhi=floppy,cory=loyal",
- "sentry=doGsaREgReaT",
- "charlie=goofy,maisey=silly,bodhi=floppy,cory=loyal",
- ),
- # only third-party data
- ("maisey=silly", None, "maisey=silly"),
- # invalid third-party data, valid sentry data
- ("maisey_is_silly,sentry=doGsaREgReaT", "sentry=doGsaREgReaT", None),
- # valid third-party data, invalid sentry data
- ("maisey=silly,sentry=doGsaREgReaT!", None, "maisey=silly"),
- # nothing valid at all
- ("maisey_is_silly,sentry=doGsaREgReaT!", None, None),
- ],
-)
-def test_tracestate_extraction(
- incoming_header, expected_sentry_value, expected_third_party
-):
- assert extract_tracestate_data(incoming_header) == {
- "sentry_tracestate": expected_sentry_value,
- "third_party_tracestate": expected_third_party,
- }
-
-
-# TODO (kmclb) remove this parameterization once tracestate is a real feature
-@pytest.mark.parametrize("tracestate_enabled", [True, False])
-def test_iter_headers(sentry_init, monkeypatch, tracestate_enabled):
+def test_iter_headers(monkeypatch):
monkeypatch.setattr(
Transaction,
"to_traceparent",
mock.Mock(return_value="12312012123120121231201212312012-0415201309082013-0"),
)
- monkeypatch.setattr(
- Transaction,
- "to_tracestate",
- mock.Mock(return_value="sentry=doGsaREgReaT,charlie=goofy"),
- )
- monkeypatch.setattr(
- sentry_sdk.tracing,
- "has_tracestate_enabled",
- mock.Mock(return_value=tracestate_enabled),
- )
transaction = Transaction(
name="/interactions/other-dogs/new-dog",
@@ -310,23 +58,3 @@ def test_iter_headers(sentry_init, monkeypatch, tracestate_enabled):
assert (
headers["sentry-trace"] == "12312012123120121231201212312012-0415201309082013-0"
)
- if tracestate_enabled:
- assert "tracestate" in headers
- assert headers["tracestate"] == "sentry=doGsaREgReaT,charlie=goofy"
- else:
- assert "tracestate" not in headers
-
-
-@pytest.mark.parametrize(
- "data",
- [ # comes out with no trailing `=`
- {"name": "Maisey", "birthday": "12/31/12"},
- # comes out with one trailing `=`
- {"dogs": "yes", "cats": "maybe"},
- # comes out with two trailing `=`
- {"name": "Charlie", "birthday": "11/21/12"},
- ],
-)
-def test_tracestate_reinflation(data):
- encoded_tracestate = to_base64(json.dumps(data)).strip("=")
- assert reinflate_tracestate(encoded_tracestate) == data
diff --git a/tests/tracing/test_integration_tests.py b/tests/tracing/test_integration_tests.py
index 486651c754..bf5cabdb64 100644
--- a/tests/tracing/test_integration_tests.py
+++ b/tests/tracing/test_integration_tests.py
@@ -1,7 +1,9 @@
+# coding: utf-8
import weakref
import gc
-
+import re
import pytest
+import random
from sentry_sdk import (
capture_message,
@@ -32,6 +34,9 @@ def test_basic(sentry_init, capture_events, sample_rate):
assert len(events) == 1
event = events[0]
+ assert event["transaction"] == "hi"
+ assert event["transaction_info"]["source"] == "custom"
+
span1, span2 = event["spans"]
parent_span = event
assert span1["tags"]["status"] == "internal_error"
@@ -49,25 +54,28 @@ def test_basic(sentry_init, capture_events, sample_rate):
@pytest.mark.parametrize("sampled", [True, False, None])
@pytest.mark.parametrize("sample_rate", [0.0, 1.0])
-def test_continue_from_headers(sentry_init, capture_events, sampled, sample_rate):
+def test_continue_from_headers(sentry_init, capture_envelopes, sampled, sample_rate):
"""
Ensure data is actually passed along via headers, and that they are read
correctly.
"""
sentry_init(traces_sample_rate=sample_rate)
- events = capture_events()
+ envelopes = capture_envelopes()
# make a parent transaction (normally this would be in a different service)
- with start_transaction(
- name="hi", sampled=True if sample_rate == 0 else None
- ) as parent_transaction:
+ with start_transaction(name="hi", sampled=True if sample_rate == 0 else None):
with start_span() as old_span:
old_span.sampled = sampled
headers = dict(Hub.current.iter_trace_propagation_headers(old_span))
- tracestate = parent_transaction._sentry_tracestate
-
- # child transaction, to prove that we can read 'sentry-trace' and
- # `tracestate` header data correctly
+ headers["baggage"] = (
+ "other-vendor-value-1=foo;bar;baz, "
+ "sentry-trace_id=771a43a4192642f0b136d5159a501700, "
+ "sentry-public_key=49d0f7386ad645858ae85020e393bef3, "
+ "sentry-sample_rate=0.01337, sentry-user_id=Amelie, "
+ "other-vendor-value-2=foo;bar;"
+ )
+
+ # child transaction, to prove that we can read 'sentry-trace' header data correctly
child_transaction = Transaction.continue_from_headers(headers, name="WRONG")
assert child_transaction is not None
assert child_transaction.parent_sampled == sampled
@@ -75,7 +83,16 @@ def test_continue_from_headers(sentry_init, capture_events, sampled, sample_rate
assert child_transaction.same_process_as_parent is False
assert child_transaction.parent_span_id == old_span.span_id
assert child_transaction.span_id != old_span.span_id
- assert child_transaction._sentry_tracestate == tracestate
+
+ baggage = child_transaction._baggage
+ assert baggage
+ assert not baggage.mutable
+ assert baggage.sentry_items == {
+ "public_key": "49d0f7386ad645858ae85020e393bef3",
+ "trace_id": "771a43a4192642f0b136d5159a501700",
+ "user_id": "Amelie",
+ "sample_rate": "0.01337",
+ }
# add child transaction to the scope, to show that the captured message will
# be tagged with the trace id (since it happens while the transaction is
@@ -89,23 +106,91 @@ def test_continue_from_headers(sentry_init, capture_events, sampled, sample_rate
# in this case the child transaction won't be captured
if sampled is False or (sample_rate == 0 and sampled is None):
- trace1, message = events
+ trace1, message = envelopes
+ message_payload = message.get_event()
+ trace1_payload = trace1.get_transaction_event()
- assert trace1["transaction"] == "hi"
+ assert trace1_payload["transaction"] == "hi"
else:
- trace1, message, trace2 = events
+ trace1, message, trace2 = envelopes
+ trace1_payload = trace1.get_transaction_event()
+ message_payload = message.get_event()
+ trace2_payload = trace2.get_transaction_event()
- assert trace1["transaction"] == "hi"
- assert trace2["transaction"] == "ho"
+ assert trace1_payload["transaction"] == "hi"
+ assert trace2_payload["transaction"] == "ho"
assert (
- trace1["contexts"]["trace"]["trace_id"]
- == trace2["contexts"]["trace"]["trace_id"]
+ trace1_payload["contexts"]["trace"]["trace_id"]
+ == trace2_payload["contexts"]["trace"]["trace_id"]
== child_transaction.trace_id
- == message["contexts"]["trace"]["trace_id"]
+ == message_payload["contexts"]["trace"]["trace_id"]
)
- assert message["message"] == "hello"
+ assert trace2.headers["trace"] == baggage.dynamic_sampling_context()
+ assert trace2.headers["trace"] == {
+ "public_key": "49d0f7386ad645858ae85020e393bef3",
+ "trace_id": "771a43a4192642f0b136d5159a501700",
+ "user_id": "Amelie",
+ "sample_rate": "0.01337",
+ }
+
+ assert message_payload["message"] == "hello"
+
+
+@pytest.mark.parametrize("sample_rate", [0.5, 1.0])
+def test_dynamic_sampling_head_sdk_creates_dsc(
+ sentry_init, capture_envelopes, sample_rate, monkeypatch
+):
+ sentry_init(traces_sample_rate=sample_rate, release="foo")
+ envelopes = capture_envelopes()
+
+ # make sure transaction is sampled for both cases
+ monkeypatch.setattr(random, "random", lambda: 0.1)
+
+ transaction = Transaction.continue_from_headers({}, name="Head SDK tx")
+
+ # will create empty mutable baggage
+ baggage = transaction._baggage
+ assert baggage
+ assert baggage.mutable
+ assert baggage.sentry_items == {}
+ assert baggage.third_party_items == ""
+
+ with start_transaction(transaction):
+ with start_span(op="foo", description="foodesc"):
+ pass
+
+ # finish will create a new baggage entry
+ baggage = transaction._baggage
+ trace_id = transaction.trace_id
+
+ assert baggage
+ assert not baggage.mutable
+ assert baggage.third_party_items == ""
+ assert baggage.sentry_items == {
+ "environment": "production",
+ "release": "foo",
+ "sample_rate": str(sample_rate),
+ "transaction": "Head SDK tx",
+ "trace_id": trace_id,
+ }
+
+ expected_baggage = (
+ "sentry-environment=production,sentry-release=foo,sentry-sample_rate=%s,sentry-transaction=Head%%20SDK%%20tx,sentry-trace_id=%s"
+ % (sample_rate, trace_id)
+ )
+ assert sorted(baggage.serialize().split(",")) == sorted(expected_baggage.split(","))
+
+ (envelope,) = envelopes
+ assert envelope.headers["trace"] == baggage.dynamic_sampling_context()
+ assert envelope.headers["trace"] == {
+ "environment": "production",
+ "release": "foo",
+ "sample_rate": str(sample_rate),
+ "transaction": "Head SDK tx",
+ "trace_id": trace_id,
+ }
@pytest.mark.parametrize(
@@ -167,3 +252,27 @@ def capture_event(self, event):
pass
assert len(events) == 1
+
+
+def test_trace_propagation_meta_head_sdk(sentry_init):
+ sentry_init(traces_sample_rate=1.0, release="foo")
+
+ transaction = Transaction.continue_from_headers({}, name="Head SDK tx")
+ meta = None
+ span = None
+
+ with start_transaction(transaction):
+ with start_span(op="foo", description="foodesc") as current_span:
+ span = current_span
+ meta = Hub.current.trace_propagation_meta()
+
+ ind = meta.find(">") + 1
+ sentry_trace, baggage = meta[:ind], meta[ind:]
+
+ assert 'meta name="sentry-trace"' in sentry_trace
+ sentry_trace_content = re.findall('content="([^"]*)"', sentry_trace)[0]
+ assert sentry_trace_content == span.to_traceparent()
+
+ assert 'meta name="baggage"' in baggage
+ baggage_content = re.findall('content="([^"]*)"', baggage)[0]
+ assert baggage_content == transaction.get_baggage().serialize()
diff --git a/tests/tracing/test_misc.py b/tests/tracing/test_misc.py
index 5d6613cd28..0c9d114793 100644
--- a/tests/tracing/test_misc.py
+++ b/tests/tracing/test_misc.py
@@ -4,14 +4,17 @@
import os
import sentry_sdk
-from sentry_sdk import Hub, start_span, start_transaction
+from sentry_sdk import Hub, start_span, start_transaction, set_measurement
+from sentry_sdk.consts import MATCH_ALL
from sentry_sdk.tracing import Span, Transaction
-from sentry_sdk.tracing_utils import has_tracestate_enabled
+from sentry_sdk.tracing_utils import should_propagate_trace
try:
from unittest import mock # python 3.3 and above
+ from unittest.mock import MagicMock
except ImportError:
import mock # python < 3.3
+ from mock import MagicMock
def test_span_trimming(sentry_init, capture_events):
@@ -173,7 +176,7 @@ def test_circular_references(monkeypatch, sentry_init, request):
# request.addfinalizer(lambda: gc.set_debug(~gc.DEBUG_LEAK))
#
# immediately after the initial collection below, so we can see what new
- # objects the garbage collecter has to clean up once `transaction.finish` is
+ # objects the garbage collector has to clean up once `transaction.finish` is
# called and the serializer runs.)
monkeypatch.setattr(
sentry_sdk.client,
@@ -232,17 +235,75 @@ def test_circular_references(monkeypatch, sentry_init, request):
assert gc.collect() == 0
-# TODO (kmclb) remove this test once tracestate is a real feature
-@pytest.mark.parametrize("tracestate_enabled", [True, False, None])
-def test_has_tracestate_enabled(sentry_init, tracestate_enabled):
- experiments = (
- {"propagate_tracestate": tracestate_enabled}
- if tracestate_enabled is not None
- else {}
- )
- sentry_init(_experiments=experiments)
+def test_set_meaurement(sentry_init, capture_events):
+ sentry_init(traces_sample_rate=1.0)
+
+ events = capture_events()
+
+ transaction = start_transaction(name="measuring stuff")
+
+ with pytest.raises(TypeError):
+ transaction.set_measurement()
+
+ with pytest.raises(TypeError):
+ transaction.set_measurement("metric.foo")
+
+ transaction.set_measurement("metric.foo", 123)
+ transaction.set_measurement("metric.bar", 456, unit="second")
+ transaction.set_measurement("metric.baz", 420.69, unit="custom")
+ transaction.set_measurement("metric.foobar", 12, unit="percent")
+ transaction.set_measurement("metric.foobar", 17.99, unit="percent")
+
+ transaction.finish()
+
+ (event,) = events
+ assert event["measurements"]["metric.foo"] == {"value": 123, "unit": ""}
+ assert event["measurements"]["metric.bar"] == {"value": 456, "unit": "second"}
+ assert event["measurements"]["metric.baz"] == {"value": 420.69, "unit": "custom"}
+ assert event["measurements"]["metric.foobar"] == {"value": 17.99, "unit": "percent"}
+
+
+def test_set_meaurement_public_api(sentry_init, capture_events):
+ sentry_init(traces_sample_rate=1.0)
+
+ events = capture_events()
+
+ with start_transaction(name="measuring stuff"):
+ set_measurement("metric.foo", 123)
+ set_measurement("metric.bar", 456, unit="second")
+
+ (event,) = events
+ assert event["measurements"]["metric.foo"] == {"value": 123, "unit": ""}
+ assert event["measurements"]["metric.bar"] == {"value": 456, "unit": "second"}
+
+
+@pytest.mark.parametrize(
+ "trace_propagation_targets,url,expected_propagation_decision",
+ [
+ (None, "http://example.com", False),
+ ([], "http://example.com", False),
+ ([MATCH_ALL], "http://example.com", True),
+ (["localhost"], "localhost:8443/api/users", True),
+ (["localhost"], "http://localhost:8443/api/users", True),
+ (["localhost"], "mylocalhost:8080/api/users", True),
+ ([r"^/api"], "/api/envelopes", True),
+ ([r"^/api"], "/backend/api/envelopes", False),
+ ([r"myApi.com/v[2-4]"], "myApi.com/v2/projects", True),
+ ([r"myApi.com/v[2-4]"], "myApi.com/v1/projects", False),
+ ([r"https:\/\/.*"], "https://example.com", True),
+ (
+ [r"https://.*"],
+ "https://example.com",
+ True,
+ ), # to show escaping is not needed
+ ([r"https://.*"], "http://example.com/insecure/", False),
+ ],
+)
+def test_should_propagate_trace(
+ trace_propagation_targets, url, expected_propagation_decision
+):
+ hub = MagicMock()
+ hub.client = MagicMock()
+ hub.client.options = {"trace_propagation_targets": trace_propagation_targets}
- if tracestate_enabled is True:
- assert has_tracestate_enabled() is True
- else:
- assert has_tracestate_enabled() is False
+ assert should_propagate_trace(hub, url) == expected_propagation_decision
diff --git a/tests/tracing/test_noop_span.py b/tests/tracing/test_noop_span.py
new file mode 100644
index 0000000000..9896afb007
--- /dev/null
+++ b/tests/tracing/test_noop_span.py
@@ -0,0 +1,52 @@
+import sentry_sdk
+from sentry_sdk.tracing import NoOpSpan
+
+# This tests make sure, that the examples from the documentation [1]
+# are working when OTel (OpenTelementry) instrumentation is turned on
+# and therefore the Senntry tracing should not do anything.
+#
+# 1: https://docs.sentry.io/platforms/python/performance/instrumentation/custom-instrumentation/
+
+
+def test_noop_start_transaction(sentry_init):
+ sentry_init(instrumenter="otel", debug=True)
+
+ with sentry_sdk.start_transaction(
+ op="task", name="test_transaction_name"
+ ) as transaction:
+ assert isinstance(transaction, NoOpSpan)
+ assert sentry_sdk.Hub.current.scope.span is transaction
+
+ transaction.name = "new name"
+
+
+def test_noop_start_span(sentry_init):
+ sentry_init(instrumenter="otel", debug=True)
+
+ with sentry_sdk.start_span(op="http", description="GET /") as span:
+ assert isinstance(span, NoOpSpan)
+ assert sentry_sdk.Hub.current.scope.span is span
+
+ span.set_tag("http.response.status_code", 418)
+ span.set_data("http.entity_type", "teapot")
+
+
+def test_noop_transaction_start_child(sentry_init):
+ sentry_init(instrumenter="otel", debug=True)
+
+ transaction = sentry_sdk.start_transaction(name="task")
+ assert isinstance(transaction, NoOpSpan)
+
+ with transaction.start_child(op="child_task") as child:
+ assert isinstance(child, NoOpSpan)
+ assert sentry_sdk.Hub.current.scope.span is child
+
+
+def test_noop_span_start_child(sentry_init):
+ sentry_init(instrumenter="otel", debug=True)
+ span = sentry_sdk.start_span(name="task")
+ assert isinstance(span, NoOpSpan)
+
+ with span.start_child(op="child_task") as child:
+ assert isinstance(child, NoOpSpan)
+ assert sentry_sdk.Hub.current.scope.span is child
diff --git a/tests/tracing/test_sampling.py b/tests/tracing/test_sampling.py
index 9975abad5d..376a4e09dc 100644
--- a/tests/tracing/test_sampling.py
+++ b/tests/tracing/test_sampling.py
@@ -4,7 +4,6 @@
from sentry_sdk import Hub, start_span, start_transaction
from sentry_sdk.tracing import Transaction
-from sentry_sdk.tracing_utils import is_valid_sample_rate
from sentry_sdk.utils import logger
try:
@@ -51,38 +50,6 @@ def test_no_double_sampling(sentry_init, capture_events):
assert len(events) == 1
-@pytest.mark.parametrize(
- "rate",
- [0.0, 0.1231, 1.0, True, False],
-)
-def test_accepts_valid_sample_rate(rate):
- with mock.patch.object(logger, "warning", mock.Mock()):
- result = is_valid_sample_rate(rate)
- assert logger.warning.called is False
- assert result is True
-
-
-@pytest.mark.parametrize(
- "rate",
- [
- "dogs are great", # wrong type
- (0, 1), # wrong type
- {"Maisey": "Charllie"}, # wrong type
- [True, True], # wrong type
- {0.2012}, # wrong type
- float("NaN"), # wrong type
- None, # wrong type
- -1.121, # wrong value
- 1.231, # wrong value
- ],
-)
-def test_warns_on_invalid_sample_rate(rate, StringContaining): # noqa: N803
- with mock.patch.object(logger, "warning", mock.Mock()):
- result = is_valid_sample_rate(rate)
- logger.warning.assert_any_call(StringContaining("Given sample rate is invalid"))
- assert result is False
-
-
@pytest.mark.parametrize("sampling_decision", [True, False])
def test_get_transaction_and_span_from_scope_regardless_of_sampling_decision(
sentry_init, sampling_decision
@@ -109,7 +76,6 @@ def test_uses_traces_sample_rate_correctly(
sentry_init(traces_sample_rate=traces_sample_rate)
with mock.patch.object(random, "random", return_value=0.5):
-
transaction = start_transaction(name="dogpark")
assert transaction.sampled is expected_decision
@@ -126,7 +92,6 @@ def test_uses_traces_sampler_return_value_correctly(
sentry_init(traces_sampler=mock.Mock(return_value=traces_sampler_return_value))
with mock.patch.object(random, "random", return_value=0.5):
-
transaction = start_transaction(name="dogpark")
assert transaction.sampled is expected_decision
diff --git a/tests/utils/test_general.py b/tests/utils/test_general.py
index 03be52ca17..6f53de32c3 100644
--- a/tests/utils/test_general.py
+++ b/tests/utils/test_general.py
@@ -11,10 +11,12 @@
safe_repr,
exceptions_from_error_tuple,
filename_for_module,
- handle_in_app_impl,
iter_event_stacktraces,
to_base64,
from_base64,
+ set_in_app_in_frames,
+ strip_string,
+ AnnotatedValue,
)
from sentry_sdk._compat import text_type, string_types
@@ -31,19 +33,23 @@
def test_safe_repr_never_broken_for_strings(x):
r = safe_repr(x)
assert isinstance(r, text_type)
- assert u"broken repr" not in r
+ assert "broken repr" not in r
def test_safe_repr_regressions():
+ # fmt: off
assert u"лошадь" in safe_repr(u"лошадь")
+ # fmt: on
@pytest.mark.xfail(
sys.version_info < (3,),
reason="Fixing this in Python 2 would break other behaviors",
)
-@pytest.mark.parametrize("prefix", (u"", u"abcd", u"лошадь"))
+# fmt: off
+@pytest.mark.parametrize("prefix", ("", "abcd", u"лошадь"))
@pytest.mark.parametrize("character", u"\x00\x07\x1b\n")
+# fmt: on
def test_safe_repr_non_printable(prefix, character):
"""Check that non-printable characters are escaped"""
string = prefix + character
@@ -127,51 +133,391 @@ def test_parse_invalid_dsn(dsn):
dsn = Dsn(dsn)
-@pytest.mark.parametrize("empty", [None, []])
-def test_in_app(empty):
- assert (
- handle_in_app_impl(
- [{"module": "foo"}, {"module": "bar"}],
- in_app_include=["foo"],
- in_app_exclude=empty,
- )
- == [{"module": "foo", "in_app": True}, {"module": "bar"}]
- )
-
- assert (
- handle_in_app_impl(
- [{"module": "foo"}, {"module": "bar"}],
- in_app_include=["foo"],
- in_app_exclude=["foo"],
- )
- == [{"module": "foo", "in_app": True}, {"module": "bar"}]
+@pytest.mark.parametrize(
+ "frame,in_app_include,in_app_exclude,project_root,resulting_frame",
+ [
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ None,
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ],
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ None,
+ None,
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ],
+ # include
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False, # because there is no module set
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ "in_app": False, # because there is no module set
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ],
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ],
+ # exclude
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/home/ubuntu/fastapi/.venv/lib/python3.10/site-packages/fastapi/routing.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "abs_path": "C:\\Users\\winuser\\AppData\\Roaming\\Python\\Python35\\site-packages\\fastapi\\routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "module": "fastapi.routing",
+ "abs_path": "/usr/lib/python2.7/dist-packages/fastapi/routing.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ],
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ ["main"],
+ None,
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ "in_app": False,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ },
+ None,
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ },
+ ["fastapi"],
+ None,
+ None,
+ {
+ "module": "fastapi.routing",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "module": "fastapi.routing",
+ },
+ None,
+ ["fastapi"],
+ None,
+ {
+ "module": "fastapi.routing",
+ "in_app": False,
+ },
+ ],
+ # with project_root set
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ None,
+ "/home/ubuntu/fastapi",
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ ["main"],
+ None,
+ "/home/ubuntu/fastapi",
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ "in_app": True,
+ },
+ ],
+ [
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ },
+ None,
+ ["main"],
+ "/home/ubuntu/fastapi",
+ {
+ "module": "main",
+ "abs_path": "/home/ubuntu/fastapi/main.py",
+ "in_app": False,
+ },
+ ],
+ ],
+)
+def test_set_in_app_in_frames(
+ frame, in_app_include, in_app_exclude, project_root, resulting_frame
+):
+ new_frames = set_in_app_in_frames(
+ [frame],
+ in_app_include=in_app_include,
+ in_app_exclude=in_app_exclude,
+ project_root=project_root,
)
- assert (
- handle_in_app_impl(
- [{"module": "foo"}, {"module": "bar"}],
- in_app_include=empty,
- in_app_exclude=["foo"],
- )
- == [{"module": "foo", "in_app": False}, {"module": "bar", "in_app": True}]
- )
+ assert new_frames[0] == resulting_frame
def test_iter_stacktraces():
- assert (
- set(
- iter_event_stacktraces(
- {
- "threads": {"values": [{"stacktrace": 1}]},
- "stacktrace": 2,
- "exception": {"values": [{"stacktrace": 3}]},
- }
- )
+ assert set(
+ iter_event_stacktraces(
+ {
+ "threads": {"values": [{"stacktrace": 1}]},
+ "stacktrace": 2,
+ "exception": {"values": [{"stacktrace": 3}]},
+ }
)
- == {1, 2, 3}
- )
+ ) == {1, 2, 3}
+# fmt: off
@pytest.mark.parametrize(
("original", "base64_encoded"),
[
@@ -191,6 +537,7 @@ def test_iter_stacktraces():
),
],
)
+# fmt: on
def test_successful_base64_conversion(original, base64_encoded):
# all unicode characters should be handled correctly
assert to_base64(original) == base64_encoded
@@ -223,3 +570,24 @@ def test_failed_base64_conversion(input):
# failures
if type(input) not in string_types:
assert to_base64(input) is None
+
+
+def test_strip_string():
+ # If value is None returns None.
+ assert strip_string(None) is None
+
+ # If max_length is not passed, returns the full text (up to 1024 bytes).
+ text_1024_long = "a" * 1024
+ assert strip_string(text_1024_long).count("a") == 1024
+
+ # If value exceeds the max_length, returns an AnnotatedValue.
+ text_1025_long = "a" * 1025
+ stripped_text = strip_string(text_1025_long)
+ assert isinstance(stripped_text, AnnotatedValue)
+ assert stripped_text.value.count("a") == 1021 # + '...' is 1024
+
+ # If text has unicode characters, it counts bytes and not number of characters.
+ # fmt: off
+ text_with_unicode_character = u"éê"
+ assert strip_string(text_with_unicode_character, max_length=2).value == u"é..."
+ # fmt: on
diff --git a/tests/utils/test_transaction.py b/tests/utils/test_transaction.py
index e1aa12308f..bfb87f4c29 100644
--- a/tests/utils/test_transaction.py
+++ b/tests/utils/test_transaction.py
@@ -1,5 +1,15 @@
+import sys
+from functools import partial
+
+import pytest
+
from sentry_sdk.utils import transaction_from_function
+try:
+ from functools import partialmethod
+except ImportError:
+ pass
+
class MyClass:
def myfunc(self):
@@ -10,6 +20,16 @@ def myfunc():
pass
+@partial
+def my_partial():
+ pass
+
+
+my_lambda = lambda: None
+
+my_partial_lambda = partial(lambda: None)
+
+
def test_transaction_from_function():
x = transaction_from_function
assert x(MyClass) == "tests.utils.test_transaction.MyClass"
@@ -18,3 +38,26 @@ def test_transaction_from_function():
assert x(None) is None
assert x(42) is None
assert x(lambda: None).endswith("")
+ assert x(my_lambda) == "tests.utils.test_transaction."
+ assert (
+ x(my_partial) == "partial()"
+ )
+ assert (
+ x(my_partial_lambda)
+ == "partial(>)"
+ )
+
+
+@pytest.mark.skipif(sys.version_info < (3, 4), reason="Require python 3.4 or higher")
+def test_transaction_from_function_partialmethod():
+ x = transaction_from_function
+
+ class MyPartialClass:
+ @partialmethod
+ def my_partial_method(self):
+ pass
+
+ assert (
+ x(MyPartialClass.my_partial_method)
+ == "partialmethod(.MyPartialClass.my_partial_method>)"
+ )
diff --git a/tox.ini b/tox.ini
index bd17e7fe58..040d6659df 100644
--- a/tox.ini
+++ b/tox.ini
@@ -5,86 +5,157 @@
[tox]
envlist =
- # === Core ===
- py{2.7,3.4,3.5,3.6,3.7,3.8,3.9,3.10}
- pypy
-
+ # === Common ===
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-common
# === Integrations ===
- # General format is {pythonversion}-{integrationname}-{frameworkversion}
+ # General format is {pythonversion}-{integrationname}-v{frameworkversion}
# 1 blank line between different integrations
# Each framework version should only be mentioned once. I.e:
- # {py3.7,py3.10}-django-{3.2}
- # {py3.10}-django-{4.0}
+ # {py3.7,py3.10}-django-v{3.2}
+ # {py3.10}-django-v{4.0}
# instead of:
- # {py3.7}-django-{3.2}
- # {py3.7,py3.10}-django-{3.2,4.0}
+ # {py3.7}-django-v{3.2}
+ # {py3.7,py3.10}-django-v{3.2,4.0}
- {pypy,py2.7,py3.5}-django-{1.8,1.9,1.10}
- {pypy,py2.7}-django-{1.8,1.9,1.10,1.11}
- {py3.5,py3.6,py3.7}-django-{2.0,2.1}
- {py3.7,py3.8,py3.9,py3.10}-django-{2.2,3.0,3.1,3.2}
+ # AIOHTTP
+ {py3.7}-aiohttp-v{3.5}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-aiohttp-v{3.6}
- {pypy,py2.7,py3.4,py3.5,py3.6,py3.7,py3.8,py3.9}-flask-{0.10,0.11,0.12,1.0}
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-flask-1.1
- {py3.6,py3.8,py3.9,py3.10}-flask-2.0
+ # Arq
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-arq
- {py3.7,py3.8,py3.9,py3.10}-quart
+ # Asgi
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-asgi
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-bottle-0.12
+ # AWS Lambda
+ # The aws_lambda tests deploy to the real AWS and have their own matrix of Python versions.
+ {py3.7}-aws_lambda
- {pypy,py2.7,py3.5,py3.6,py3.7}-falcon-1.4
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-falcon-2.0
+ # Beam
+ {py3.7}-beam-v{2.12,2.13,2.32,2.33}
- {py3.5,py3.6,py3.7}-sanic-{0.8,18}
- {py3.6,py3.7}-sanic-19
- {py3.6,py3.7,py3.8}-sanic-20
- {py3.7,py3.8,py3.9,py3.10}-sanic-21
+ # Boto3
+ {py2.7,py3.6,py3.7,py3.8}-boto3-v{1.9,1.10,1.11,1.12,1.13,1.14,1.15,1.16}
- {pypy,py2.7}-celery-3
- {pypy,py2.7,py3.5,py3.6}-celery-{4.1,4.2}
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8}-celery-{4.3,4.4}
- {py3.6,py3.7,py3.8,py3.9,py3.10}-celery-5.0
+ # Bottle
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-bottle-v{0.12}
- py3.7-beam-{2.12,2.13,2.32,2.33}
+ # Celery
+ {py2.7}-celery-v{3}
+ {py2.7,py3.5,py3.6}-celery-v{4.1,4.2}
+ {py2.7,py3.5,py3.6,py3.7,py3.8}-celery-v{4.3,4.4}
+ {py3.6,py3.7,py3.8}-celery-v{5.0}
+ {py3.7,py3.8,py3.9,py3.10}-celery-v{5.1,5.2}
+ # TODO: enable when celery is ready {py3.7,py3.8,py3.9,py3.10,py3.11}-celery-v{5.3}
- # The aws_lambda tests deploy to the real AWS and have their own matrix of Python versions.
- py3.7-aws_lambda
+ # Chalice
+ {py3.6,py3.7,py3.8}-chalice-v{1.16,1.17,1.18,1.19,1.20}
- py3.7-gcp
+ # Cloud Resource Context
+ {py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-cloud_resource_context
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-pyramid-{1.6,1.7,1.8,1.9,1.10}
+ # Django
+ # - Django 1.x
+ {py2.7,py3.5}-django-v{1.8,1.9,1.10}
+ {py2.7,py3.5,py3.6,py3.7}-django-v{1.11}
+ # - Django 2.x
+ {py3.5,py3.6,py3.7}-django-v{2.0,2.1}
+ {py3.5,py3.6,py3.7,py3.8,py3.9}-django-v{2.2}
+ # - Django 3.x
+ {py3.6,py3.7,py3.8,py3.9}-django-v{3.0,3.1}
+ {py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-django-v{3.2}
+ # - Django 4.x
+ {py3.8,py3.9,py3.10,py3.11}-django-v{4.0,4.1}
- {pypy,py2.7,py3.5,py3.6}-rq-{0.6,0.7,0.8,0.9,0.10,0.11}
- {pypy,py2.7,py3.5,py3.6,py3.7,py3.8,py3.9}-rq-{0.12,0.13,1.0,1.1,1.2,1.3}
- {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-rq-{1.4,1.5}
+ # Falcon
+ {py2.7,py3.5,py3.6,py3.7}-falcon-v{1.4}
+ {py2.7,py3.5,py3.6,py3.7}-falcon-v{2.0}
+ {py3.5,py3.6,py3.7,py3.8,py3.9}-falcon-v{3.0}
- py3.7-aiohttp-3.5
- {py3.7,py3.8,py3.9,py3.10}-aiohttp-3.6
+ # FastAPI
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-fastapi
- {py3.7,py3.8,py3.9}-tornado-{5}
- {py3.7,py3.8,py3.9,py3.10}-tornado-{6}
+ # Flask
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9}-flask-v{0.11,0.12,1.0}
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-flask-v{1.1}
+ {py3.6,py3.8,py3.9,py3.10,py3.11}-flask-v{2.0}
- {py3.5,py3.6,py3.7,py3.8,py3.9}-trytond-{4.6,5.0,5.2}
- {py3.6,py3.7,py3.8,py3.9,py3.10}-trytond-{5.4}
+ # Gevent
+ {py2.7,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-gevent
- {py2.7,py3.8,py3.9}-requests
+ # GCP
+ {py3.7}-gcp
+
+ # Grpc
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-grpc-v{1.21.1,1.22.1,1.23.1,1.24.1,1.25.0,1.26.0,1.27.1,1.28.1,1.29.0,1.30.0,1.31.0,1.32.0,1.33.1,1.34.0,1.36.0,1.37.0,1.38.0,1.39.0,1.40.0,1.41.1,1.43.0,1.44.0,1.46.1,1.48.1,1.51.3,1.53.0}
+
+ # HTTPX
+ {py3.6,py3.7,py3.8,py3.9}-httpx-v{0.16,0.17,0.18}
+ {py3.6,py3.7,py3.8,py3.9,py3.10}-httpx-v{0.19,0.20,0.21,0.22}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-httpx-v{0.23}
+
+ # Huey
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-huey-2
+
+ # Loguru
+ {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-loguru-v{0.5,0.6,0.7}
+
+ # OpenTelemetry (OTel)
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-opentelemetry
+
+ # pure_eval
+ {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-pure_eval
+
+ # PyMongo (Mongo DB)
+ {py2.7,py3.6}-pymongo-v{3.1}
+ {py2.7,py3.6,py3.7,py3.8,py3.9}-pymongo-v{3.12}
+ {py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-pymongo-v{4.0}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-pymongo-v{4.1,4.2}
+ # Pyramid
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-pyramid-v{1.6,1.7,1.8,1.9,1.10}
+
+ # Quart
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-quart-v{0.16,0.17,0.18}
+
+ # Redis
{py2.7,py3.7,py3.8,py3.9}-redis
- {py2.7,py3.7,py3.8,py3.9}-rediscluster-{1,2}
- py{3.7,3.8,3.9,3.10}-asgi
+ # Redis Cluster
+ {py2.7,py3.7,py3.8,py3.9}-rediscluster-v{1,2.1.0,2}
+
+ # Requests
+ {py2.7,py3.8,py3.9}-requests
+
+ # RQ (Redis Queue)
+ {py2.7,py3.5,py3.6}-rq-v{0.6,0.7,0.8,0.9,0.10,0.11}
+ {py2.7,py3.5,py3.6,py3.7,py3.8,py3.9}-rq-v{0.12,0.13,1.0,1.1,1.2,1.3}
+ {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-rq-v{1.4,1.5}
- {py2.7,py3.7,py3.8,py3.9,py3.10}-sqlalchemy-{1.2,1.3}
+ # Sanic
+ {py3.5,py3.6,py3.7}-sanic-v{0.8,18}
+ {py3.6,py3.7}-sanic-v{19}
+ {py3.6,py3.7,py3.8}-sanic-v{20}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-sanic-v{21}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-sanic-v{22}
+ # Starlette
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-starlette-v{0.19.1,0.20,0.21}
- {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10}-pure_eval
+ # Starlite
+ {py3.8,py3.9,py3.10,py3.11}-starlite
- {py3.6,py3.7,py3.8}-chalice-{1.16,1.17,1.18,1.19,1.20}
+ # SQL Alchemy
+ {py2.7,py3.7,py3.8,py3.9,py3.10,py3.11}-sqlalchemy-v{1.2,1.3}
- {py2.7,py3.6,py3.7,py3.8}-boto3-{1.9,1.10,1.11,1.12,1.13,1.14,1.15,1.16}
+ # Tornado
+ {py3.7,py3.8,py3.9}-tornado-v{5}
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-tornado-v{6}
- {py3.6,py3.7,py3.8,py3.9,py3.10}-httpx-{0.16,0.17}
+ # Trytond
+ {py3.5,py3.6,py3.7,py3.8,py3.9}-trytond-v{4.6,5.0,5.2}
+ {py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-trytond-v{5.4}
[testenv]
deps =
@@ -93,184 +164,321 @@ deps =
# with the -r flag
-r test-requirements.txt
- py3.4: colorama==0.4.1
- py3.4: watchdog==0.10.7
-
- django-{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: djangorestframework>=3.0.0,<4.0.0
+ py3.4-common: colorama==0.4.1
+ py3.4-common: watchdog==0.10.7
+ py3.8-common: hypothesis
- {py3.7,py3.8,py3.9,py3.10}-django-{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: channels>2
- {py3.7,py3.8,py3.9,py3.10}-django-{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: pytest-asyncio
- {py2.7,py3.7,py3.8,py3.9,py3.10}-django-{1.11,2.2,3.0,3.1,3.2}: psycopg2-binary
-
- django-{1.8,1.9,1.10,1.11,2.0,2.1}: pytest-django<4.0
- django-{2.2,3.0,3.1,3.2}: pytest-django>=4.0
- django-{2.2,3.0,3.1,3.2}: Werkzeug<2.0
+ linters: -r linter-requirements.txt
+ linters: werkzeug<2.3.0
- django-1.8: Django>=1.8,<1.9
- django-1.9: Django>=1.9,<1.10
- django-1.10: Django>=1.10,<1.11
- django-1.11: Django>=1.11,<1.12
- django-2.0: Django>=2.0,<2.1
- django-2.1: Django>=2.1,<2.2
- django-2.2: Django>=2.2,<2.3
- django-3.0: Django>=3.0,<3.1
- django-3.1: Django>=3.1,<3.2
- django-3.2: Django>=3.2,<3.3
+ # Common
+ {py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-common: pytest-asyncio
- flask: flask-login
- flask-0.10: Flask>=0.10,<0.11
- flask-0.11: Flask>=0.11,<0.12
- flask-0.12: Flask>=0.12,<0.13
- flask-1.0: Flask>=1.0,<1.1
- flask-1.1: Flask>=1.1,<1.2
- flask-2.0: Flask>=2.0,<2.1
-
- quart: quart>=0.16.1
- quart: quart-auth
- quart: pytest-asyncio
+ # AIOHTTP
+ aiohttp-v3.4: aiohttp>=3.4.0,<3.5.0
+ aiohttp-v3.5: aiohttp>=3.5.0,<3.6.0
+ aiohttp: pytest-aiohttp
- bottle-0.12: bottle>=0.12,<0.13
+ # Arq
+ arq: arq>=0.23.0
+ arq: fakeredis>=2.2.0,<2.8
+ arq: pytest-asyncio
+ arq: async-timeout
- falcon-1.4: falcon>=1.4,<1.5
- falcon-2.0: falcon>=2.0.0rc3,<3.0
+ # Asgi
+ asgi: pytest-asyncio
+ asgi: async-asgi-testclient
- sanic-0.8: sanic>=0.8,<0.9
- sanic-18: sanic>=18.0,<19.0
- sanic-19: sanic>=19.0,<20.0
- sanic-20: sanic>=20.0,<21.0
- sanic-21: sanic>=21.0,<22.0
- {py3.7,py3.8,py3.9,py3.10}-sanic-21: sanic_testing
- {py3.5,py3.6}-sanic: aiocontextvars==0.2.1
- sanic: aiohttp
- py3.5-sanic: ujson<4
+ # AWS Lambda
+ aws_lambda: boto3
- beam-2.12: apache-beam>=2.12.0, <2.13.0
- beam-2.13: apache-beam>=2.13.0, <2.14.0
- beam-2.32: apache-beam>=2.32.0, <2.33.0
- beam-2.33: apache-beam>=2.33.0, <2.34.0
+ # Beam
+ beam-v2.12: apache-beam>=2.12.0, <2.13.0
+ beam-v2.13: apache-beam>=2.13.0, <2.14.0
+ beam-v2.32: apache-beam>=2.32.0, <2.33.0
+ beam-v2.33: apache-beam>=2.33.0, <2.34.0
beam-master: git+https://github.com/apache/beam#egg=apache-beam&subdirectory=sdks/python
+ # Boto3
+ boto3-v1.9: boto3>=1.9,<1.10
+ boto3-v1.10: boto3>=1.10,<1.11
+ boto3-v1.11: boto3>=1.11,<1.12
+ boto3-v1.12: boto3>=1.12,<1.13
+ boto3-v1.13: boto3>=1.13,<1.14
+ boto3-v1.14: boto3>=1.14,<1.15
+ boto3-v1.15: boto3>=1.15,<1.16
+ boto3-v1.16: boto3>=1.16,<1.17
+
+ # Bottle
+ bottle: Werkzeug<2.1.0
+ bottle-v0.12: bottle>=0.12,<0.13
+
+ # Celery
celery: redis
- celery-3: Celery>=3.1,<4.0
- celery-4.1: Celery>=4.1,<4.2
- celery-4.2: Celery>=4.2,<4.3
- celery-4.3: Celery>=4.3,<4.4
+ celery-v3: Celery>=3.1,<4.0
+ celery-v4.1: Celery>=4.1,<4.2
+ celery-v4.2: Celery>=4.2,<4.3
+ celery-v4.3: Celery>=4.3,<4.4
# https://github.com/celery/vine/pull/29#issuecomment-689498382
celery-4.3: vine<5.0.0
# https://github.com/celery/celery/issues/6153
- celery-4.4: Celery>=4.4,<4.5,!=4.4.4
- celery-5.0: Celery>=5.0,<5.1
+ celery-v4.4: Celery>=4.4,<4.5,!=4.4.4
+ celery-v5.0: Celery>=5.0,<5.1
+ celery-v5.1: Celery>=5.1,<5.2
+ celery-v5.2: Celery>=5.2,<5.3
+
+ {py3.5}-celery: newrelic<6.0.0
+ {py3.7}-celery: importlib-metadata<5.0
+ {py2.7,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-celery: newrelic
+
+ # Chalice
+ chalice-v1.16: chalice>=1.16.0,<1.17.0
+ chalice-v1.17: chalice>=1.17.0,<1.18.0
+ chalice-v1.18: chalice>=1.18.0,<1.19.0
+ chalice-v1.19: chalice>=1.19.0,<1.20.0
+ chalice-v1.20: chalice>=1.20.0,<1.21.0
+ chalice: pytest-chalice==0.0.5
- py3.5-celery: newrelic<6.0.0
- {pypy,py2.7,py3.6,py3.7,py3.8,py3.9,py3.10}-celery: newrelic
+ # Django
+ django: Werkzeug<2.1.0
+ django-v{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: djangorestframework>=3.0.0,<4.0.0
+
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-django-v{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: channels[daphne]>2
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-django-v{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: pytest-asyncio
+ {py2.7,py3.7,py3.8,py3.9,py3.10,py3.11}-django-v{1.11,2.2,3.0,3.1,3.2}: psycopg2-binary
+
+ django-v{1.8,1.9,1.10,1.11,2.0,2.1}: pytest-django<4.0
+ django-v{2.2,3.0,3.1,3.2}: pytest-django>=4.0
+ django-v{2.2,3.0,3.1,3.2}: Werkzeug<2.0
+
+ django-v{4.0,4.1}: djangorestframework
+ django-v{4.0,4.1}: pytest-asyncio
+ django-v{4.0,4.1}: psycopg2-binary
+ django-v{4.0,4.1}: pytest-django
+ django-v{4.0,4.1}: Werkzeug
+
+ django-v1.8: Django>=1.8,<1.9
+ django-v1.9: Django>=1.9,<1.10
+ django-v1.10: Django>=1.10,<1.11
+ django-v1.11: Django>=1.11,<1.12
+ django-v2.0: Django>=2.0,<2.1
+ django-v2.1: Django>=2.1,<2.2
+ django-v2.2: Django>=2.2,<2.3
+ django-v3.0: Django>=3.0,<3.1
+ django-v3.1: Django>=3.1,<3.2
+ django-v3.2: Django>=3.2,<3.3
+ django-v4.0: Django>=4.0,<4.1
+ django-v4.1: Django>=4.1,<4.2
+
+ # Falcon
+ falcon-v1.4: falcon>=1.4,<1.5
+ falcon-v2.0: falcon>=2.0.0rc3,<3.0
+ falcon-v3.0: falcon>=3.0.0,<3.1.0
+
+ # FastAPI
+ fastapi: fastapi
+ fastapi: httpx
+ fastapi: pytest-asyncio
+ fastapi: python-multipart
+ fastapi: requests
+
+ # Flask
+ flask: flask-login
+ flask: Werkzeug<2.1.0
+ flask-v0.11: Flask>=0.11,<0.12
+ flask-v0.12: Flask>=0.12,<0.13
+ flask-v1.0: Flask>=1.0,<1.1
+ flask-v1.1: Flask>=1.1,<1.2
+ flask-v2.0: Flask>=2.0,<2.1
+
+ # Gevent
+ # See http://www.gevent.org/install.html#older-versions-of-python
+ # for justification of the versions pinned below
+ py3.4-gevent: gevent==1.4.0
+ py3.5-gevent: gevent==20.9.0
+ # See https://stackoverflow.com/questions/51496550/runtime-warning-greenlet-greenlet-size-changed
+ # for justification why greenlet is pinned here
+ py3.5-gevent: greenlet==0.4.17
+ {py2.7,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}-gevent: gevent>=22.10.0, <22.11.0
+
+ # Grpc
+ grpc: grpcio-tools
+ grpc: protobuf
+ grpc: mypy-protobuf
+ grpc: types-protobuf
+
+ # HTTPX
+ httpx: pytest-httpx
+ httpx-v0.16: httpx>=0.16,<0.17
+ httpx-v0.17: httpx>=0.17,<0.18
+ httpx-v0.18: httpx>=0.18,<0.19
+ httpx-v0.19: httpx>=0.19,<0.20
+ httpx-v0.20: httpx>=0.20,<0.21
+ httpx-v0.21: httpx>=0.21,<0.22
+ httpx-v0.22: httpx>=0.22,<0.23
+ httpx-v0.23: httpx>=0.23,<0.24
+
+ # Huey
+ huey-2: huey>=2.0
+
+ # Loguru
+ loguru-v0.5: loguru>=0.5.0,<0.6.0
+ loguru-v0.6: loguru>=0.6.0,<0.7.0
+ loguru-v0.7: loguru>=0.7.0,<0.8.0
+
+ # OpenTelemetry (OTel)
+ opentelemetry: opentelemetry-distro
+
+ # pure_eval
+ pure_eval: pure_eval
+ # PyMongo (MongoDB)
+ pymongo: mockupdb
+ pymongo-v3.1: pymongo>=3.1,<3.2
+ pymongo-v3.12: pymongo>=3.12,<4.0
+ pymongo-v4.0: pymongo>=4.0,<4.1
+ pymongo-v4.1: pymongo>=4.1,<4.2
+ pymongo-v4.2: pymongo>=4.2,<4.3
+
+ # Pyramid
+ pyramid: Werkzeug<2.1.0
+ pyramid-v1.6: pyramid>=1.6,<1.7
+ pyramid-v1.7: pyramid>=1.7,<1.8
+ pyramid-v1.8: pyramid>=1.8,<1.9
+ pyramid-v1.9: pyramid>=1.9,<1.10
+ pyramid-v1.10: pyramid>=1.10,<1.11
+
+ # Quart
+ quart: quart-auth
+ quart: pytest-asyncio
+ quart-v0.16: blinker<1.6
+ quart-v0.16: jinja2<3.1.0
+ quart-v0.16: Werkzeug<2.1.0
+ quart-v0.17: blinker<1.6
+ quart-v0.16: quart>=0.16.1,<0.17.0
+ quart-v0.17: quart>=0.17.0,<0.18.0
+ quart-v0.18: quart>=0.18.0,<0.19.0
+
+ # Requests
requests: requests>=2.0
- aws_lambda: boto3
+ # Redis
+ redis: fakeredis<1.7.4
- pyramid-1.6: pyramid>=1.6,<1.7
- pyramid-1.7: pyramid>=1.7,<1.8
- pyramid-1.8: pyramid>=1.8,<1.9
- pyramid-1.9: pyramid>=1.9,<1.10
- pyramid-1.10: pyramid>=1.10,<1.11
+ # Redis Cluster
+ rediscluster-v1: redis-py-cluster>=1.0.0,<2.0.0
+ rediscluster-v2.1.0: redis-py-cluster>=2.0.0,<2.1.1
+ rediscluster-v2: redis-py-cluster>=2.1.1,<3.0.0
+ # RQ (Redis Queue)
# https://github.com/jamesls/fakeredis/issues/245
- rq-{0.6,0.7,0.8,0.9,0.10,0.11,0.12}: fakeredis<1.0
- rq-{0.6,0.7,0.8,0.9,0.10,0.11,0.12}: redis<3.2.2
- rq-{0.13,1.0,1.1,1.2,1.3,1.4,1.5}: fakeredis>=1.0
-
- rq-0.6: rq>=0.6,<0.7
- rq-0.7: rq>=0.7,<0.8
- rq-0.8: rq>=0.8,<0.9
- rq-0.9: rq>=0.9,<0.10
- rq-0.10: rq>=0.10,<0.11
- rq-0.11: rq>=0.11,<0.12
- rq-0.12: rq>=0.12,<0.13
- rq-0.13: rq>=0.13,<0.14
- rq-1.0: rq>=1.0,<1.1
- rq-1.1: rq>=1.1,<1.2
- rq-1.2: rq>=1.2,<1.3
- rq-1.3: rq>=1.3,<1.4
- rq-1.4: rq>=1.4,<1.5
- rq-1.5: rq>=1.5,<1.6
-
- aiohttp-3.4: aiohttp>=3.4.0,<3.5.0
- aiohttp-3.5: aiohttp>=3.5.0,<3.6.0
- aiohttp: pytest-aiohttp
-
- tornado-5: tornado>=5,<6
- tornado-6: tornado>=6.0a1
-
- trytond-5.4: trytond>=5.4,<5.5
- trytond-5.2: trytond>=5.2,<5.3
- trytond-5.0: trytond>=5.0,<5.1
- trytond-4.6: trytond>=4.6,<4.7
-
- trytond-{4.6,4.8,5.0,5.2,5.4}: werkzeug<2.0
-
- redis: fakeredis
-
- rediscluster-1: redis-py-cluster>=1.0.0,<2.0.0
- rediscluster-2: redis-py-cluster>=2.0.0,<3.0.0
-
- asgi: starlette
- asgi: requests
- asgi: fastapi
-
- sqlalchemy-1.2: sqlalchemy>=1.2,<1.3
- sqlalchemy-1.3: sqlalchemy>=1.3,<1.4
-
- linters: -r linter-requirements.txt
-
- py3.8: hypothesis
-
- pure_eval: pure_eval
- chalice-1.16: chalice>=1.16.0,<1.17.0
- chalice-1.17: chalice>=1.17.0,<1.18.0
- chalice-1.18: chalice>=1.18.0,<1.19.0
- chalice-1.19: chalice>=1.19.0,<1.20.0
- chalice-1.20: chalice>=1.20.0,<1.21.0
- chalice: pytest-chalice==0.0.5
-
- boto3-1.9: boto3>=1.9,<1.10
- boto3-1.10: boto3>=1.10,<1.11
- boto3-1.11: boto3>=1.11,<1.12
- boto3-1.12: boto3>=1.12,<1.13
- boto3-1.13: boto3>=1.13,<1.14
- boto3-1.14: boto3>=1.14,<1.15
- boto3-1.15: boto3>=1.15,<1.16
- boto3-1.16: boto3>=1.16,<1.17
-
- httpx-0.16: httpx>=0.16,<0.17
- httpx-0.17: httpx>=0.17,<0.18
+ rq-v{0.6,0.7,0.8,0.9,0.10,0.11,0.12}: fakeredis<1.0
+ rq-v{0.6,0.7,0.8,0.9,0.10,0.11,0.12}: redis<3.2.2
+ rq-v{0.13,1.0,1.1,1.2,1.3,1.4,1.5}: fakeredis>=1.0,<1.7.4
+
+ rq-v0.6: rq>=0.6,<0.7
+ rq-v0.7: rq>=0.7,<0.8
+ rq-v0.8: rq>=0.8,<0.9
+ rq-v0.9: rq>=0.9,<0.10
+ rq-v0.10: rq>=0.10,<0.11
+ rq-v0.11: rq>=0.11,<0.12
+ rq-v0.12: rq>=0.12,<0.13
+ rq-v0.13: rq>=0.13,<0.14
+ rq-v1.0: rq>=1.0,<1.1
+ rq-v1.1: rq>=1.1,<1.2
+ rq-v1.2: rq>=1.2,<1.3
+ rq-v1.3: rq>=1.3,<1.4
+ rq-v1.4: rq>=1.4,<1.5
+ rq-v1.5: rq>=1.5,<1.6
+
+ # Sanic
+ sanic-v0.8: sanic>=0.8,<0.9
+ sanic-v18: sanic>=18.0,<19.0
+ sanic-v19: sanic>=19.0,<20.0
+ sanic-v20: sanic>=20.0,<21.0
+ sanic-v21: sanic>=21.0,<22.0
+ sanic-v22: sanic>=22.0,<22.9.0
+
+ sanic: websockets<11.0
+ sanic: aiohttp
+ sanic-v21: sanic_testing<22
+ sanic-v22: sanic_testing<22.9.0
+ {py3.5,py3.6}-sanic: aiocontextvars==0.2.1
+ {py3.5}-sanic: ujson<4
+
+ # Starlette
+ starlette: pytest-asyncio
+ starlette: python-multipart
+ starlette: requests
+ starlette-v0.21: httpx
+ starlette-v0.19.1: starlette==0.19.1
+ starlette-v0.20: starlette>=0.20.0,<0.21.0
+ starlette-v0.21: starlette>=0.21.0,<0.22.0
+
+ # Starlite
+ starlite: starlite
+ starlite: pytest-asyncio
+ starlite: python-multipart
+ starlite: requests
+ starlite: cryptography
+ {py3.8,py3.9}-starlite: typing-extensions==4.5.0 # this is used by pydantic, which is used by starlite. When the problem is fixed in here or pydantic, this can be removed
+
+ # SQLAlchemy
+ sqlalchemy-v1.2: sqlalchemy>=1.2,<1.3
+ sqlalchemy-v1.3: sqlalchemy>=1.3,<1.4
+
+ # Tornado
+ tornado-v5: tornado>=5,<6
+ tornado-v6: tornado>=6.0a1
+
+ # Trytond
+ trytond-v5.4: trytond>=5.4,<5.5
+ trytond-v5.2: trytond>=5.2,<5.3
+ trytond-v5.0: trytond>=5.0,<5.1
+ trytond-v4.6: trytond>=4.6,<4.7
+
+ trytond-v{4.6,4.8,5.0,5.2,5.4}: werkzeug<2.0
setenv =
PYTHONDONTWRITEBYTECODE=1
- TESTPATH=tests
+ common: TESTPATH=tests
+ aiohttp: TESTPATH=tests/integrations/aiohttp
+ arq: TESTPATH=tests/integrations/arq
+ asgi: TESTPATH=tests/integrations/asgi
+ aws_lambda: TESTPATH=tests/integrations/aws_lambda
beam: TESTPATH=tests/integrations/beam
- django: TESTPATH=tests/integrations/django
- flask: TESTPATH=tests/integrations/flask
- quart: TESTPATH=tests/integrations/quart
+ boto3: TESTPATH=tests/integrations/boto3
bottle: TESTPATH=tests/integrations/bottle
- falcon: TESTPATH=tests/integrations/falcon
celery: TESTPATH=tests/integrations/celery
- requests: TESTPATH=tests/integrations/requests
- aws_lambda: TESTPATH=tests/integrations/aws_lambda
+ chalice: TESTPATH=tests/integrations/chalice
+ cloud_resource_context: TESTPATH=tests/integrations/cloud_resource_context
+ django: TESTPATH=tests/integrations/django
+ falcon: TESTPATH=tests/integrations/falcon
+ fastapi: TESTPATH=tests/integrations/fastapi
+ flask: TESTPATH=tests/integrations/flask
+ # run all tests with gevent
+ gevent: TESTPATH=tests
gcp: TESTPATH=tests/integrations/gcp
- sanic: TESTPATH=tests/integrations/sanic
+ httpx: TESTPATH=tests/integrations/httpx
+ huey: TESTPATH=tests/integrations/huey
+ loguru: TESTPATH=tests/integrations/loguru
+ opentelemetry: TESTPATH=tests/integrations/opentelemetry
+ pure_eval: TESTPATH=tests/integrations/pure_eval
+ pymongo: TESTPATH=tests/integrations/pymongo
pyramid: TESTPATH=tests/integrations/pyramid
- rq: TESTPATH=tests/integrations/rq
- aiohttp: TESTPATH=tests/integrations/aiohttp
- tornado: TESTPATH=tests/integrations/tornado
- trytond: TESTPATH=tests/integrations/trytond
+ quart: TESTPATH=tests/integrations/quart
redis: TESTPATH=tests/integrations/redis
rediscluster: TESTPATH=tests/integrations/rediscluster
- asgi: TESTPATH=tests/integrations/asgi
+ requests: TESTPATH=tests/integrations/requests
+ rq: TESTPATH=tests/integrations/rq
+ sanic: TESTPATH=tests/integrations/sanic
+ starlette: TESTPATH=tests/integrations/starlette
+ starlite: TESTPATH=tests/integrations/starlite
sqlalchemy: TESTPATH=tests/integrations/sqlalchemy
- pure_eval: TESTPATH=tests/integrations/pure_eval
- chalice: TESTPATH=tests/integrations/chalice
- boto3: TESTPATH=tests/integrations/boto3
- httpx: TESTPATH=tests/integrations/httpx
+ tornado: TESTPATH=tests/integrations/tornado
+ trytond: TESTPATH=tests/integrations/trytond
+ socket: TESTPATH=tests/integrations/socket
+ grpc: TESTPATH=tests/integrations/grpc
COVERAGE_FILE=.coverage-{envname}
passenv =
@@ -282,10 +490,10 @@ passenv =
SENTRY_PYTHON_TEST_POSTGRES_NAME
usedevelop = True
extras =
- flask: flask
bottle: bottle
falcon: falcon
- quart: quart
+ flask: flask
+ pymongo: pymongo
basepython =
py2.7: python2.7
@@ -296,33 +504,37 @@ basepython =
py3.8: python3.8
py3.9: python3.9
py3.10: python3.10
+ py3.11: python3.11
# Python version is pinned here because flake8 actually behaves differently
# depending on which version is used. You can patch this out to point to
# some random Python 3 binary, but then you get guaranteed mismatches with
# CI. Other tools such as mypy and black have options that pin the Python
# version.
- linters: python3.9
- pypy: pypy
+ linters: python3.11
commands =
- ; https://github.com/pytest-dev/pytest/issues/5532
- {py3.5,py3.6,py3.7,py3.8,py3.9}-flask-{0.10,0.11,0.12}: pip install pytest<5
- {py3.6,py3.7,py3.8,py3.9}-flask-{0.11}: pip install Werkzeug<2
+ {py3.7,py3.8}-boto3: pip install urllib3<2.0.0
+ ; https://github.com/pytest-dev/pytest/issues/5532
+ {py3.5,py3.6,py3.7,py3.8,py3.9}-flask-v{0.11,0.12}: pip install pytest<5
+ {py3.6,py3.7,py3.8,py3.9}-flask-v{0.11}: pip install Werkzeug<2
; https://github.com/pallets/flask/issues/4455
- {py3.7,py3.8,py3.9,py3.10}-flask-{0.11,0.12,1.0,1.1}: pip install "itsdangerous>=0.24,<2.0" "markupsafe<2.0.0" "jinja2<3.1.1"
-
+ {py3.7,py3.8,py3.9,py3.10,py3.11}-flask-v{0.11,0.12,1.0,1.1}: pip install "itsdangerous>=0.24,<2.0" "markupsafe<2.0.0" "jinja2<3.1.1"
; https://github.com/more-itertools/more-itertools/issues/578
- py3.5-flask-{0.10,0.11,0.12}: pip install more-itertools<8.11.0
+ py3.5-flask-v{0.11,0.12}: pip install more-itertools<8.11.0
; use old pytest for old Python versions:
{py2.7,py3.4,py3.5}: pip install pytest-forked==1.1.3
- py.test {env:TESTPATH} {posargs}
+ ; Running `py.test` as an executable suffers from an import error
+ ; when loading tests in scenarios. In particular, django fails to
+ ; load the settings from the test module.
+ {py2.7}: python -m pytest --ignore-glob='*py3.py' -rsx -s --durations=5 -vvv {env:TESTPATH} {posargs}
+ {py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11}: python -m pytest -rsx -s --durations=5 -vvv {env:TESTPATH} {posargs}
[testenv:linters]
commands =
- flake8 tests examples sentry_sdk
- black --check tests examples sentry_sdk
- mypy examples sentry_sdk
+ flake8 tests sentry_sdk
+ black --check tests sentry_sdk
+ mypy sentry_sdk
-
+
+ 
+