# 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
def _is_contextvars_broken():
# type: () -> bool
"""
Returns whether gevent/eventlet have patched the stdlib in a way where thread locals are now more "correct" than contextvars.
"""
try:
import gevent # type: ignore
from gevent.monkey import is_object_patched # type: ignore
# Get the MAJOR and MINOR version numbers of Gevent
version_tuple = tuple(
[int(part) for part in re.split(r"a|b|rc|\.", gevent.__version__)[:2]]
)
if is_object_patched("threading", "local"):
# Gevent 20.9.0 depends on Greenlet 0.4.17 which natively handles switching
# context vars when greenlets are switched, so, Gevent 20.9.0+ is all fine.
# Ref: https://github.com/gevent/gevent/blob/83c9e2ae5b0834b8f84233760aabe82c3ba065b4/src/gevent/monkey.py#L604-L609
# Gevent 20.5, that doesn't depend on Greenlet 0.4.17 with native support
# for contextvars, is able to patch both thread locals and contextvars, in
# that case, check if contextvars are effectively patched.
if (
# Gevent 20.9.0+
(sys.version_info >= (3, 7) and version_tuple >= (20, 9))
# Gevent 20.5.0+ or Python < 3.7
or (is_object_patched("contextvars", "ContextVar"))
):
return False
return True
except ImportError:
pass
try:
import greenlet # type: ignore
from eventlet.patcher import is_monkey_patched # type: ignore
greenlet_version = parse_version(greenlet.__version__)
if greenlet_version is None:
logger.error(
"Internal error in Sentry SDK: Could not parse Greenlet version from greenlet.__version__."
)
return False
if is_monkey_patched("thread") and greenlet_version < (0, 5):
return True
except ImportError:
pass
return False
def _make_threadlocal_contextvars(local):
# type: (type) -> type
class ContextVar(object):
# Super-limited impl of ContextVar
def __init__(self, name):
# type: (str) -> None
self._name = name
self._local = local()
def get(self, default):
# type: (Any) -> Any
return getattr(self._local, "value", default)
def set(self, value):
# type: (Any) -> None
self._local.value = value
return ContextVar
def _get_contextvars():
# type: () -> Tuple[bool, type]
"""
Figure out the "right" contextvars installation to use. Returns a
`contextvars.ContextVar`-like class with a limited API.
See https://docs.sentry.io/platforms/python/contextvars/ for more information.
"""
if not _is_contextvars_broken():
# aiocontextvars is a PyPI package that ensures that the contextvars
# backport (also a PyPI package) works with asyncio under Python 3.6
#
# Import it if available.
if sys.version_info < (3, 7):
# `aiocontextvars` is absolutely required for functional
# contextvars on Python 3.6.
try:
from aiocontextvars import ContextVar
return True, ContextVar
except ImportError:
pass
else:
# On Python 3.7 contextvars are functional.
try:
from contextvars import ContextVar
return True, ContextVar
except ImportError:
pass
# Fall back to basic thread-local usage.
from threading import local
return False, _make_threadlocal_contextvars(local)
HAS_REAL_CONTEXTVARS, ContextVar = _get_contextvars()
CONTEXTVARS_ERROR_MESSAGE = """
With asyncio/ASGI applications, the Sentry SDK requires a functional
installation of `contextvars` to avoid leaking scope/context data across
requests.
Please refer to https://docs.sentry.io/platforms/python/contextvars/ for more information.
"""
def qualname_from_function(func):
# type: (Callable[..., Any]) -> Optional[str]
"""Return the qualified name of func. Works with regular function, lambda, partial and partialmethod."""
func_qualname = None # type: Optional[str]
# Python 2
try:
return "%s.%s.%s" % (
func.im_class.__module__, # type: ignore
func.im_class.__name__, # type: ignore
func.__name__,
)
except Exception:
pass
prefix, suffix = "", ""
if (
_PARTIALMETHOD_AVAILABLE
and hasattr(func, "_partialmethod")
and isinstance(func._partialmethod, partialmethod)
):
prefix, suffix = "partialmethod()"
func = func._partialmethod.func
elif isinstance(func, partial) and hasattr(func.func, "__name__"):
prefix, suffix = "partial()"
func = func.func
if hasattr(func, "__qualname__"):
func_qualname = func.__qualname__
elif hasattr(func, "__name__"): # Python 2.7 has no __qualname__
func_qualname = func.__name__
# Python 3: methods, functions, classes
if func_qualname is not None:
if hasattr(func, "__module__"):
func_qualname = func.__module__ + "." + func_qualname
func_qualname = prefix + func_qualname + suffix
return func_qualname
def transaction_from_function(func):
# type: (Callable[..., Any]) -> Optional[str]
return qualname_from_function(func)
disable_capture_event = ContextVar("disable_capture_event")
class ServerlessTimeoutWarning(Exception): # noqa: N818
"""Raised when a serverless method is about to reach its timeout."""
pass
class TimeoutThread(threading.Thread):
"""Creates a Thread which runs (sleeps) for a time duration equal to
waiting_time and raises a custom ServerlessTimeout exception.
"""
def __init__(self, waiting_time, configured_timeout):
# type: (float, int) -> None
threading.Thread.__init__(self)
self.waiting_time = waiting_time
self.configured_timeout = configured_timeout
self._stop_event = threading.Event()
def stop(self):
# type: () -> None
self._stop_event.set()
def run(self):
# type: () -> None
self._stop_event.wait(self.waiting_time)
if self._stop_event.is_set():
return
integer_configured_timeout = int(self.configured_timeout)
# Setting up the exact integer value of configured time(in seconds)
if integer_configured_timeout < self.configured_timeout:
integer_configured_timeout = integer_configured_timeout + 1
# Raising Exception after timeout duration is reached
raise ServerlessTimeoutWarning(
"WARNING : Function is expected to get timed out. Configured timeout duration = {} seconds.".format(
integer_configured_timeout
)
)
def to_base64(original):
# type: (str) -> Optional[str]
"""
Convert a string to base64, via UTF-8. Returns None on invalid input.
"""
base64_string = None
try:
utf8_bytes = original.encode("UTF-8")
base64_bytes = base64.b64encode(utf8_bytes)
base64_string = base64_bytes.decode("UTF-8")
except Exception as err:
logger.warning("Unable to encode {orig} to base64:".format(orig=original), err)
return base64_string
def from_base64(base64_string):
# type: (str) -> Optional[str]
"""
Convert a string from base64, via UTF-8. Returns None on invalid input.
"""
utf8_string = None
try:
only_valid_chars = BASE64_ALPHABET.match(base64_string)
assert only_valid_chars
base64_bytes = base64_string.encode("UTF-8")
utf8_bytes = base64.b64decode(base64_bytes)
utf8_string = utf8_bytes.decode("UTF-8")
except Exception as err:
logger.warning(
"Unable to decode {b64} from base64:".format(b64=base64_string), err
)
return utf8_string
Components = namedtuple("Components", ["scheme", "netloc", "path", "query", "fragment"])
def sanitize_url(url, remove_authority=True, remove_query_values=True, split=False):
# type: (str, bool, bool, bool) -> Union[str, Components]
"""
Removes the authority and query parameter values from a given URL.
"""
parsed_url = urlsplit(url)
query_params = parse_qs(parsed_url.query, keep_blank_values=True)
# strip username:password (netloc can be usr:pwd@example.com)
if remove_authority:
netloc_parts = parsed_url.netloc.split("@")
if len(netloc_parts) > 1:
netloc = "%s:%s@%s" % (
SENSITIVE_DATA_SUBSTITUTE,
SENSITIVE_DATA_SUBSTITUTE,
netloc_parts[-1],
)
else:
netloc = parsed_url.netloc
else:
netloc = parsed_url.netloc
# strip values from query string
if remove_query_values:
query_string = unquote(
urlencode({key: SENSITIVE_DATA_SUBSTITUTE for key in query_params})
)
else:
query_string = parsed_url.query
components = Components(
scheme=parsed_url.scheme,
netloc=netloc,
query=query_string,
path=parsed_url.path,
fragment=parsed_url.fragment,
)
if split:
return components
else:
return urlunsplit(components)
ParsedUrl = namedtuple("ParsedUrl", ["url", "query", "fragment"])
def parse_url(url, sanitize=True):
# type: (str, bool) -> ParsedUrl
"""
Splits a URL into a url (including path), query and fragment. If sanitize is True, the query
parameters will be sanitized to remove sensitive data. The autority (username and password)
in the URL will always be removed.
"""
parsed_url = sanitize_url(
url, remove_authority=True, remove_query_values=sanitize, split=True
)
base_url = urlunsplit(
Components(
scheme=parsed_url.scheme, # type: ignore
netloc=parsed_url.netloc, # type: ignore
query="",
path=parsed_url.path, # type: ignore
fragment="",
)
)
return ParsedUrl(
url=base_url,
query=parsed_url.query, # type: ignore
fragment=parsed_url.fragment, # type: ignore
)
def is_valid_sample_rate(rate, source):
# type: (Any, str) -> bool
"""
Checks the given sample rate to make sure it is valid type and value (a
boolean or a number between 0 and 1, inclusive).
"""
# both booleans and NaN are instances of Real, so a) checking for Real
# checks for the possibility of a boolean also, and b) we have to check
# separately for NaN and Decimal does not derive from Real so need to check that too
if not isinstance(rate, (Real, Decimal)) or math.isnan(rate):
logger.warning(
"{source} Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got {rate} of type {type}.".format(
source=source, rate=rate, type=type(rate)
)
)
return False
# in case rate is a boolean, it will get cast to 1 if it's True and 0 if it's False
rate = float(rate)
if rate < 0 or rate > 1:
logger.warning(
"{source} Given sample rate is invalid. Sample rate must be between 0 and 1. Got {rate}.".format(
source=source, rate=rate
)
)
return False
return True
def match_regex_list(item, regex_list=None, substring_matching=False):
# type: (str, Optional[List[str]], bool) -> bool
if regex_list is None:
return False
for item_matcher in regex_list:
if not substring_matching and item_matcher[-1] != "$":
item_matcher += "$"
matched = re.search(item_matcher, item)
if matched:
return True
return False
def is_sentry_url(hub, url):
# type: (sentry_sdk.Hub, str) -> bool
"""
Determines whether the given URL matches the Sentry DSN.
"""
return (
hub.client is not None
and hub.client.transport is not None
and hub.client.transport.parsed_dsn is not None
and hub.client.transport.parsed_dsn.netloc in url
)
def _generate_installed_modules():
# type: () -> Iterator[Tuple[str, str]]
try:
from importlib import metadata
for dist in metadata.distributions():
name = dist.metadata["Name"]
# `metadata` values may be `None`, see:
# https://github.com/python/cpython/issues/91216
# and
# https://github.com/python/importlib_metadata/issues/371
if name is not None:
version = metadata.version(name)
if version is not None:
yield _normalize_module_name(name), version
except ImportError:
# < py3.8
try:
import pkg_resources
except ImportError:
return
for info in pkg_resources.working_set:
yield _normalize_module_name(info.key), info.version
def _normalize_module_name(name):
# type: (str) -> str
return name.lower()
def _get_installed_modules():
# type: () -> Dict[str, str]
global _installed_modules
if _installed_modules is None:
_installed_modules = dict(_generate_installed_modules())
return _installed_modules
def package_version(package):
# type: (str) -> Optional[Tuple[int, ...]]
installed_packages = _get_installed_modules()
version = installed_packages.get(package)
if version is None:
return None
return parse_version(version)
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
return int(time.time() * 1e9)
if PY2:
def now():
# type: () -> float
return time.time()
else:
def now():
# type: () -> float
return time.perf_counter()
sentry-python-1.39.2/sentry_sdk/worker.py 0000664 0000000 0000000 00000010730 14547447232 0020536 0 ustar 00root root 0000000 0000000 import os
import threading
from time import sleep, time
from sentry_sdk._compat import check_thread_support
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 TYPE_CHECKING
if TYPE_CHECKING:
from typing import Any
from typing import Optional
from typing import Callable
_TERMINATOR = object()
class BackgroundWorker(object):
def __init__(self, queue_size=DEFAULT_QUEUE_SIZE):
# type: (int) -> None
check_thread_support()
self._queue = Queue(queue_size) # type: Queue
self._lock = threading.Lock()
self._thread = None # type: Optional[threading.Thread]
self._thread_for_pid = None # type: Optional[int]
@property
def is_alive(self):
# type: () -> bool
if self._thread_for_pid != os.getpid():
return False
if not self._thread:
return False
return self._thread.is_alive()
def _ensure_thread(self):
# type: () -> None
if not self.is_alive:
self.start()
def _timed_queue_join(self, timeout):
# type: (float) -> bool
deadline = time() + timeout
queue = self._queue
queue.all_tasks_done.acquire()
try:
while queue.unfinished_tasks:
delay = deadline - time()
if delay <= 0:
return False
queue.all_tasks_done.wait(timeout=delay)
return True
finally:
queue.all_tasks_done.release()
def start(self):
# type: () -> None
with self._lock:
if not self.is_alive:
self._thread = threading.Thread(
target=self._target, name="raven-sentry.BackgroundWorker"
)
self._thread.daemon = True
try:
self._thread.start()
self._thread_for_pid = os.getpid()
except RuntimeError:
# At this point we can no longer start because the interpreter
# is already shutting down. Sadly at this point we can no longer
# send out events.
self._thread = None
def kill(self):
# type: () -> None
"""
Kill worker thread. Returns immediately. Not useful for
waiting on shutdown for events, use `flush` for that.
"""
logger.debug("background worker got kill request")
with self._lock:
if self._thread:
try:
self._queue.put_nowait(_TERMINATOR)
except FullError:
logger.debug("background worker queue full, kill failed")
self._thread = None
self._thread_for_pid = None
def flush(self, timeout, callback=None):
# type: (float, Optional[Any]) -> None
logger.debug("background worker got flush request")
with self._lock:
if self.is_alive and timeout > 0.0:
self._wait_flush(timeout, callback)
logger.debug("background worker flushed")
def full(self):
# type: () -> bool
return self._queue.full()
def _wait_flush(self, timeout, callback):
# type: (float, Optional[Any]) -> None
initial_timeout = min(0.1, timeout)
if not self._timed_queue_join(initial_timeout):
pending = self._queue.qsize() + 1
logger.debug("%d event(s) pending on flush", pending)
if callback is not None:
callback(pending, timeout)
if not self._timed_queue_join(timeout - initial_timeout):
pending = self._queue.qsize() + 1
logger.error("flush timed out, dropped %s events", pending)
def submit(self, callback):
# type: (Callable[[], None]) -> bool
self._ensure_thread()
try:
self._queue.put_nowait(callback)
return True
except FullError:
return False
def _target(self):
# type: () -> None
while True:
callback = self._queue.get()
try:
if callback is _TERMINATOR:
break
try:
callback()
except Exception:
logger.error("Failed processing job", exc_info=True)
finally:
self._queue.task_done()
sleep(0)
sentry-python-1.39.2/setup.py 0000664 0000000 0000000 00000007661 14547447232 0016211 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Sentry-Python - Sentry SDK for Python
=====================================
**Sentry-Python is an SDK for Sentry.** Check out `GitHub
`_ to find out more.
"""
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
def get_file_text(file_name):
with open(os.path.join(here, file_name)) as in_file:
return in_file.read()
setup(
name="sentry-sdk",
version="1.39.2",
author="Sentry Team and Contributors",
author_email="hello@sentry.io",
url="https://github.com/getsentry/sentry-python",
project_urls={
"Documentation": "https://docs.sentry.io/platforms/python/",
"Changelog": "https://github.com/getsentry/sentry-python/blob/master/CHANGELOG.md",
},
description="Python client for Sentry (https://sentry.io)",
long_description=get_file_text("README.md"),
long_description_content_type="text/markdown",
packages=find_packages(exclude=("tests", "tests.*")),
# PEP 561
package_data={"sentry_sdk": ["py.typed"]},
zip_safe=False,
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={
"aiohttp": ["aiohttp>=3.5"],
"arq": ["arq>=0.23"],
"asyncpg": ["asyncpg>=0.23"],
"beam": ["apache-beam>=2.12"],
"bottle": ["bottle>=0.12.13"],
"celery": ["celery>=3"],
"chalice": ["chalice>=1.16.0"],
"clickhouse-driver": ["clickhouse-driver>=0.2.0"],
"django": ["django>=1.8"],
"falcon": ["falcon>=1.4"],
"fastapi": ["fastapi>=0.79.0"],
"flask": ["flask>=0.11", "blinker>=1.1", "markupsafe"],
"grpcio": ["grpcio>=1.21.1"],
"httpx": ["httpx>=0.16.0"],
"huey": ["huey>=2"],
"loguru": ["loguru>=0.5"],
"opentelemetry": ["opentelemetry-distro>=0.35b0"],
"opentelemetry-experimental": [
"opentelemetry-distro~=0.40b0",
"opentelemetry-instrumentation-aiohttp-client~=0.40b0",
"opentelemetry-instrumentation-django~=0.40b0",
"opentelemetry-instrumentation-fastapi~=0.40b0",
"opentelemetry-instrumentation-flask~=0.40b0",
"opentelemetry-instrumentation-requests~=0.40b0",
"opentelemetry-instrumentation-sqlite3~=0.40b0",
"opentelemetry-instrumentation-urllib~=0.40b0",
],
"pure_eval": ["pure_eval", "executing", "asttokens"],
"pymongo": ["pymongo>=3.1"],
"pyspark": ["pyspark>=2.4.4"],
"quart": ["quart>=0.16.1", "blinker>=1.1"],
"rq": ["rq>=0.6"],
"sanic": ["sanic>=0.8"],
"sqlalchemy": ["sqlalchemy>=1.2"],
"starlette": ["starlette>=0.19.1"],
"starlite": ["starlite>=1.48"],
"tornado": ["tornado>=5"],
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Libraries :: Python Modules",
],
options={"bdist_wheel": {"universal": "1"}},
)
sentry-python-1.39.2/test-requirements.txt 0000664 0000000 0000000 00000000740 14547447232 0020727 0 ustar 00root root 0000000 0000000 pip # always use newest pip
mock ; python_version<'3.3'
pytest
pytest-cov==2.8.1
pytest-forked<=1.4.0
pytest-localserver==0.5.1 # TODO(py3): 0.6.0 drops 2.7 support: https://github.com/pytest-dev/pytest-localserver/releases/tag/v0.6.0
pytest-watch==4.2.0
tox==3.7.0
jsonschema==3.2.0
pyrsistent==0.16.0 # TODO(py3): 0.17.0 requires python3, see https://github.com/tobgu/pyrsistent/issues/205
executing<2.0.0 # TODO(py3): 2.0.0 requires python3
asttokens
responses
pysocks
ipdb
sentry-python-1.39.2/tests/ 0000775 0000000 0000000 00000000000 14547447232 0015627 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/__init__.py 0000664 0000000 0000000 00000000636 14547447232 0017745 0 ustar 00root root 0000000 0000000 import sys
import pytest
# This is used in _capture_internal_warnings. We need to run this at import
# time because that's where many deprecation warnings might get thrown.
#
# This lives in tests/__init__.py because apparently even tests/conftest.py
# gets loaded too late.
assert "sentry_sdk" not in sys.modules
_warning_recorder_mgr = pytest.warns(None)
_warning_recorder = _warning_recorder_mgr.__enter__()
sentry-python-1.39.2/tests/conftest.py 0000664 0000000 0000000 00000046202 14547447232 0020032 0 ustar 00root root 0000000 0000000 import json
import os
import socket
from threading import Thread
from contextlib import contextmanager
import pytest
import jsonschema
try:
import gevent
except ImportError:
gevent = None
try:
import eventlet
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
try:
from unittest import mock
except ImportError:
import mock
import sentry_sdk
from sentry_sdk._compat import iteritems, reraise, string_types, PY2
from sentry_sdk.envelope import Envelope
from sentry_sdk.integrations import _processed_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
from sentry_sdk._types import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Optional
from collections.abc import Iterator
SENTRY_EVENT_SCHEMA = "./checkouts/data-schemas/relay/event.schema.json"
if not os.path.isfile(SENTRY_EVENT_SCHEMA):
SENTRY_EVENT_SCHEMA = None
else:
with open(SENTRY_EVENT_SCHEMA) as f:
SENTRY_EVENT_SCHEMA = json.load(f)
try:
import pytest_benchmark
except ImportError:
@pytest.fixture
def benchmark():
return lambda x: x()
else:
del pytest_benchmark
@pytest.fixture(autouse=True)
def internal_exceptions(request, monkeypatch):
errors = []
if "tests_internal_exceptions" in request.keywords:
return
def _capture_internal_exception(self, exc_info):
errors.append(exc_info)
@request.addfinalizer
def _():
# 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)
monkeypatch.setattr(
sentry_sdk.Hub, "_capture_internal_exception", _capture_internal_exception
)
return errors
@pytest.fixture(autouse=True, scope="session")
def _capture_internal_warnings():
yield
_warning_recorder_mgr.__exit__(None, None, None)
recorder = _warning_recorder
for warning in recorder:
try:
if isinstance(warning.message, ResourceWarning):
continue
except NameError:
pass
if "sentry_sdk" not in str(warning.filename) and "sentry-sdk" not in str(
warning.filename
):
continue
# pytest-django
if "getfuncargvalue" in str(warning.message):
continue
# Happens when re-initializing the SDK
if "but it was only enabled on init()" in str(warning.message):
continue
# sanic's usage of aiohttp for test client
if "verify_ssl is deprecated, use ssl=False instead" in str(warning.message):
continue
if "getargspec" in str(warning.message) and warning.filename.endswith(
("pyramid/config/util.py", "pyramid/config/views.py")
):
continue
if "isAlive() is deprecated" in str(
warning.message
) and warning.filename.endswith("celery/utils/timer2.py"):
continue
if "collections.abc" in str(warning.message) and warning.filename.endswith(
("celery/canvas.py", "werkzeug/datastructures.py", "tornado/httputil.py")
):
continue
# Django 1.7 emits a (seemingly) false-positive warning for our test
# app and suggests to use a middleware that does not exist in later
# Django versions.
if "SessionAuthenticationMiddleware" in str(warning.message):
continue
if "Something has already installed a non-asyncio" in str(warning.message):
continue
if "dns.hash" in str(warning.message) or "dns/namedict" in warning.filename:
continue
raise AssertionError(warning)
@pytest.fixture
def monkeypatch_test_transport(monkeypatch, validate_event_schema):
def check_event(event):
def check_string_keys(map):
for key, value in iteritems(map):
assert isinstance(key, string_types)
if isinstance(value, dict):
check_string_keys(value)
with capture_internal_exceptions():
check_string_keys(event)
validate_event_schema(event)
def check_envelope(envelope):
with capture_internal_exceptions():
# 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(
client, "transport", TestTransport(check_event, check_envelope)
)
return inner
@pytest.fixture
def validate_event_schema(tmpdir):
def inner(event):
if SENTRY_EVENT_SCHEMA:
jsonschema.validate(instance=event, schema=SENTRY_EVENT_SCHEMA)
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 _processed_integrations
_processed_integrations.clear()
@pytest.fixture
def sentry_init(monkeypatch_test_transport, request):
def inner(*a, **kw):
hub = sentry_sdk.Hub.current
client = sentry_sdk.Client(*a, **kw)
hub.bind_client(client)
if "transport" not in kw:
monkeypatch_test_transport(sentry_sdk.Hub.current.client)
if request.node.get_closest_marker("forked"):
# Do not run isolation if the test is already running in
# ultimate isolation (seems to be required for celery tests that
# fork)
yield inner
else:
with sentry_sdk.Hub(None):
yield inner
class TestTransport(Transport):
def __init__(self, capture_event_callback, capture_envelope_callback):
Transport.__init__(self)
self.capture_event = capture_event_callback
self.capture_envelope = capture_envelope_callback
self._queue = None
@pytest.fixture
def capture_events(monkeypatch):
def inner():
events = []
test_client = sentry_sdk.Hub.current.client
old_capture_event = test_client.transport.capture_event
old_capture_envelope = test_client.transport.capture_envelope
def append_event(event):
events.append(event)
return old_capture_event(event)
def append_envelope(envelope):
for item in envelope:
if item.headers.get("type") in ("event", "transaction"):
test_client.transport.capture_event(item.payload.json)
return old_capture_envelope(envelope)
monkeypatch.setattr(test_client.transport, "capture_event", append_event)
monkeypatch.setattr(test_client.transport, "capture_envelope", append_envelope)
return events
return inner
@pytest.fixture
def capture_envelopes(monkeypatch):
def inner():
envelopes = []
test_client = sentry_sdk.Hub.current.client
old_capture_event = test_client.transport.capture_event
old_capture_envelope = test_client.transport.capture_envelope
def append_event(event):
envelope = Envelope()
envelope.add_event(event)
envelopes.append(envelope)
return old_capture_event(event)
def append_envelope(envelope):
envelopes.append(envelope)
return old_capture_envelope(envelope)
monkeypatch.setattr(test_client.transport, "capture_event", append_event)
monkeypatch.setattr(test_client.transport, "capture_envelope", append_envelope)
return envelopes
return inner
@pytest.fixture
def capture_client_reports(monkeypatch):
def inner():
reports = []
test_client = sentry_sdk.Hub.current.client
def record_lost_event(reason, data_category=None, item=None):
if data_category is None:
data_category = item.data_category
return reports.append((reason, data_category))
monkeypatch.setattr(
test_client.transport, "record_lost_event", record_lost_event
)
return reports
return inner
@pytest.fixture
def capture_events_forksafe(monkeypatch, capture_events, request):
def inner():
capture_events()
events_r, events_w = os.pipe()
events_r = os.fdopen(events_r, "rb", 0)
events_w = os.fdopen(events_w, "wb", 0)
test_client = sentry_sdk.Hub.current.client
old_capture_event = test_client.transport.capture_event
def append(event):
events_w.write(json.dumps(event).encode("utf-8"))
events_w.write(b"\n")
return old_capture_event(event)
def flush(timeout=None, callback=None):
events_w.write(b"flush\n")
monkeypatch.setattr(test_client.transport, "capture_event", append)
monkeypatch.setattr(test_client, "flush", flush)
return EventStreamReader(events_r, events_w)
return inner
class EventStreamReader(object):
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.read_file.readline().decode("utf-8"))
def read_flush(self):
assert self.read_file.readline() == b"flush\n"
# scope=session ensures that fixture is run earlier
@pytest.fixture(
scope="session",
params=[None, "eventlet", "gevent"],
ids=("threads", "eventlet", "greenlet"),
)
def maybe_monkeypatched_threading(request):
if request.param == "eventlet":
if eventlet is None:
pytest.skip("no eventlet installed")
try:
eventlet.monkey_patch()
except AttributeError as e:
if "'thread.RLock' object has no attribute" in str(e):
# https://bitbucket.org/pypy/pypy/issues/2962/gevent-cannot-patch-rlock-under-pypy-27-7
pytest.skip("https://github.com/eventlet/eventlet/issues/546")
else:
raise
elif request.param == "gevent":
if gevent is None:
pytest.skip("no gevent installed")
try:
gevent.monkey.patch_all()
except Exception as e:
if "_RLock__owner" in str(e):
pytest.skip("https://github.com/gevent/gevent/issues/1380")
else:
raise
else:
assert request.param is None
return request.param
@pytest.fixture
def render_span_tree():
def inner(event):
assert event["type"] == "transaction"
by_parent = {}
for span in event["spans"]:
by_parent.setdefault(span["parent_span_id"], []).append(span)
def render_span(span):
yield "- op={}: description={}".format(
json.dumps(span.get("op")), json.dumps(span.get("description"))
)
for subspan in by_parent.get(span["span_id"]) or ():
for line in render_span(subspan):
yield " {}".format(line)
root_span = event["contexts"]["trace"]
# Return a list instead of a multiline string because black will know better how to format that
return "\n".join(render_span(root_span))
return inner
@pytest.fixture(name="StringContaining")
def string_containing_matcher():
"""
An object which matches any string containing the substring passed to the
object at instantiation time.
Useful for assert_called_with, assert_any_call, etc.
Used like this:
>>> f = mock.Mock()
>>> f("dogs are great")
>>> f.assert_any_call("dogs") # will raise AssertionError
Traceback (most recent call last):
...
AssertionError: mock('dogs') call not found
>>> f.assert_any_call(StringContaining("dogs")) # no AssertionError
"""
class StringContaining(object):
def __init__(self, substring):
self.substring = 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)
except NameError:
self.valid_types = (str, bytes)
def __eq__(self, test_string):
if not isinstance(test_string, self.valid_types):
return False
# this is safe even in py2 because as of 2.6, `bytes` exists in py2
# as an alias for `str`
if isinstance(test_string, bytes):
test_string = test_string.decode()
if len(self.substring) > len(test_string):
return False
return self.substring in test_string
def __ne__(self, test_string):
return not self.__eq__(test_string)
return StringContaining
def _safe_is_equal(x, y):
"""
Compares two values, preferring to use the first's __eq__ method if it
exists and is implemented.
Accounts for py2/py3 differences (like ints in py2 not having a __eq__
method), as well as the incomparability of certain types exposed by using
raw __eq__ () rather than ==.
"""
# Prefer using __eq__ directly to ensure that examples like
#
# maisey = Dog()
# maisey.name = "Maisey the Dog"
# maisey == ObjectDescribedBy(attrs={"name": StringContaining("Maisey")})
#
# evaluate to True (in other words, examples where the values in self.attrs
# might also have custom __eq__ methods; this makes sure those methods get
# used if possible)
try:
is_equal = x.__eq__(y)
except AttributeError:
is_equal = NotImplemented
# this can happen on its own, too (i.e. without an AttributeError being
# thrown), which is why this is separate from the except block above
if is_equal == NotImplemented:
# using == smoothes out weird variations exposed by raw __eq__
return x == y
return is_equal
@pytest.fixture(name="DictionaryContaining")
def dictionary_containing_matcher():
"""
An object which matches any dictionary containing all key-value pairs from
the dictionary passed to the object at instantiation time.
Useful for assert_called_with, assert_any_call, etc.
Used like this:
>>> f = mock.Mock()
>>> f({"dogs": "yes", "cats": "maybe"})
>>> f.assert_any_call({"dogs": "yes"}) # will raise AssertionError
Traceback (most recent call last):
...
AssertionError: mock({'dogs': 'yes'}) call not found
>>> f.assert_any_call(DictionaryContaining({"dogs": "yes"})) # no AssertionError
"""
class DictionaryContaining(object):
def __init__(self, subdict):
self.subdict = subdict
def __eq__(self, test_dict):
if not isinstance(test_dict, dict):
return False
if len(self.subdict) > len(test_dict):
return False
for key, value in self.subdict.items():
try:
test_value = test_dict[key]
except KeyError: # missing key
return False
if not _safe_is_equal(value, test_value):
return False
return True
def __ne__(self, test_dict):
return not self.__eq__(test_dict)
return DictionaryContaining
@pytest.fixture(name="ObjectDescribedBy")
def object_described_by_matcher():
"""
An object which matches any other object with the given properties.
Available properties currently are "type" (a type object) and "attrs" (a
dictionary).
Useful for assert_called_with, assert_any_call, etc.
Used like this:
>>> class Dog(object):
... pass
...
>>> maisey = Dog()
>>> maisey.name = "Maisey"
>>> maisey.age = 7
>>> f = mock.Mock()
>>> f(maisey)
>>> f.assert_any_call(ObjectDescribedBy(type=Dog)) # no AssertionError
>>> f.assert_any_call(ObjectDescribedBy(attrs={"name": "Maisey"})) # no AssertionError
"""
class ObjectDescribedBy(object):
def __init__(self, type=None, attrs=None):
self.type = type
self.attrs = attrs
def __eq__(self, test_obj):
if self.type:
if not isinstance(test_obj, self.type):
return False
if self.attrs:
for attr_name, attr_value in self.attrs.items():
try:
test_value = getattr(test_obj, attr_name)
except AttributeError: # missing attribute
return False
if not _safe_is_equal(attr_value, test_value):
return False
return True
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
def unpack_werkzeug_response(response):
# werkzeug < 2.1 returns a tuple as client response, newer versions return
# an object
try:
return response.get_data(), response.status, response.headers
except AttributeError:
content, status, headers = response
return b"".join(content), status, headers
def werkzeug_set_cookie(client, servername, key, value):
# client.set_cookie has a different signature in different werkzeug versions
try:
client.set_cookie(servername, key, value)
except TypeError:
client.set_cookie(key, value)
@contextmanager
def patch_start_tracing_child(fake_transaction_is_none=False):
# type: (bool) -> Iterator[Optional[mock.MagicMock]]
if not fake_transaction_is_none:
fake_transaction = mock.MagicMock()
fake_start_child = mock.MagicMock()
fake_transaction.start_child = fake_start_child
else:
fake_transaction = None
fake_start_child = None
version = "2" if PY2 else "3"
with mock.patch(
"sentry_sdk.tracing_utils_py%s.get_current_span" % version,
return_value=fake_transaction,
):
yield fake_start_child
sentry-python-1.39.2/tests/integrations/ 0000775 0000000 0000000 00000000000 14547447232 0020335 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/__init__.py 0000664 0000000 0000000 00000000000 14547447232 0022434 0 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/aiohttp/ 0000775 0000000 0000000 00000000000 14547447232 0022005 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/aiohttp/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024117 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("aiohttp")
sentry-python-1.39.2/tests/integrations/aiohttp/test_aiohttp.py 0000664 0000000 0000000 00000035440 14547447232 0025074 0 ustar 00root root 0000000 0000000 import asyncio
import json
from contextlib import suppress
import pytest
from aiohttp import web
from aiohttp.client import ServerDisconnectedError
from aiohttp.web_request import Request
from sentry_sdk import capture_message, start_transaction
from sentry_sdk.integrations.aiohttp import AioHttpIntegration
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
@pytest.mark.asyncio
async def test_basic(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
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
(event,) = events
assert (
event["transaction"]
== "tests.integrations.aiohttp.test_aiohttp.test_basic..hello"
)
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
host = request["headers"]["Host"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "GET"
assert request["query_string"] == ""
assert request.get("data") is None
assert request["url"] == "http://{host}/".format(host=host)
assert request["headers"] == {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": host,
"User-Agent": request["headers"]["User-Agent"],
"baggage": mock.ANY,
"sentry-trace": mock.ANY,
}
@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()])
body = {"some": "value"}
async def hello(request):
1 / 0
app = web.Application()
app.router.add_post("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.post("/", json=body)
assert resp.status == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "POST"
assert request["data"] == BODY_NOT_READ_MESSAGE
@pytest.mark.asyncio
async def test_post_body_read(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
body = {"some": "value"}
async def hello(request):
await request.json()
1 / 0
app = web.Application()
app.router.add_post("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.post("/", json=body)
assert resp.status == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
request = event["request"]
assert request["env"] == {"REMOTE_ADDR": "127.0.0.1"}
assert request["method"] == "POST"
assert request["data"] == json.dumps(body)
@pytest.mark.asyncio
async def test_403_not_captured(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
raise web.HTTPForbidden()
app = web.Application()
app.router.add_get("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.get("/")
assert resp.status == 403
assert not events
@pytest.mark.asyncio
async def test_cancelled_error_not_captured(
sentry_init, aiohttp_client, capture_events
):
sentry_init(integrations=[AioHttpIntegration()])
async def hello(request):
raise asyncio.CancelledError()
app = web.Application()
app.router.add_get("/", hello)
events = capture_events()
client = await aiohttp_client(app)
with suppress(ServerDisconnectedError):
# Intended `aiohttp` interaction: server will disconnect if it
# encounters `asyncio.CancelledError`
await client.get("/")
assert not events
@pytest.mark.asyncio
async def test_half_initialized(sentry_init, aiohttp_client, capture_events):
sentry_init(integrations=[AioHttpIntegration()])
sentry_init()
async def hello(request):
return web.Response(text="hello")
app = web.Application()
app.router.add_get("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.get("/")
assert resp.status == 200
assert 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):
return web.Response(text="hello")
app = web.Application()
app.router.add_get("/", hello)
events = capture_events()
client = await aiohttp_client(app)
resp = await client.get("/")
assert resp.status == 200
(event,) = events
assert event["type"] == "transaction"
assert (
event["transaction"]
== "tests.integrations.aiohttp.test_aiohttp.test_tracing..hello"
)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"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",
),
],
)
async def test_transaction_style(
sentry_init,
aiohttp_client,
capture_events,
url,
transaction_style,
expected_transaction,
expected_source,
):
sentry_init(
integrations=[AioHttpIntegration(transaction_style=transaction_style)],
traces_sample_rate=1.0,
)
async def hello(request):
return web.Response(text="hello")
app = web.Application()
app.router.add_get(r"/{var}", hello)
events = capture_events()
client = await aiohttp_client(app)
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,
):
traces_sampler = mock.Mock()
sentry_init(
integrations=[AioHttpIntegration()],
traces_sampler=traces_sampler,
)
async def kangaroo_handler(request):
return web.Response(text="dogs are great")
app = web.Application()
app.router.add_get("/tricks/kangaroo", kangaroo_handler)
client = await aiohttp_client(app)
await client.get("/tricks/kangaroo")
traces_sampler.assert_any_call(
DictionaryContaining(
{
"aiohttp_request": ObjectDescribedBy(
type=Request, attrs={"method": "GET", "path": "/tricks/kangaroo"}
)
}
)
)
@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()
# The aiohttp_client is instrumented so will generate the sentry-trace header and add request.
# Get the sentry-trace header from the request so we can later compare with transaction events.
client = await aiohttp_client(app)
resp = await client.get("/")
sentry_trace_header = resp.request_info.headers.get("sentry-trace")
trace_id = sentry_trace_header.split("-")[0]
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()
# The aiohttp_client is instrumented so will generate the sentry-trace header and add request.
# Get the sentry-trace header from the request so we can later compare with transaction events.
client = await aiohttp_client(app)
resp = await client.get("/")
sentry_trace_header = resp.request_info.headers.get("sentry-trace")
trace_id = sentry_trace_header.split("-")[0]
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
@pytest.mark.asyncio
async def test_crumb_capture(
sentry_init, aiohttp_raw_server, aiohttp_client, loop, capture_events
):
def before_breadcrumb(crumb, hint):
crumb["data"]["extra"] = "foo"
return crumb
sentry_init(
integrations=[AioHttpIntegration()], before_breadcrumb=before_breadcrumb
)
async def handler(request):
return web.Response(text="OK")
raw_server = await aiohttp_raw_server(handler)
with start_transaction():
events = capture_events()
client = await aiohttp_client(raw_server)
resp = await client.get("/")
assert resp.status == 200
capture_message("Testing!")
(event,) = events
crumb = event["breadcrumbs"]["values"][0]
assert crumb["type"] == "http"
assert crumb["category"] == "httplib"
assert crumb["data"] == {
"url": "http://127.0.0.1:{}/".format(raw_server.port),
"http.fragment": "",
"http.method": "GET",
"http.query": "",
"http.response.status_code": 200,
"reason": "OK",
"extra": "foo",
}
@pytest.mark.asyncio
async def test_outgoing_trace_headers(sentry_init, aiohttp_raw_server, aiohttp_client):
sentry_init(
integrations=[AioHttpIntegration()],
traces_sample_rate=1.0,
)
async def handler(request):
return web.Response(text="OK")
raw_server = await aiohttp_raw_server(handler)
with start_transaction(
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
# make trace_id difference between transactions
trace_id="0123456789012345678901234567890",
) as transaction:
client = await aiohttp_client(raw_server)
resp = await client.get("/")
request_span = transaction._span_recorder.spans[-1]
assert resp.request_info.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.asyncio
async def test_outgoing_trace_headers_append_to_baggage(
sentry_init, aiohttp_raw_server, aiohttp_client
):
sentry_init(
integrations=[AioHttpIntegration()],
traces_sample_rate=1.0,
release="d08ebdb9309e1b004c6f52202de58a09c2268e42",
)
async def handler(request):
return web.Response(text="OK")
raw_server = await aiohttp_raw_server(handler)
with start_transaction(
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
trace_id="0123456789012345678901234567890",
):
client = await aiohttp_client(raw_server)
resp = await client.get("/", headers={"bagGage": "custom=value"})
assert (
resp.request_info.headers["baggage"]
== "custom=value,sentry-trace_id=0123456789012345678901234567890,sentry-environment=production,sentry-release=d08ebdb9309e1b004c6f52202de58a09c2268e42,sentry-transaction=/interactions/other-dogs/new-dog,sentry-sample_rate=1.0,sentry-sampled=true"
)
sentry-python-1.39.2/tests/integrations/argv/ 0000775 0000000 0000000 00000000000 14547447232 0021274 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/argv/test_argv.py 0000664 0000000 0000000 00000000644 14547447232 0023650 0 ustar 00root root 0000000 0000000 import sys
from sentry_sdk import capture_message
from sentry_sdk.integrations.argv import ArgvIntegration
def test_basic(sentry_init, capture_events, monkeypatch):
sentry_init(integrations=[ArgvIntegration()])
argv = ["foo", "bar", "baz"]
monkeypatch.setattr(sys, "argv", argv)
events = capture_events()
capture_message("hi")
(event,) = events
assert event["extra"]["sys.argv"] == argv
sentry-python-1.39.2/tests/integrations/ariadne/ 0000775 0000000 0000000 00000000000 14547447232 0021740 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/ariadne/__init__.py 0000664 0000000 0000000 00000000152 14547447232 0024047 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("ariadne")
pytest.importorskip("fastapi")
pytest.importorskip("flask")
sentry-python-1.39.2/tests/integrations/ariadne/test_ariadne.py 0000664 0000000 0000000 00000016504 14547447232 0024762 0 ustar 00root root 0000000 0000000 from ariadne import gql, graphql_sync, ObjectType, QueryType, make_executable_schema
from ariadne.asgi import GraphQL
from fastapi import FastAPI
from fastapi.testclient import TestClient
from flask import Flask, request, jsonify
from sentry_sdk.integrations.ariadne import AriadneIntegration
from sentry_sdk.integrations.fastapi import FastApiIntegration
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.starlette import StarletteIntegration
def schema_factory():
type_defs = gql(
"""
type Query {
greeting(name: String): Greeting
error: String
}
type Greeting {
name: String
}
"""
)
query = QueryType()
greeting = ObjectType("Greeting")
@query.field("greeting")
def resolve_greeting(*_, **kwargs):
name = kwargs.pop("name")
return {"name": name}
@query.field("error")
def resolve_error(obj, *_):
raise RuntimeError("resolver failed")
@greeting.field("name")
def resolve_name(obj, *_):
return "Hello, {}!".format(obj["name"])
return make_executable_schema(type_defs, query)
def test_capture_request_and_response_if_send_pii_is_on_async(
sentry_init, capture_events
):
sentry_init(
send_default_pii=True,
integrations=[
AriadneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = schema_factory()
async_app = FastAPI()
async_app.mount("/graphql/", GraphQL(schema))
query = {"query": "query ErrorQuery {error}"}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "ariadne"
assert event["contexts"]["response"] == {
"data": {
"data": {"error": None},
"errors": [
{
"locations": [{"column": 19, "line": 1}],
"message": "resolver failed",
"path": ["error"],
}
],
}
}
assert event["request"]["api_target"] == "graphql"
assert event["request"]["data"] == query
def test_capture_request_and_response_if_send_pii_is_on_sync(
sentry_init, capture_events
):
sentry_init(
send_default_pii=True,
integrations=[AriadneIntegration(), FlaskIntegration()],
)
events = capture_events()
schema = schema_factory()
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(schema, data)
return jsonify(result), 200
query = {"query": "query ErrorQuery {error}"}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "ariadne"
assert event["contexts"]["response"] == {
"data": {
"data": {"error": None},
"errors": [
{
"locations": [{"column": 19, "line": 1}],
"message": "resolver failed",
"path": ["error"],
}
],
}
}
assert event["request"]["api_target"] == "graphql"
assert event["request"]["data"] == query
def test_do_not_capture_request_and_response_if_send_pii_is_off_async(
sentry_init, capture_events
):
sentry_init(
integrations=[
AriadneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = schema_factory()
async_app = FastAPI()
async_app.mount("/graphql/", GraphQL(schema))
query = {"query": "query ErrorQuery {error}"}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "ariadne"
assert "data" not in event["request"]
assert "response" not in event["contexts"]
def test_do_not_capture_request_and_response_if_send_pii_is_off_sync(
sentry_init, capture_events
):
sentry_init(
integrations=[AriadneIntegration(), FlaskIntegration()],
)
events = capture_events()
schema = schema_factory()
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(schema, data)
return jsonify(result), 200
query = {"query": "query ErrorQuery {error}"}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "ariadne"
assert "data" not in event["request"]
assert "response" not in event["contexts"]
def test_capture_validation_error(sentry_init, capture_events):
sentry_init(
send_default_pii=True,
integrations=[
AriadneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = schema_factory()
async_app = FastAPI()
async_app.mount("/graphql/", GraphQL(schema))
query = {"query": "query ErrorQuery {doesnt_exist}"}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "ariadne"
assert event["contexts"]["response"] == {
"data": {
"errors": [
{
"locations": [{"column": 19, "line": 1}],
"message": "Cannot query field 'doesnt_exist' on type 'Query'.",
}
]
}
}
assert event["request"]["api_target"] == "graphql"
assert event["request"]["data"] == query
def test_no_event_if_no_errors_async(sentry_init, capture_events):
sentry_init(
integrations=[
AriadneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = schema_factory()
async_app = FastAPI()
async_app.mount("/graphql/", GraphQL(schema))
query = {
"query": "query GreetingQuery($name: String) { greeting(name: $name) {name} }",
"variables": {"name": "some name"},
}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 0
def test_no_event_if_no_errors_sync(sentry_init, capture_events):
sentry_init(
integrations=[AriadneIntegration(), FlaskIntegration()],
)
events = capture_events()
schema = schema_factory()
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server():
data = request.get_json()
success, result = graphql_sync(schema, data)
return jsonify(result), 200
query = {
"query": "query GreetingQuery($name: String) { greeting(name: $name) {name} }",
"variables": {"name": "some name"},
}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 0
sentry-python-1.39.2/tests/integrations/arq/ 0000775 0000000 0000000 00000000000 14547447232 0021120 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/arq/__init__.py 0000664 0000000 0000000 00000000052 14547447232 0023226 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("arq")
sentry-python-1.39.2/tests/integrations/arq/test_arq.py 0000664 0000000 0000000 00000016421 14547447232 0023320 0 ustar 00root root 0000000 0000000 import asyncio
import pytest
from sentry_sdk import start_transaction, Hub
from sentry_sdk.integrations.arq import ArqIntegration
import arq.worker
from arq import cron
from arq.connections import ArqRedis
from arq.jobs import Job
from arq.utils import timestamp_ms
from fakeredis.aioredis import FakeRedis
def async_partial(async_fn, *args, **kwargs):
# asyncio.iscoroutinefunction (Used in the integration code) in Python < 3.8
# does not detect async functions in functools.partial objects.
# This partial implementation returns a coroutine instead.
async def wrapped(ctx):
return await async_fn(ctx, *args, **kwargs)
return wrapped
@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(
cls_functions=None,
cls_cron_jobs=None,
kw_functions=None,
kw_cron_jobs=None,
allow_abort_jobs_=False,
):
cls_functions = cls_functions or []
cls_cron_jobs = cls_cron_jobs or []
kwargs = {}
if kw_functions is not None:
kwargs["functions"] = kw_functions
if kw_cron_jobs is not None:
kwargs["cron_jobs"] = kw_cron_jobs
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)
class WorkerSettings:
functions = cls_functions
cron_jobs = cls_cron_jobs
redis_pool = pool
allow_abort_jobs = allow_abort_jobs_
if not WorkerSettings.functions:
del WorkerSettings.functions
if not WorkerSettings.cron_jobs:
del WorkerSettings.cron_jobs
worker = arq.worker.create_worker(WorkerSettings, **kwargs)
return pool, worker
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 arq.worker.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(
"source", [("cls_functions", "cls_cron_jobs"), ("kw_functions", "kw_cron_jobs")]
)
@pytest.mark.parametrize("job_fails", [True, False], ids=["error", "success"])
@pytest.mark.asyncio
async def test_job_transaction(capture_events, init_arq, source, job_fails):
async def division(_, a, b=0):
return a / b
division.__qualname__ = division.__name__
cron_func = async_partial(division, a=1, b=int(not job_fails))
cron_func.__qualname__ = division.__name__
cron_job = cron(cron_func, minute=0, run_at_startup=True)
functions_key, cron_jobs_key = source
pool, worker = init_arq(**{functions_key: [division], cron_jobs_key: [cron_job]})
events = capture_events()
job = await pool.enqueue_job("division", 1, b=int(not job_fails))
await worker.run_job(job.job_id, timestamp_ms())
loop = asyncio.get_event_loop()
task = loop.create_task(worker.async_run())
await asyncio.sleep(1)
task.cancel()
await worker.close()
if job_fails:
error_func_event = events.pop(0)
error_cron_event = events.pop(1)
assert error_func_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
assert error_func_event["exception"]["values"][0]["mechanism"]["type"] == "arq"
func_extra = error_func_event["extra"]["arq-job"]
assert func_extra["task"] == "division"
assert error_cron_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
assert error_cron_event["exception"]["values"][0]["mechanism"]["type"] == "arq"
cron_extra = error_cron_event["extra"]["arq-job"]
assert cron_extra["task"] == "cron:division"
[func_event, cron_event] = events
assert func_event["type"] == "transaction"
assert func_event["transaction"] == "division"
assert func_event["transaction_info"] == {"source": "task"}
assert "arq_task_id" in func_event["tags"]
assert "arq_task_retry" in func_event["tags"]
func_extra = func_event["extra"]["arq-job"]
assert func_extra["task"] == "division"
assert func_extra["kwargs"] == {"b": int(not job_fails)}
assert func_extra["retry"] == 1
assert cron_event["type"] == "transaction"
assert cron_event["transaction"] == "cron:division"
assert cron_event["transaction_info"] == {"source": "task"}
assert "arq_task_id" in cron_event["tags"]
assert "arq_task_retry" in cron_event["tags"]
cron_extra = cron_event["extra"]["arq-job"]
assert cron_extra["task"] == "cron:division"
assert cron_extra["kwargs"] == {}
assert cron_extra["retry"] == 1
@pytest.mark.parametrize("source", ["cls_functions", "kw_functions"])
@pytest.mark.asyncio
async def test_enqueue_job(capture_events, init_arq, source):
async def dummy_job(_):
pass
pool, _ = init_arq(**{source: [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"
@pytest.mark.asyncio
async def test_execute_job_without_integration(init_arq):
async def dummy_job(_ctx):
pass
dummy_job.__qualname__ = dummy_job.__name__
pool, worker = init_arq([dummy_job])
# remove the integration to trigger the edge case
Hub.current.client.integrations.pop("arq")
job = await pool.enqueue_job("dummy_job")
await worker.run_job(job.job_id, timestamp_ms())
assert await job.result() is None
sentry-python-1.39.2/tests/integrations/asgi/ 0000775 0000000 0000000 00000000000 14547447232 0021260 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/asgi/__init__.py 0000664 0000000 0000000 00000000201 14547447232 0023362 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("asyncio")
pytest.importorskip("pytest_asyncio")
pytest.importorskip("async_asgi_testclient")
sentry-python-1.39.2/tests/integrations/asgi/test_asgi.py 0000664 0000000 0000000 00000045505 14547447232 0023625 0 ustar 00root root 0000000 0000000 import sys
from collections import Counter
import pytest
import sentry_sdk
from sentry_sdk import capture_message
from sentry_sdk.integrations._asgi_common import _get_ip, _get_headers
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware, _looks_like_asgi3
from async_asgi_testclient import TestClient
minimum_python_36 = pytest.mark.skipif(
sys.version_info < (3, 6), reason="ASGI is only supported in Python >= 3.6"
)
@pytest.fixture
def asgi3_app():
async def app(scope, receive, send):
if scope["type"] == "lifespan":
while True:
message = await receive()
if message["type"] == "lifespan.startup":
await send({"type": "lifespan.startup.complete"})
elif message["type"] == "lifespan.shutdown":
await send({"type": "lifespan.shutdown.complete"})
return
elif (
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"],
],
}
)
await send(
{
"type": "http.response.body",
"body": b"Hello, world!",
}
)
return app
@pytest.fixture
def asgi3_app_with_error():
async def send_with_error(event):
1 / 0
async def app(scope, receive, send):
if scope["type"] == "lifespan":
while True:
message = await receive()
if message["type"] == "lifespan.startup":
... # Do some startup here!
await send({"type": "lifespan.startup.complete"})
elif message["type"] == "lifespan.shutdown":
... # Do some shutdown here!
await send({"type": "lifespan.shutdown.complete"})
return
else:
await send_with_error(
{
"type": "http.response.start",
"status": 200,
"headers": [
[b"content-type", b"text/plain"],
],
}
)
await send_with_error(
{
"type": "http.response.body",
"body": b"Hello, world!",
}
)
return app
@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"],
],
}
)
capture_message("Let's try dividing by 0")
1 / 0
await send(
{
"type": "http.response.body",
"body": b"Hello, world!",
}
)
return app
@pytest.fixture
def asgi3_ws_app():
def message():
capture_message("Some message to the world!")
raise ValueError("Oh no")
async def app(scope, receive, send):
await send(
{
"type": "websocket.send",
"text": message(),
}
)
return app
@minimum_python_36
def test_invalid_transaction_style(asgi3_app):
with pytest.raises(ValueError) as exp:
SentryAsgiMiddleware(asgi3_app, transaction_style="URL")
assert (
str(exp.value)
== "Invalid value for transaction_style: URL (must be in ('endpoint', 'url'))"
)
@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("/some_url?somevalue=123")
(transaction_event,) = events
assert transaction_event["type"] == "transaction"
assert transaction_event["transaction"] == "/some_url"
assert transaction_event["transaction_info"] == {"source": "url"}
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/some_url",
}
@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)
events = capture_events()
with pytest.raises(ZeroDivisionError):
async with TestClient(app) as client:
await client.get("/some_url")
(
error_event,
transaction_event,
) = events
assert error_event["transaction"] == "/some_url"
assert error_event["transaction_info"] == {"source": "url"}
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"]
@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)
with pytest.raises(ZeroDivisionError):
async with TestClient(app) as client:
events = capture_events()
await client.get("/")
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"]
)
@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)
with pytest.raises(ZeroDivisionError):
async with TestClient(app) as client:
events = capture_events()
await client.get("/")
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"]
@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)
app = SentryAsgiMiddleware(asgi3_app_with_error_and_msg)
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})
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
@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)
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})
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
@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)
events = capture_events()
asgi3_ws_app = SentryAsgiMiddleware(asgi3_ws_app)
scope = {
"type": "websocket",
"endpoint": asgi3_app,
"client": ("127.0.0.1", 60457),
"route": "some_url",
"headers": [
("accept", "*/*"),
],
}
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
assert msg_event["message"] == "Some message to the world!"
(exc,) = error_event["exception"]["values"]
assert exc["type"] == "ValueError"
assert exc["value"] == "Oh no"
@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()
count_item_types = Counter()
for envelope in envelopes:
count_item_types[envelope.items[0].type] += 1
assert count_item_types["transaction"] == 3
assert count_item_types["event"] == 1
assert count_item_types["sessions"] == 1
assert len(envelopes) == 5
session_aggregates = envelopes[-1].items[0].payload.json["aggregates"]
assert session_aggregates[0]["exited"] == 2
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..app",
"component",
),
],
)
@pytest.mark.asyncio
async def test_transaction_style(
sentry_init,
asgi3_app,
capture_events,
url,
transaction_style,
expected_transaction,
expected_source,
):
sentry_init(send_default_pii=True, traces_sample_rate=1.0)
app = SentryAsgiMiddleware(asgi3_app, transaction_style=transaction_style)
scope = {
"endpoint": asgi3_app,
"route": url,
"client": ("127.0.0.1", 60457),
}
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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
ip = _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,
}
headers = _get_headers(scope)
assert headers == {
"x-real-ip": "10.10.10.10",
"some_header": "123, abc",
}
@minimum_python_36
@pytest.mark.asyncio
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"/message/123456",
"url",
),
(
"/message/123456",
"url",
"/message/123456",
"url",
),
],
)
async def test_transaction_name(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
asgi3_app,
capture_envelopes,
):
"""
Tests that the transaction name is something meaningful.
"""
sentry_init(
traces_sample_rate=1.0,
debug=True,
)
envelopes = capture_envelopes()
app = SentryAsgiMiddleware(asgi3_app, transaction_style=transaction_style)
async with TestClient(app) as client:
await client.get(request_url)
(transaction_envelope,) = envelopes
transaction_event = transaction_envelope.get_transaction_event()
assert transaction_event["transaction"] == expected_transaction_name
assert (
transaction_event["transaction_info"]["source"] == expected_transaction_source
)
@minimum_python_36
@pytest.mark.asyncio
@pytest.mark.parametrize(
"request_url, transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"/message/123456",
"url",
),
(
"/message/123456",
"url",
"/message/123456",
"url",
),
],
)
async def test_transaction_name_in_traces_sampler(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
asgi3_app,
):
"""
Tests that a custom traces_sampler has a meaningful transaction name.
In this case the URL or endpoint, because we do not have the route yet.
"""
def dummy_traces_sampler(sampling_context):
assert (
sampling_context["transaction_context"]["name"] == expected_transaction_name
)
assert (
sampling_context["transaction_context"]["source"]
== expected_transaction_source
)
sentry_init(
traces_sampler=dummy_traces_sampler,
traces_sample_rate=1.0,
debug=True,
)
app = SentryAsgiMiddleware(asgi3_app, transaction_style=transaction_style)
async with TestClient(app) as client:
await client.get(request_url)
sentry-python-1.39.2/tests/integrations/asyncio/ 0000775 0000000 0000000 00000000000 14547447232 0022002 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/asyncio/__init__.py 0000664 0000000 0000000 00000000000 14547447232 0024101 0 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/asyncio/test_asyncio_py3.py 0000664 0000000 0000000 00000024721 14547447232 0025661 0 ustar 00root root 0000000 0000000 import asyncio
import inspect
import sys
import pytest
import sentry_sdk
from sentry_sdk.consts import OP
from sentry_sdk.integrations.asyncio import AsyncioIntegration, patch_asyncio
try:
from unittest.mock import MagicMock, patch
except ImportError:
from mock import MagicMock, patch
try:
from contextvars import Context, ContextVar
except ImportError:
pass # All tests will be skipped with incompatible versions
minimum_python_37 = pytest.mark.skipif(
sys.version_info < (3, 7), reason="Asyncio tests need Python >= 3.7"
)
minimum_python_311 = pytest.mark.skipif(
sys.version_info < (3, 11),
reason="Asyncio task context parameter was introduced in Python 3.11",
)
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()
def get_sentry_task_factory(mock_get_running_loop):
"""
Patches (mocked) asyncio and gets the sentry_task_factory.
"""
mock_loop = mock_get_running_loop.return_value
patch_asyncio()
patched_factory = mock_loop.set_task_factory.call_args[0][0]
return patched_factory
@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
@minimum_python_311
@pytest.mark.asyncio
async def test_task_with_context(sentry_init):
"""
Integration test to ensure working context parameter in Python 3.11+
"""
sentry_init(
integrations=[
AsyncioIntegration(),
],
)
var = ContextVar("var")
var.set("original value")
async def change_value():
var.set("changed value")
async def retrieve_value():
return var.get()
# Create a context and run both tasks within the context
ctx = Context()
async with asyncio.TaskGroup() as tg:
tg.create_task(change_value(), context=ctx)
retrieve_task = tg.create_task(retrieve_value(), context=ctx)
assert retrieve_task.result() == "changed value"
@minimum_python_37
@patch("asyncio.get_running_loop")
def test_patch_asyncio(mock_get_running_loop):
"""
Test that the patch_asyncio function will patch the task factory.
"""
mock_loop = mock_get_running_loop.return_value
patch_asyncio()
assert mock_loop.set_task_factory.called
set_task_factory_args, _ = mock_loop.set_task_factory.call_args
assert len(set_task_factory_args) == 1
sentry_task_factory, *_ = set_task_factory_args
assert callable(sentry_task_factory)
@minimum_python_37
@pytest.mark.forked
@patch("asyncio.get_running_loop")
@patch("sentry_sdk.integrations.asyncio.Task")
def test_sentry_task_factory_no_factory(MockTask, mock_get_running_loop): # noqa: N803
mock_loop = mock_get_running_loop.return_value
mock_coro = MagicMock()
# Set the original task factory to None
mock_loop.get_task_factory.return_value = None
# Retieve sentry task factory (since it is an inner function within patch_asyncio)
sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
# The call we are testing
ret_val = sentry_task_factory(mock_loop, mock_coro)
assert MockTask.called
assert ret_val == MockTask.return_value
task_args, task_kwargs = MockTask.call_args
assert len(task_args) == 1
coro_param, *_ = task_args
assert inspect.iscoroutine(coro_param)
assert "loop" in task_kwargs
assert task_kwargs["loop"] == mock_loop
@minimum_python_37
@pytest.mark.forked
@patch("asyncio.get_running_loop")
def test_sentry_task_factory_with_factory(mock_get_running_loop):
mock_loop = mock_get_running_loop.return_value
mock_coro = MagicMock()
# The original task factory will be mocked out here, let's retrieve the value for later
orig_task_factory = mock_loop.get_task_factory.return_value
# Retieve sentry task factory (since it is an inner function within patch_asyncio)
sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
# The call we are testing
ret_val = sentry_task_factory(mock_loop, mock_coro)
assert orig_task_factory.called
assert ret_val == orig_task_factory.return_value
task_factory_args, _ = orig_task_factory.call_args
assert len(task_factory_args) == 2
loop_arg, coro_arg = task_factory_args
assert loop_arg == mock_loop
assert inspect.iscoroutine(coro_arg)
@minimum_python_311
@patch("asyncio.get_running_loop")
@patch("sentry_sdk.integrations.asyncio.Task")
def test_sentry_task_factory_context_no_factory(
MockTask, mock_get_running_loop # noqa: N803
):
mock_loop = mock_get_running_loop.return_value
mock_coro = MagicMock()
mock_context = MagicMock()
# Set the original task factory to None
mock_loop.get_task_factory.return_value = None
# Retieve sentry task factory (since it is an inner function within patch_asyncio)
sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
# The call we are testing
ret_val = sentry_task_factory(mock_loop, mock_coro, context=mock_context)
assert MockTask.called
assert ret_val == MockTask.return_value
task_args, task_kwargs = MockTask.call_args
assert len(task_args) == 1
coro_param, *_ = task_args
assert inspect.iscoroutine(coro_param)
assert "loop" in task_kwargs
assert task_kwargs["loop"] == mock_loop
assert "context" in task_kwargs
assert task_kwargs["context"] == mock_context
@minimum_python_311
@patch("asyncio.get_running_loop")
def test_sentry_task_factory_context_with_factory(mock_get_running_loop):
mock_loop = mock_get_running_loop.return_value
mock_coro = MagicMock()
mock_context = MagicMock()
# The original task factory will be mocked out here, let's retrieve the value for later
orig_task_factory = mock_loop.get_task_factory.return_value
# Retieve sentry task factory (since it is an inner function within patch_asyncio)
sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
# The call we are testing
ret_val = sentry_task_factory(mock_loop, mock_coro, context=mock_context)
assert orig_task_factory.called
assert ret_val == orig_task_factory.return_value
task_factory_args, task_factory_kwargs = orig_task_factory.call_args
assert len(task_factory_args) == 2
loop_arg, coro_arg = task_factory_args
assert loop_arg == mock_loop
assert inspect.iscoroutine(coro_arg)
assert "context" in task_factory_kwargs
assert task_factory_kwargs["context"] == mock_context
sentry-python-1.39.2/tests/integrations/asyncpg/ 0000775 0000000 0000000 00000000000 14547447232 0022001 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/asyncpg/__init__.py 0000664 0000000 0000000 00000000124 14547447232 0024107 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("asyncpg")
pytest.importorskip("pytest_asyncio")
sentry-python-1.39.2/tests/integrations/asyncpg/test_asyncpg.py 0000664 0000000 0000000 00000035631 14547447232 0025066 0 ustar 00root root 0000000 0000000 """
Tests need pytest-asyncio installed.
Tests need a local postgresql instance running, this can best be done using
```sh
docker run --rm --name some-postgres -e POSTGRES_USER=foo -e POSTGRES_PASSWORD=bar -d -p 5432:5432 postgres
```
The tests use the following credentials to establish a database connection.
"""
import os
PG_NAME = os.getenv("SENTRY_PYTHON_TEST_POSTGRES_NAME", "postgres")
PG_USER = os.getenv("SENTRY_PYTHON_TEST_POSTGRES_USER", "foo")
PG_PASSWORD = os.getenv("SENTRY_PYTHON_TEST_POSTGRES_PASSWORD", "bar")
PG_HOST = os.getenv("SENTRY_PYTHON_TEST_POSTGRES_HOST", "localhost")
PG_PORT = 5432
import datetime
import asyncpg
import pytest
import pytest_asyncio
from asyncpg import connect, Connection
from sentry_sdk import capture_message, start_transaction
from sentry_sdk.integrations.asyncpg import AsyncPGIntegration
from sentry_sdk.consts import SPANDATA
PG_CONNECTION_URI = "postgresql://{}:{}@{}/{}".format(
PG_USER, PG_PASSWORD, PG_HOST, PG_NAME
)
CRUMBS_CONNECT = {
"category": "query",
"data": {
"db.name": PG_NAME,
"db.system": "postgresql",
"db.user": PG_USER,
"server.address": PG_HOST,
"server.port": PG_PORT,
},
"message": "connect",
"type": "default",
}
@pytest_asyncio.fixture(autouse=True)
async def _clean_pg():
conn = await connect(PG_CONNECTION_URI)
await conn.execute("DROP TABLE IF EXISTS users")
await conn.execute(
"""
CREATE TABLE users(
id serial PRIMARY KEY,
name text,
password text,
dob date
)
"""
)
await conn.close()
@pytest.mark.asyncio
async def test_connect(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [CRUMBS_CONNECT]
@pytest.mark.asyncio
async def test_execute(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES ('Alice', 'pw', '1990-12-25')",
)
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"Bob",
"secret_pw",
datetime.date(1984, 3, 1),
)
row = await conn.fetchrow("SELECT * FROM users WHERE name = $1", "Bob")
assert row == (2, "Bob", "secret_pw", datetime.date(1984, 3, 1))
row = await conn.fetchrow("SELECT * FROM users WHERE name = 'Bob'")
assert row == (2, "Bob", "secret_pw", datetime.date(1984, 3, 1))
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {},
"message": "INSERT INTO users(name, password, dob) VALUES ('Alice', 'pw', '1990-12-25')",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE name = $1",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE name = 'Bob'",
"type": "default",
},
]
@pytest.mark.asyncio
async def test_execute_many(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.executemany(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
[
("Bob", "secret_pw", datetime.date(1984, 3, 1)),
("Alice", "pw", datetime.date(1990, 12, 25)),
],
)
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {"db.executemany": True},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
]
@pytest.mark.asyncio
async def test_record_params(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration(record_params=True)],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"Bob",
"secret_pw",
datetime.date(1984, 3, 1),
)
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {
"db.params": ["Bob", "secret_pw", "datetime.date(1984, 3, 1)"],
"db.paramstyle": "format",
},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
]
@pytest.mark.asyncio
async def test_cursor(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.executemany(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
[
("Bob", "secret_pw", datetime.date(1984, 3, 1)),
("Alice", "pw", datetime.date(1990, 12, 25)),
],
)
async with conn.transaction():
# Postgres requires non-scrollable cursors to be created
# and used in a transaction.
async for record in conn.cursor(
"SELECT * FROM users WHERE dob > $1", datetime.date(1970, 1, 1)
):
print(record)
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {"db.executemany": True},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
{"category": "query", "data": {}, "message": "BEGIN;", "type": "default"},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE dob > $1",
"type": "default",
},
{"category": "query", "data": {}, "message": "COMMIT;", "type": "default"},
]
@pytest.mark.asyncio
async def test_cursor_manual(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.executemany(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
[
("Bob", "secret_pw", datetime.date(1984, 3, 1)),
("Alice", "pw", datetime.date(1990, 12, 25)),
],
)
#
async with conn.transaction():
# Postgres requires non-scrollable cursors to be created
# and used in a transaction.
cur = await conn.cursor(
"SELECT * FROM users WHERE dob > $1", datetime.date(1970, 1, 1)
)
record = await cur.fetchrow()
print(record)
while await cur.forward(1):
record = await cur.fetchrow()
print(record)
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {"db.executemany": True},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
{"category": "query", "data": {}, "message": "BEGIN;", "type": "default"},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE dob > $1",
"type": "default",
},
{"category": "query", "data": {}, "message": "COMMIT;", "type": "default"},
]
@pytest.mark.asyncio
async def test_prepared_stmt(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.executemany(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
[
("Bob", "secret_pw", datetime.date(1984, 3, 1)),
("Alice", "pw", datetime.date(1990, 12, 25)),
],
)
stmt = await conn.prepare("SELECT * FROM users WHERE name = $1")
print(await stmt.fetchval("Bob"))
print(await stmt.fetchval("Alice"))
await conn.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
CRUMBS_CONNECT,
{
"category": "query",
"data": {"db.executemany": True},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE name = $1",
"type": "default",
},
]
@pytest.mark.asyncio
async def test_connection_pool(sentry_init, capture_events) -> None:
sentry_init(
integrations=[AsyncPGIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
pool_size = 2
pool = await asyncpg.create_pool(
PG_CONNECTION_URI, min_size=pool_size, max_size=pool_size
)
async with pool.acquire() as conn:
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"Bob",
"secret_pw",
datetime.date(1984, 3, 1),
)
async with pool.acquire() as conn:
row = await conn.fetchrow("SELECT * FROM users WHERE name = $1", "Bob")
assert row == (1, "Bob", "secret_pw", datetime.date(1984, 3, 1))
await pool.close()
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"] == [
# The connection pool opens pool_size connections so we have the crumbs pool_size times
*[CRUMBS_CONNECT] * pool_size,
{
"category": "query",
"data": {},
"message": "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT pg_advisory_unlock_all();\n"
"CLOSE ALL;\n"
"UNLISTEN *;\n"
"RESET ALL;",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT * FROM users WHERE name = $1",
"type": "default",
},
{
"category": "query",
"data": {},
"message": "SELECT pg_advisory_unlock_all();\n"
"CLOSE ALL;\n"
"UNLISTEN *;\n"
"RESET ALL;",
"type": "default",
},
]
@pytest.mark.asyncio
@pytest.mark.parametrize("enable_db_query_source", [None, False])
async def test_query_source_disabled(
sentry_init, capture_events, enable_db_query_source
):
sentry_options = {
"integrations": [AsyncPGIntegration()],
"enable_tracing": True,
}
if enable_db_query_source is not None:
sentry_options["enable_db_query_source"] = enable_db_query_source
sentry_options["db_query_source_threshold_ms"] = 0
sentry_init(**sentry_options)
events = capture_events()
with start_transaction(name="test_transaction", sampled=True):
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES ('Alice', 'secret', '1990-12-25')",
)
await conn.close()
(event,) = events
span = event["spans"][-1]
assert span["description"].startswith("INSERT INTO")
data = span.get("data", {})
assert SPANDATA.CODE_LINENO not in data
assert SPANDATA.CODE_NAMESPACE not in data
assert SPANDATA.CODE_FILEPATH not in data
assert SPANDATA.CODE_FUNCTION not in data
@pytest.mark.asyncio
async def test_query_source(sentry_init, capture_events):
sentry_init(
integrations=[AsyncPGIntegration()],
enable_tracing=True,
enable_db_query_source=True,
db_query_source_threshold_ms=0,
)
events = capture_events()
with start_transaction(name="test_transaction", sampled=True):
conn: Connection = await connect(PG_CONNECTION_URI)
await conn.execute(
"INSERT INTO users(name, password, dob) VALUES ('Alice', 'secret', '1990-12-25')",
)
await conn.close()
(event,) = events
span = event["spans"][-1]
assert span["description"].startswith("INSERT INTO")
data = span.get("data", {})
assert SPANDATA.CODE_LINENO in data
assert SPANDATA.CODE_NAMESPACE in data
assert SPANDATA.CODE_FILEPATH in data
assert SPANDATA.CODE_FUNCTION in data
assert type(data.get(SPANDATA.CODE_LINENO)) == int
assert data.get(SPANDATA.CODE_LINENO) > 0
assert (
data.get(SPANDATA.CODE_NAMESPACE) == "tests.integrations.asyncpg.test_asyncpg"
)
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"tests/integrations/asyncpg/test_asyncpg.py"
)
is_relative_path = data.get(SPANDATA.CODE_FILEPATH)[0] != os.sep
assert is_relative_path
assert data.get(SPANDATA.CODE_FUNCTION) == "test_query_source"
sentry-python-1.39.2/tests/integrations/aws_lambda/ 0000775 0000000 0000000 00000000000 14547447232 0022427 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/aws_lambda/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0024537 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("boto3")
sentry-python-1.39.2/tests/integrations/aws_lambda/client.py 0000664 0000000 0000000 00000030246 14547447232 0024264 0 ustar 00root root 0000000 0000000 import base64
import boto3
import glob
import hashlib
import os
import subprocess
import sys
import tempfile
from sentry_sdk.consts import VERSION as SDK_VERSION
from sentry_sdk.utils import get_git_revision
AWS_REGION_NAME = "us-east-1"
AWS_CREDENTIALS = {
"aws_access_key_id": os.environ["SENTRY_PYTHON_TEST_AWS_ACCESS_KEY_ID"],
"aws_secret_access_key": os.environ["SENTRY_PYTHON_TEST_AWS_SECRET_ACCESS_KEY"],
}
AWS_LAMBDA_EXECUTION_ROLE_NAME = "lambda-ex"
AWS_LAMBDA_EXECUTION_ROLE_ARN = None
def _install_dependencies(base_dir, subprocess_kwargs):
"""
Installs dependencies for AWS Lambda function
"""
setup_cfg = os.path.join(base_dir, "setup.cfg")
with open(setup_cfg, "w") as f:
f.write("[install]\nprefix=")
# Install requirements for Lambda Layer (these are more limited than the SDK requirements,
# because Lambda does not support the newest versions of some packages)
subprocess.check_call(
[
sys.executable,
"-m",
"pip",
"install",
"-r",
"aws-lambda-layer-requirements.txt",
"--target",
base_dir,
],
**subprocess_kwargs,
)
# Install requirements used for testing
subprocess.check_call(
[
sys.executable,
"-m",
"pip",
"install",
"mock==3.0.0",
"funcsigs",
"--target",
base_dir,
],
**subprocess_kwargs,
)
# Create a source distribution of the Sentry SDK (in parent directory of base_dir)
subprocess.check_call(
[
sys.executable,
"setup.py",
"sdist",
"--dist-dir",
os.path.dirname(base_dir),
],
**subprocess_kwargs,
)
# Install the created Sentry SDK source distribution into the target directory
# Do not install the dependencies of the SDK, because they where installed by aws-lambda-layer-requirements.txt above
source_distribution_archive = glob.glob(
"{}/*.tar.gz".format(os.path.dirname(base_dir))
)[0]
subprocess.check_call(
[
sys.executable,
"-m",
"pip",
"install",
source_distribution_archive,
"--no-deps",
"--target",
base_dir,
],
**subprocess_kwargs,
)
def _create_lambda_function_zip(base_dir):
"""
Zips the given base_dir omitting Python cache files
"""
subprocess.run(
[
"zip",
"-q",
"-x",
"**/__pycache__/*",
"-r",
"lambda-function-package.zip",
"./",
],
cwd=base_dir,
check=True,
)
def _create_lambda_package(
base_dir, code, initial_handler, layer, syntax_check, subprocess_kwargs
):
"""
Creates deployable packages (as zip files) for AWS Lambda function
and optional the accompanying Sentry Lambda layer
"""
if initial_handler:
# If Initial handler value is provided i.e. it is not the default
# `test_lambda.test_handler`, then create another dir level so that our path is
# test_dir.test_lambda.test_handler
test_dir_path = os.path.join(base_dir, "test_dir")
python_init_file = os.path.join(test_dir_path, "__init__.py")
os.makedirs(test_dir_path)
with open(python_init_file, "w"):
# Create __init__ file to make it a python package
pass
test_lambda_py = os.path.join(base_dir, "test_dir", "test_lambda.py")
else:
test_lambda_py = os.path.join(base_dir, "test_lambda.py")
with open(test_lambda_py, "w") as f:
f.write(code)
if syntax_check:
# Check file for valid syntax first, and that the integration does not
# crash when not running in Lambda (but rather a local deployment tool
# such as chalice's)
subprocess.check_call([sys.executable, test_lambda_py])
if layer is None:
_install_dependencies(base_dir, subprocess_kwargs)
_create_lambda_function_zip(base_dir)
else:
_create_lambda_function_zip(base_dir)
# Create Lambda layer zip package
from scripts.build_aws_lambda_layer import build_packaged_zip
build_packaged_zip(
base_dir=base_dir,
make_dist=True,
out_zip_filename="lambda-layer-package.zip",
)
def _get_or_create_lambda_execution_role():
global AWS_LAMBDA_EXECUTION_ROLE_ARN
policy = """{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
"""
iam_client = boto3.client(
"iam",
region_name=AWS_REGION_NAME,
**AWS_CREDENTIALS,
)
try:
response = iam_client.get_role(RoleName=AWS_LAMBDA_EXECUTION_ROLE_NAME)
AWS_LAMBDA_EXECUTION_ROLE_ARN = response["Role"]["Arn"]
except iam_client.exceptions.NoSuchEntityException:
# create role for lambda execution
response = iam_client.create_role(
RoleName=AWS_LAMBDA_EXECUTION_ROLE_NAME,
AssumeRolePolicyDocument=policy,
)
AWS_LAMBDA_EXECUTION_ROLE_ARN = response["Role"]["Arn"]
# attach policy to role
iam_client.attach_role_policy(
RoleName=AWS_LAMBDA_EXECUTION_ROLE_NAME,
PolicyArn="arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
)
def get_boto_client():
_get_or_create_lambda_execution_role()
return boto3.client(
"lambda",
region_name=AWS_REGION_NAME,
**AWS_CREDENTIALS,
)
def run_lambda_function(
client,
runtime,
code,
payload,
add_finalizer,
syntax_check=True,
timeout=30,
layer=None,
initial_handler=None,
subprocess_kwargs=(),
):
"""
Creates a Lambda function with the given code, and invokes it.
If the same code is run multiple times the function will NOT be
created anew each time but the existing function will be reused.
"""
subprocess_kwargs = dict(subprocess_kwargs)
# Making a unique function name depending on all the code that is run in it (function code plus SDK version)
# The name needs to be short so the generated event/envelope json blobs are small enough to be output
# in the log result of the Lambda function.
rev = get_git_revision() or SDK_VERSION
function_hash = hashlib.shake_256((code + rev).encode("utf-8")).hexdigest(6)
fn_name = "test_{}".format(function_hash)
full_fn_name = "{}_{}".format(
fn_name, runtime.replace(".", "").replace("python", "py")
)
function_exists_in_aws = True
try:
client.get_function(
FunctionName=full_fn_name,
)
print(
"Lambda function in AWS already existing, taking it (and do not create a local one)"
)
except client.exceptions.ResourceNotFoundException:
function_exists_in_aws = False
if not function_exists_in_aws:
tmp_base_dir = tempfile.gettempdir()
base_dir = os.path.join(tmp_base_dir, fn_name)
dir_already_existing = os.path.isdir(base_dir)
if dir_already_existing:
print("Local Lambda function directory already exists, skipping creation")
if not dir_already_existing:
os.mkdir(base_dir)
_create_lambda_package(
base_dir, code, initial_handler, layer, syntax_check, subprocess_kwargs
)
@add_finalizer
def clean_up():
# this closes the web socket so we don't get a
# ResourceWarning: unclosed
# warning on every test
# based on https://github.com/boto/botocore/pull/1810
# (if that's ever merged, this can just become client.close())
session = client._endpoint.http_session
managers = [session._manager] + list(session._proxy_managers.values())
for manager in managers:
manager.clear()
layers = []
environment = {}
handler = initial_handler or "test_lambda.test_handler"
if layer is not None:
with open(
os.path.join(base_dir, "lambda-layer-package.zip"), "rb"
) as lambda_layer_zip:
response = client.publish_layer_version(
LayerName="python-serverless-sdk-test",
Description="Created as part of testsuite for getsentry/sentry-python",
Content={"ZipFile": lambda_layer_zip.read()},
)
layers = [response["LayerVersionArn"]]
handler = (
"sentry_sdk.integrations.init_serverless_sdk.sentry_lambda_handler"
)
environment = {
"Variables": {
"SENTRY_INITIAL_HANDLER": initial_handler
or "test_lambda.test_handler",
"SENTRY_DSN": "https://123abc@example.com/123",
"SENTRY_TRACES_SAMPLE_RATE": "1.0",
}
}
try:
with open(
os.path.join(base_dir, "lambda-function-package.zip"), "rb"
) as lambda_function_zip:
client.create_function(
Description="Created as part of testsuite for getsentry/sentry-python",
FunctionName=full_fn_name,
Runtime=runtime,
Timeout=timeout,
Role=AWS_LAMBDA_EXECUTION_ROLE_ARN,
Handler=handler,
Code={"ZipFile": lambda_function_zip.read()},
Environment=environment,
Layers=layers,
)
waiter = client.get_waiter("function_active_v2")
waiter.wait(FunctionName=full_fn_name)
except client.exceptions.ResourceConflictException:
print(
"Lambda function already exists, this is fine, we will just invoke it."
)
response = client.invoke(
FunctionName=full_fn_name,
InvocationType="RequestResponse",
LogType="Tail",
Payload=payload,
)
assert 200 <= response["StatusCode"] < 300, response
return response
# This is for inspecting new Python runtime environments in AWS Lambda
# If you need to debug a new runtime, use this REPL to run arbitrary Python or bash commands
# in that runtime in a Lambda function:
#
# pip3 install click
# python3 tests/integrations/aws_lambda/client.py --runtime=python4.0
#
_REPL_CODE = """
import os
def test_handler(event, context):
line = {line!r}
if line.startswith(">>> "):
exec(line[4:])
elif line.startswith("$ "):
os.system(line[2:])
else:
print("Start a line with $ or >>>")
return b""
"""
try:
import click
except ImportError:
pass
else:
@click.command()
@click.option(
"--runtime", required=True, help="name of the runtime to use, eg python3.11"
)
@click.option("--verbose", is_flag=True, default=False)
def repl(runtime, verbose):
"""
Launch a "REPL" against AWS Lambda to inspect their runtime.
"""
cleanup = []
client = get_boto_client()
print("Start a line with `$ ` to run shell commands, or `>>> ` to run Python")
while True:
line = input()
response = run_lambda_function(
client,
runtime,
_REPL_CODE.format(line=line),
b"",
cleanup.append,
subprocess_kwargs={
"stdout": subprocess.DEVNULL,
"stderr": subprocess.DEVNULL,
}
if not verbose
else {},
)
for line in base64.b64decode(response["LogResult"]).splitlines():
print(line.decode("utf8"))
for f in cleanup:
f()
cleanup = []
if __name__ == "__main__":
repl()
sentry-python-1.39.2/tests/integrations/aws_lambda/test_aws.py 0000664 0000000 0000000 00000067075 14547447232 0024651 0 ustar 00root root 0000000 0000000 """
# AWS Lambda System Tests
This testsuite uses boto3 to upload actual Lambda functions to AWS Lambda and invoke them.
For running test locally you need to set these env vars:
(You can find the values in the Sentry password manager by searching for "AWS Lambda for Python SDK Tests").
export SENTRY_PYTHON_TEST_AWS_ACCESS_KEY_ID="..."
export SENTRY_PYTHON_TEST_AWS_SECRET_ACCESS_KEY="..."
You can use `scripts/aws-cleanup.sh` to delete all files generated by this test suite.
If you need to debug a new runtime, use this REPL to run arbitrary Python or bash commands
in that runtime in a Lambda function: (see the bottom of client.py for more information.)
pip3 install click
python3 tests/integrations/aws_lambda/client.py --runtime=python4.0
IMPORTANT:
During running of this test suite temporary folders will be created for compiling the Lambda functions.
This temporary folders will not be cleaned up. This is because in CI generated files have to be shared
between tests and thus the folders can not be deleted right after use.
If you run your tests locally, you need to clean up the temporary folders manually. The location of
the temporary folders is printed when running a test.
"""
import base64
import json
import re
from textwrap import dedent
import pytest
LAMBDA_PRELUDE = """
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration, get_lambda_bootstrap
import sentry_sdk
import json
import time
from sentry_sdk.transport import HttpTransport
def truncate_data(data):
# AWS Lambda truncates the log output to 4kb, which is small enough to miss
# parts of even a single error-event/transaction-envelope pair if considered
# in full, so only grab the data we need.
cleaned_data = {}
if data.get("type") is not None:
cleaned_data["type"] = data["type"]
if data.get("contexts") is not None:
cleaned_data["contexts"] = {}
if data["contexts"].get("trace") is not None:
cleaned_data["contexts"]["trace"] = data["contexts"].get("trace")
if data.get("transaction") is not None:
cleaned_data["transaction"] = data.get("transaction")
if data.get("request") is not None:
cleaned_data["request"] = data.get("request")
if data.get("tags") is not None:
cleaned_data["tags"] = data.get("tags")
if data.get("exception") is not None:
cleaned_data["exception"] = data.get("exception")
for value in cleaned_data["exception"]["values"]:
for frame in value.get("stacktrace", {}).get("frames", []):
del frame["vars"]
del frame["pre_context"]
del frame["context_line"]
del frame["post_context"]
if data.get("extra") is not None:
cleaned_data["extra"] = {}
for key in data["extra"].keys():
if key == "lambda":
for lambda_key in data["extra"]["lambda"].keys():
if lambda_key in ["function_name"]:
cleaned_data["extra"].setdefault("lambda", {})[lambda_key] = data["extra"]["lambda"][lambda_key]
elif key == "cloudwatch logs":
for cloudwatch_key in data["extra"]["cloudwatch logs"].keys():
if cloudwatch_key in ["url", "log_group", "log_stream"]:
cleaned_data["extra"].setdefault("cloudwatch logs", {})[cloudwatch_key] = data["extra"]["cloudwatch logs"][cloudwatch_key]
if data.get("level") is not None:
cleaned_data["level"] = data.get("level")
if data.get("message") is not None:
cleaned_data["message"] = data.get("message")
if "contexts" not in cleaned_data:
raise Exception(json.dumps(data))
return cleaned_data
def event_processor(event):
return truncate_data(event)
def envelope_processor(envelope):
(item,) = envelope.items
item_json = json.loads(item.get_bytes())
return truncate_data(item_json)
class TestTransport(HttpTransport):
def _send_event(self, event):
event = event_processor(event)
print("\\nEVENT: {}\\n".format(json.dumps(event)))
def _send_envelope(self, envelope):
envelope = envelope_processor(envelope)
print("\\nENVELOPE: {}\\n".format(json.dumps(envelope)))
def init_sdk(timeout_warning=False, **extra_init_args):
sentry_sdk.init(
dsn="https://123abc@example.com/123",
transport=TestTransport,
integrations=[AwsLambdaIntegration(timeout_warning=timeout_warning)],
shutdown_timeout=10,
**extra_init_args
)
"""
@pytest.fixture
def lambda_client():
from tests.integrations.aws_lambda.client import get_boto_client
return get_boto_client()
@pytest.fixture(
params=[
"python3.7",
"python3.8",
"python3.9",
"python3.10",
"python3.11",
]
)
def lambda_runtime(request):
return request.param
@pytest.fixture
def run_lambda_function(request, lambda_client, lambda_runtime):
def inner(
code, payload, timeout=30, syntax_check=True, layer=None, initial_handler=None
):
from tests.integrations.aws_lambda.client import run_lambda_function
response = run_lambda_function(
client=lambda_client,
runtime=lambda_runtime,
code=code,
payload=payload,
add_finalizer=request.addfinalizer,
timeout=timeout,
syntax_check=syntax_check,
layer=layer,
initial_handler=initial_handler,
)
# Make sure the "ENVELOPE:" and "EVENT:" log entries are always starting a new line. (Sometimes they don't.)
response["LogResult"] = (
base64.b64decode(response["LogResult"])
.replace(b"EVENT:", b"\nEVENT:")
.replace(b"ENVELOPE:", b"\nENVELOPE:")
.splitlines()
)
response["Payload"] = json.loads(response["Payload"].read().decode("utf-8"))
del response["ResponseMetadata"]
events = []
envelopes = []
for line in response["LogResult"]:
print("AWS:", line)
if line.startswith(b"EVENT: "):
line = line[len(b"EVENT: ") :]
events.append(json.loads(line.decode("utf-8")))
elif line.startswith(b"ENVELOPE: "):
line = line[len(b"ENVELOPE: ") :]
envelopes.append(json.loads(line.decode("utf-8")))
else:
continue
return envelopes, events, response
return inner
def test_basic(run_lambda_function):
_, events, response = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk()
def test_handler(event, context):
raise Exception("Oh!")
"""
),
b'{"foo": "bar"}',
)
assert response["FunctionError"] == "Unhandled"
(event,) = events
assert event["level"] == "error"
(exception,) = event["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "Oh!"
(frame1,) = exception["stacktrace"]["frames"]
assert frame1["filename"] == "test_lambda.py"
assert frame1["abs_path"] == "/var/task/test_lambda.py"
assert frame1["function"] == "test_handler"
assert frame1["in_app"] is True
assert exception["mechanism"]["type"] == "aws_lambda"
assert not exception["mechanism"]["handled"]
assert event["extra"]["lambda"]["function_name"].startswith("test_")
logs_url = event["extra"]["cloudwatch logs"]["url"]
assert logs_url.startswith("https://console.aws.amazon.com/cloudwatch/home?region=")
assert not re.search("(=;|=$)", logs_url)
assert event["extra"]["cloudwatch logs"]["log_group"].startswith(
"/aws/lambda/test_"
)
log_stream_re = "^[0-9]{4}/[0-9]{2}/[0-9]{2}/\\[[^\\]]+][a-f0-9]+$"
log_stream = event["extra"]["cloudwatch logs"]["log_stream"]
assert re.match(log_stream_re, log_stream)
def test_initialization_order(run_lambda_function):
"""Zappa lazily imports our code, so by the time we monkeypatch the handler
as seen by AWS already runs. At this point at least draining the queue
should work."""
_, events, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
def test_handler(event, context):
init_sdk()
sentry_sdk.capture_exception(Exception("Oh!"))
"""
),
b'{"foo": "bar"}',
)
(event,) = events
assert event["level"] == "error"
(exception,) = event["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "Oh!"
def test_request_data(run_lambda_function):
_, events, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk()
def test_handler(event, context):
sentry_sdk.capture_message("hi")
return "ok"
"""
),
payload=b"""
{
"resource": "/asd",
"path": "/asd",
"httpMethod": "GET",
"headers": {
"Host": "iwsz2c7uwi.execute-api.us-east-1.amazonaws.com",
"User-Agent": "custom",
"X-Forwarded-Proto": "https"
},
"queryStringParameters": {
"bonkers": "true"
},
"pathParameters": null,
"stageVariables": null,
"requestContext": {
"identity": {
"sourceIp": "213.47.147.207",
"userArn": "42"
}
},
"body": null,
"isBase64Encoded": false
}
""",
)
(event,) = events
assert event["request"] == {
"headers": {
"Host": "iwsz2c7uwi.execute-api.us-east-1.amazonaws.com",
"User-Agent": "custom",
"X-Forwarded-Proto": "https",
},
"method": "GET",
"query_string": {"bonkers": "true"},
"url": "https://iwsz2c7uwi.execute-api.us-east-1.amazonaws.com/asd",
}
def test_init_error(run_lambda_function, lambda_runtime):
_, events, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk()
func()
"""
),
b'{"foo": "bar"}',
syntax_check=False,
)
(event,) = events
assert event["exception"]["values"][0]["value"] == "name 'func' is not defined"
def test_timeout_error(run_lambda_function):
_, events, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk(timeout_warning=True)
def test_handler(event, context):
time.sleep(10)
return 0
"""
),
b'{"foo": "bar"}',
timeout=2,
)
(event,) = events
assert event["level"] == "error"
(exception,) = event["exception"]["values"]
assert exception["type"] == "ServerlessTimeoutWarning"
assert exception["value"] in (
"WARNING : Function is expected to get timed out. Configured timeout duration = 3 seconds.",
"WARNING : Function is expected to get timed out. Configured timeout duration = 2 seconds.",
)
assert exception["mechanism"]["type"] == "threading"
assert not exception["mechanism"]["handled"]
assert event["extra"]["lambda"]["function_name"].startswith("test_")
logs_url = event["extra"]["cloudwatch logs"]["url"]
assert logs_url.startswith("https://console.aws.amazon.com/cloudwatch/home?region=")
assert not re.search("(=;|=$)", logs_url)
assert event["extra"]["cloudwatch logs"]["log_group"].startswith(
"/aws/lambda/test_"
)
log_stream_re = "^[0-9]{4}/[0-9]{2}/[0-9]{2}/\\[[^\\]]+][a-f0-9]+$"
log_stream = event["extra"]["cloudwatch logs"]["log_stream"]
assert re.match(log_stream_re, log_stream)
def test_performance_no_error(run_lambda_function):
envelopes, _, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk(traces_sample_rate=1.0)
def test_handler(event, context):
return "test_string"
"""
),
b'{"foo": "bar"}',
)
(envelope,) = envelopes
assert envelope["type"] == "transaction"
assert envelope["contexts"]["trace"]["op"] == "function.aws"
assert envelope["transaction"].startswith("test_")
assert envelope["transaction"] in envelope["request"]["url"]
def test_performance_error(run_lambda_function):
envelopes, _, _ = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk(traces_sample_rate=1.0)
def test_handler(event, context):
raise Exception("Oh!")
"""
),
b'{"foo": "bar"}',
)
(
error_event,
transaction_event,
) = envelopes
assert error_event["level"] == "error"
(exception,) = error_event["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "Oh!"
assert transaction_event["type"] == "transaction"
assert transaction_event["contexts"]["trace"]["op"] == "function.aws"
assert transaction_event["transaction"].startswith("test_")
assert transaction_event["transaction"] in transaction_event["request"]["url"]
@pytest.mark.parametrize(
"aws_event, has_request_data, batch_size",
[
(b"1231", False, 1),
(b"11.21", False, 1),
(b'"Good dog!"', False, 1),
(b"true", False, 1),
(
b"""
[
{"good dog": "Maisey"},
{"good dog": "Charlie"},
{"good dog": "Cory"},
{"good dog": "Bodhi"}
]
""",
False,
4,
),
(
b"""
[
{
"headers": {
"Host": "x.io",
"X-Forwarded-Proto": "http"
},
"httpMethod": "GET",
"path": "/somepath",
"queryStringParameters": {
"done": "true"
},
"dog": "Maisey"
},
{
"headers": {
"Host": "x.io",
"X-Forwarded-Proto": "http"
},
"httpMethod": "GET",
"path": "/somepath",
"queryStringParameters": {
"done": "true"
},
"dog": "Charlie"
}
]
""",
True,
2,
),
],
)
def test_non_dict_event(
run_lambda_function,
aws_event,
has_request_data,
batch_size,
DictionaryContaining, # noqa:N803
):
envelopes, _, response = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk(traces_sample_rate=1.0)
def test_handler(event, context):
raise Exception("Oh?")
"""
),
aws_event,
)
assert response["FunctionError"] == "Unhandled"
(
error_event,
transaction_event,
) = envelopes
assert error_event["level"] == "error"
assert error_event["contexts"]["trace"]["op"] == "function.aws"
function_name = error_event["extra"]["lambda"]["function_name"]
assert function_name.startswith("test_")
assert error_event["transaction"] == function_name
exception = error_event["exception"]["values"][0]
assert exception["type"] == "Exception"
assert exception["value"] == "Oh?"
assert exception["mechanism"]["type"] == "aws_lambda"
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"]["url"] == error_event["request"]["url"]
if has_request_data:
request_data = {
"headers": {"Host": "x.io", "X-Forwarded-Proto": "http"},
"method": "GET",
"url": "http://x.io/somepath",
"query_string": {
"done": "true",
},
}
else:
request_data = {"url": "awslambda:///{}".format(function_name)}
assert error_event["request"] == request_data
assert transaction_event["request"] == request_data
if batch_size > 1:
assert error_event["tags"]["batch_size"] == batch_size
assert error_event["tags"]["batch_request"] is True
assert transaction_event["tags"]["batch_size"] == batch_size
assert transaction_event["tags"]["batch_request"] is True
def test_traces_sampler_gets_correct_values_in_sampling_context(
run_lambda_function,
DictionaryContaining, # 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
# `inspect.getsource` and a copy of `_safe_is_equal` included directly in
# the code below. Ideas which have been discussed to fix this:
# - Include the test suite as a module installed in the package which is
# shot up to AWS
# - In client.py, copy `conftest.py` (or wherever the necessary code lives)
# from the test suite into the main SDK directory so it gets included as
# "part of the SDK"
# It's also worth noting why it's necessary to run the assertions in the AWS
# runtime rather than asserting on side effects the way we do with events
# and envelopes. The reasons are two-fold:
# - We're testing against the `LambdaContext` class, which only exists in
# the AWS runtime
# - If we were to transmit call args data they way we transmit event and
# envelope data (through JSON), we'd quickly run into the problem that all
# sorts of stuff isn't serializable by `json.dumps` out of the box, up to
# and including `datetime` objects (so anything with a timestamp is
# automatically out)
# Perhaps these challenges can be solved in a cleaner and more systematic
# way if we ever decide to refactor the entire AWS testing apparatus.
import inspect
_, _, response = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(inspect.getsource(StringContaining))
+ dedent(inspect.getsource(DictionaryContaining))
+ dedent(inspect.getsource(ObjectDescribedBy))
+ dedent(
"""
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
def _safe_is_equal(x, y):
# copied from conftest.py - see docstring and comments there
try:
is_equal = x.__eq__(y)
except AttributeError:
is_equal = NotImplemented
if is_equal == NotImplemented:
# using == smoothes out weird variations exposed by raw __eq__
return x == y
return is_equal
def test_handler(event, context):
# this runs after the transaction has started, which means we
# can make assertions about traces_sampler
try:
traces_sampler.assert_any_call(
DictionaryContaining(
{
"aws_event": DictionaryContaining({
"httpMethod": "GET",
"path": "/sit/stay/rollover",
"headers": {"Host": "x.io", "X-Forwarded-Proto": "http"},
}),
"aws_context": ObjectDescribedBy(
type=get_lambda_bootstrap().LambdaContext,
attrs={
'function_name': StringContaining("test_"),
'function_version': '$LATEST',
}
)
}
)
)
except AssertionError:
# catch the error and return it because the error itself will
# get swallowed by the SDK as an "internal exception"
return {"AssertionError raised": True,}
return {"AssertionError raised": False,}
traces_sampler = mock.Mock(return_value=True)
init_sdk(
traces_sampler=traces_sampler,
)
"""
),
b'{"httpMethod": "GET", "path": "/sit/stay/rollover", "headers": {"Host": "x.io", "X-Forwarded-Proto": "http"}}',
)
assert response["Payload"]["AssertionError raised"] is False
def test_serverless_no_code_instrumentation(run_lambda_function):
"""
Test that ensures that just by adding a lambda layer containing the
python sdk, with no code changes sentry is able to capture errors
"""
for initial_handler in [
None,
"test_dir/test_lambda.test_handler",
"test_dir.test_lambda.test_handler",
]:
print("Testing Initial Handler ", initial_handler)
_, _, response = run_lambda_function(
dedent(
"""
import sentry_sdk
def test_handler(event, context):
current_client = sentry_sdk.Hub.current.client
assert current_client is not None
assert len(current_client.options['integrations']) == 1
assert isinstance(current_client.options['integrations'][0],
sentry_sdk.integrations.aws_lambda.AwsLambdaIntegration)
raise Exception("Oh!")
"""
),
b'{"foo": "bar"}',
layer=True,
initial_handler=initial_handler,
)
assert response["FunctionError"] == "Unhandled"
assert response["StatusCode"] == 200
assert response["Payload"]["errorType"] != "AssertionError"
assert response["Payload"]["errorType"] == "Exception"
assert response["Payload"]["errorMessage"] == "Oh!"
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("Oh!")
"""
),
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("Oh!")
"""
),
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)
# We simulate here AWS Api Gateway's behavior of passing HTTP headers
# as the `headers` dict in the event passed to the Lambda function.
payload = {
"headers": {
"sentry-trace": sentry_trace_header,
}
}
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("Oh!")
"""
),
payload=json.dumps(payload).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)
# We simulate here AWS Api Gateway's behavior of passing HTTP headers
# as the `headers` dict in the event passed to the Lambda function.
payload = {
"headers": {
"sentry-trace": sentry_trace_header,
}
}
_, 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("Oh!")
"""
),
payload=json.dumps(payload).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"
)
def test_basic_with_eventbridge_source(run_lambda_function):
_, events, response = run_lambda_function(
LAMBDA_PRELUDE
+ dedent(
"""
init_sdk()
def test_handler(event, context):
raise Exception("Oh!")
"""
),
b'[{"topic":"lps-ranges","partition":1,"offset":0,"timestamp":1701268939207,"timestampType":"CREATE_TIME","key":"REDACTED","value":"REDACTED","headers":[],"eventSourceArn":"REDACTED","bootstrapServers":"REDACTED","eventSource":"aws:kafka","eventSourceKey":"lps-ranges-1"}]',
)
assert response["FunctionError"] == "Unhandled"
(event,) = events
assert event["level"] == "error"
(exception,) = event["exception"]["values"]
assert exception["type"] == "Exception"
assert exception["value"] == "Oh!"
sentry-python-1.39.2/tests/integrations/beam/ 0000775 0000000 0000000 00000000000 14547447232 0021241 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/beam/__init__.py 0000664 0000000 0000000 00000000062 14547447232 0023350 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("apache_beam")
sentry-python-1.39.2/tests/integrations/beam/test_beam.py 0000664 0000000 0000000 00000013454 14547447232 0023565 0 ustar 00root root 0000000 0000000 import pytest
import inspect
import dill
from sentry_sdk.integrations.beam import (
BeamIntegration,
_wrap_task_call,
_wrap_inspect_call,
)
from apache_beam.typehints.trivial_inference import instance_to_type
from apache_beam.typehints.decorators import getcallargs_forhints
from apache_beam.transforms.core import DoFn, ParDo, _DoFnParam, CallableWrapperDoFn
from apache_beam.runners.common import DoFnInvoker, DoFnContext
from apache_beam.utils.windowed_value import WindowedValue
try:
from apache_beam.runners.common import OutputHandler
except ImportError:
from apache_beam.runners.common import OutputProcessor as OutputHandler
def foo():
return True
def bar(x, y):
# print(x + y)
return True
def baz(x, y=2):
# print(x + y)
return True
class A:
def __init__(self, fn):
self.r = "We are in A"
self.fn = fn
self._inspect_fn = _wrap_inspect_call(self, "fn")
def process(self):
return self.fn()
class B(A, object):
def fa(self, x, element=False, another_element=False):
if x or (element and not another_element):
# print(self.r)
return True
1 / 0
return False
def __init__(self):
self.r = "We are in B"
super(B, self).__init__(self.fa)
class SimpleFunc(DoFn):
def process(self, x):
if x:
1 / 0
return [True]
class PlaceHolderFunc(DoFn):
def process(self, x, timestamp=DoFn.TimestampParam, wx=DoFn.WindowParam):
if isinstance(timestamp, _DoFnParam) or isinstance(wx, _DoFnParam):
raise Exception("Bad instance")
if x:
1 / 0
yield True
def fail(x):
if x:
1 / 0
return [True]
test_parent = A(foo)
test_child = B()
test_simple = SimpleFunc()
test_place_holder = PlaceHolderFunc()
test_callable = CallableWrapperDoFn(fail)
# Cannot call simple functions or placeholder test.
@pytest.mark.parametrize(
"obj,f,args,kwargs",
[
[test_parent, "fn", (), {}],
[test_child, "fn", (False,), {"element": True}],
[test_child, "fn", (True,), {}],
[test_simple, "process", (False,), {}],
[test_callable, "process", (False,), {}],
],
)
def test_monkey_patch_call(obj, f, args, kwargs):
func = getattr(obj, f)
assert func(*args, **kwargs)
assert _wrap_task_call(func)(*args, **kwargs)
@pytest.mark.parametrize("f", [foo, bar, baz, test_parent.fn, test_child.fn])
def test_monkey_patch_pickle(f):
f_temp = _wrap_task_call(f)
assert dill.pickles(f_temp), "{} is not pickling correctly!".format(f)
# Pickle everything
s1 = dill.dumps(f_temp)
s2 = dill.loads(s1)
dill.dumps(s2)
@pytest.mark.parametrize(
"f,args,kwargs",
[
[foo, (), {}],
[bar, (1, 5), {}],
[baz, (1,), {}],
[test_parent.fn, (), {}],
[test_child.fn, (False,), {"element": True}],
[test_child.fn, (True,), {}],
],
)
def test_monkey_patch_signature(f, args, kwargs):
arg_types = [instance_to_type(v) for v in args]
kwargs_types = {k: instance_to_type(v) for (k, v) in kwargs.items()}
f_temp = _wrap_task_call(f)
try:
getcallargs_forhints(f, *arg_types, **kwargs_types)
except Exception:
print("Failed on {} with parameters {}, {}".format(f, args, kwargs))
raise
try:
getcallargs_forhints(f_temp, *arg_types, **kwargs_types)
except Exception:
print("Failed on {} with parameters {}, {}".format(f_temp, args, kwargs))
raise
try:
expected_signature = inspect.signature(f)
test_signature = inspect.signature(f_temp)
assert (
expected_signature == test_signature
), "Failed on {}, signature {} does not match {}".format(
f, expected_signature, test_signature
)
except Exception:
# expected to pass for py2.7
pass
class _OutputHandler(OutputHandler):
def process_outputs(
self, windowed_input_element, results, watermark_estimator=None
):
self.handle_process_outputs(
windowed_input_element, results, watermark_estimator
)
def handle_process_outputs(
self, windowed_input_element, results, watermark_estimator=None
):
print(windowed_input_element)
try:
for result in results:
assert result
except StopIteration:
print("In here")
@pytest.fixture
def init_beam(sentry_init):
def inner(fn):
sentry_init(default_integrations=False, integrations=[BeamIntegration()])
# Little hack to avoid having to run the whole pipeline.
pardo = ParDo(fn)
signature = pardo._signature
output_processor = _OutputHandler()
return DoFnInvoker.create_invoker(
signature, output_processor, DoFnContext("test")
)
return inner
@pytest.mark.parametrize("fn", [test_simple, test_callable, test_place_holder])
def test_invoker_normal(init_beam, fn):
invoker = init_beam(fn)
print("Normal testing {} with {} invoker.".format(fn, invoker))
windowed_value = WindowedValue(False, 0, [None])
invoker.invoke_process(windowed_value)
@pytest.mark.parametrize("fn", [test_simple, test_callable, test_place_holder])
def test_invoker_exception(init_beam, capture_events, capture_exceptions, fn):
invoker = init_beam(fn)
events = capture_events()
print("Exception testing {} with {} invoker.".format(fn, invoker))
# Window value will always have one value for the process to run.
windowed_value = WindowedValue(True, 0, [None])
try:
invoker.invoke_process(windowed_value)
except Exception:
pass
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "beam"
sentry-python-1.39.2/tests/integrations/boto3/ 0000775 0000000 0000000 00000000000 14547447232 0021363 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/boto3/__init__.py 0000664 0000000 0000000 00000000346 14547447232 0023477 0 ustar 00root root 0000000 0000000 import pytest
import os
pytest.importorskip("boto3")
xml_fixture_path = os.path.dirname(os.path.abspath(__file__))
def read_fixture(name):
with open(os.path.join(xml_fixture_path, name), "rb") as f:
return f.read()
sentry-python-1.39.2/tests/integrations/boto3/aws_mock.py 0000664 0000000 0000000 00000001563 14547447232 0023545 0 ustar 00root root 0000000 0000000 from io import BytesIO
from botocore.awsrequest import AWSResponse
class Body(BytesIO):
def stream(self, **kwargs):
contents = self.read()
while contents:
yield contents
contents = self.read()
class MockResponse(object):
def __init__(self, client, status_code, headers, body):
self._client = client
self._status_code = status_code
self._headers = headers
self._body = body
def __enter__(self):
self._client.meta.events.register("before-send", self)
return self
def __exit__(self, exc_type, exc_value, traceback):
self._client.meta.events.unregister("before-send", self)
def __call__(self, request, **kwargs):
return AWSResponse(
request.url,
self._status_code,
self._headers,
Body(self._body),
)
sentry-python-1.39.2/tests/integrations/boto3/s3_list.xml 0000664 0000000 0000000 00000001545 14547447232 0023472 0 ustar 00root root 0000000 0000000
marshalls-furious-bucket 1000 url false foo.txt 2020-10-24T00:13:39.000Z "a895ba674b4abd01b5d67cfd7074b827" 206453 7bef397f7e536914d1ff1bbdb105ed90bcfd06269456bf4a06c6e2e54564daf7 STANDARD bar.txt 2020-10-02T15:15:20.000Z "a895ba674b4abd01b5d67cfd7074b827" 206453 7bef397f7e536914d1ff1bbdb105ed90bcfd06269456bf4a06c6e2e54564daf7 STANDARD ")
def hi_with_id(message_id):
capture_message("hi")
return "ok"
@app.route("/message-named-route", name="hi")
def named_hi():
capture_message("hi")
return "ok"
yield app
@pytest.fixture
def get_client(app):
def inner():
return Client(app)
return inner
def test_has_context(sentry_init, app, capture_events, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
events = capture_events()
client = get_client()
response = client.get("/message")
assert response[1] == "200 OK"
(event,) = events
assert event["message"] == "hi"
assert "data" not in event["request"]
assert event["request"]["url"] == "http://localhost/message"
@pytest.mark.parametrize(
"url,transaction_style,expected_transaction,expected_source",
[
("/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,
url,
transaction_style,
expected_transaction,
expected_source,
capture_events,
get_client,
):
sentry_init(
integrations=[
bottle_sentry.BottleIntegration(transaction_style=transaction_style)
]
)
events = capture_events()
client = get_client()
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"])
@pytest.mark.parametrize("catchall", (True, False), ids=["catchall", "nocatchall"])
def test_errors(
sentry_init, capture_exceptions, capture_events, app, debug, catchall, get_client
):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
app.catchall = catchall
set_debug(mode=debug)
exceptions = capture_exceptions()
events = capture_events()
@app.route("/")
def index():
1 / 0
client = get_client()
try:
client.get("/")
except ZeroDivisionError:
pass
(exc,) = exceptions
assert isinstance(exc, ZeroDivisionError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "bottle"
assert event["exception"]["values"][0]["mechanism"]["handled"] is False
def test_large_json_request(sentry_init, capture_events, app, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
data = {"foo": {"bar": "a" * 2000}}
@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.get("/")
response = client.post("/", content_type="application/json", data=json.dumps(data))
assert response[1] == "200 OK"
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
def test_empty_json_request(sentry_init, capture_events, app, data, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
@app.route("/", method="POST")
def index():
import bottle
assert bottle.request.json == data
assert bottle.request.body.read() == json.dumps(data).encode("ascii")
# assert not bottle.request.forms
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
def test_medium_formdata_request(sentry_init, capture_events, app, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
data = {"foo": "a" * 2000}
@app.route("/", method="POST")
def index():
import bottle
assert bottle.request.forms["foo"] == data["foo"]
capture_message("hi")
return "ok"
events = capture_events()
client = get_client()
response = client.post("/", data=data)
assert response[1] == "200 OK"
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]) == 1024
@pytest.mark.parametrize("input_char", ["a", b"a"])
def test_too_large_raw_request(
sentry_init, input_char, capture_events, app, get_client
):
sentry_init(
integrations=[bottle_sentry.BottleIntegration()], max_request_body_size="small"
)
data = input_char * 2000
@app.route("/", method="POST")
def index():
import bottle
if isinstance(data, bytes):
assert bottle.request.body.read() == data
else:
assert bottle.request.body.read() == data.encode("ascii")
assert not bottle.request.json
capture_message("hi")
return "ok"
events = capture_events()
client = get_client()
response = client.post("/", data=data)
assert response[1] == "200 OK"
(event,) = events
assert event["_meta"]["request"]["data"] == {"": {"rem": [["!config", "x"]]}}
assert not event["request"]["data"]
def test_files_and_form(sentry_init, capture_events, app, get_client):
sentry_init(
integrations=[bottle_sentry.BottleIntegration()], max_request_body_size="always"
)
data = {"foo": "a" * 2000, "file": (BytesIO(b"hello"), "hello.txt")}
@app.route("/", method="POST")
def index():
import bottle
assert list(bottle.request.forms) == ["foo"]
assert list(bottle.request.files) == ["file"]
assert not bottle.request.json
capture_message("hi")
return "ok"
events = capture_events()
client = get_client()
response = client.post("/", data=data)
assert response[1] == "200 OK"
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]) == 1024
assert event["_meta"]["request"]["data"]["file"] == {
"": {
"rem": [["!raw", "x"]],
}
}
assert not event["request"]["data"]["file"]
def test_json_not_truncated_if_max_request_body_size_is_always(
sentry_init, capture_events, app, get_client
):
sentry_init(
integrations=[bottle_sentry.BottleIntegration()], max_request_body_size="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",
[
[bottle_sentry.BottleIntegration()],
[bottle_sentry.BottleIntegration(), LoggingIntegration(event_level="ERROR")],
],
)
def test_errors_not_reported_twice(
sentry_init, integrations, capture_events, app, get_client
):
sentry_init(integrations=integrations)
app.catchall = False
logger = logging.getLogger("bottle.app")
@app.route("/")
def index():
try:
1 / 0
except Exception as e:
logger.exception(e)
raise e
events = capture_events()
client = get_client()
with pytest.raises(ZeroDivisionError):
client.get("/")
assert len(events) == 1
def test_logging(sentry_init, capture_events, app, get_client):
# ensure that Bottle's logger magic doesn't break ours
sentry_init(
integrations=[
bottle_sentry.BottleIntegration(),
LoggingIntegration(event_level="ERROR"),
]
)
@app.route("/")
def index():
app.logger.error("hi")
return "ok"
events = capture_events()
client = get_client()
client.get("/")
(event,) = events
assert event["level"] == "error"
def test_mount(app, capture_exceptions, capture_events, sentry_init, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
app.catchall = False
def crashing_app(environ, start_response):
1 / 0
app.mount("/wsgi/", crashing_app)
client = Client(app)
exceptions = capture_exceptions()
events = capture_events()
with pytest.raises(ZeroDivisionError) as exc:
client.get("/wsgi/")
(error,) = exceptions
assert error is exc.value
(event,) = events
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):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
set_debug(False)
app.catchall = True
@app.route("/")
def index():
1 / 0
@app.error(500)
def error_handler(err):
capture_message("error_msg")
return "My error"
events = capture_events()
client = get_client()
response = client.get("/")
assert response[1] == "500 Internal Server Error"
_, event = events
assert event["message"] == "error_msg"
def test_error_in_errorhandler(sentry_init, capture_events, app, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
set_debug(False)
app.catchall = True
@app.route("/")
def index():
raise ValueError()
@app.error(500)
def error_handler(err):
1 / 0
events = capture_events()
client = get_client()
with pytest.raises(ZeroDivisionError):
client.get("/")
event1, event2 = events
(exception,) = event1["exception"]["values"]
assert exception["type"] == "ValueError"
exception = event2["exception"]["values"][0]
assert exception["type"] == "ZeroDivisionError"
def test_bad_request_not_captured(sentry_init, capture_events, app, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
events = capture_events()
@app.route("/")
def index():
abort(400, "bad request in")
client = get_client()
client.get("/")
assert not events
def test_no_exception_on_redirect(sentry_init, capture_events, app, get_client):
sentry_init(integrations=[bottle_sentry.BottleIntegration()])
events = capture_events()
@app.route("/")
def index():
redirect("/here")
@app.route("/here")
def here():
return "here"
client = get_client()
client.get("/")
assert not events
sentry-python-1.39.2/tests/integrations/celery/ 0000775 0000000 0000000 00000000000 14547447232 0021620 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/celery/__init__.py 0000664 0000000 0000000 00000000055 14547447232 0023731 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("celery")
sentry-python-1.39.2/tests/integrations/celery/test_celery.py 0000664 0000000 0000000 00000044244 14547447232 0024524 0 ustar 00root root 0000000 0000000 import threading
import pytest
from sentry_sdk import Hub, configure_scope, start_transaction, get_current_span
from sentry_sdk.integrations.celery import (
CeleryIntegration,
_get_headers,
_wrap_apply_async,
)
from sentry_sdk._compat import text_type
from celery import Celery, VERSION
from celery.bin import worker
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
@pytest.fixture
def connect_signal(request):
def inner(signal, f):
signal.connect(f)
request.addfinalizer(lambda: signal.disconnect(f))
return inner
@pytest.fixture
def init_celery(sentry_init, request):
def inner(propagate_traces=True, backend="always_eager", **kwargs):
sentry_init(
integrations=[CeleryIntegration(propagate_traces=propagate_traces)],
**kwargs
)
celery = Celery(__name__)
if backend == "always_eager":
if VERSION < (4,):
celery.conf.CELERY_ALWAYS_EAGER = True
else:
celery.conf.task_always_eager = True
elif backend == "redis":
# broken on celery 3
if VERSION < (4,):
pytest.skip("Redis backend broken for some reason")
# this backend requires capture_events_forksafe
celery.conf.worker_max_tasks_per_child = 1
celery.conf.worker_concurrency = 1
celery.conf.broker_url = "redis://127.0.0.1:6379"
celery.conf.result_backend = "redis://127.0.0.1:6379"
celery.conf.task_always_eager = False
Hub.main.bind_client(Hub.current.client)
request.addfinalizer(lambda: Hub.main.bind_client(None))
# Once we drop celery 3 we can use the celery_worker fixture
if VERSION < (5,):
worker_fn = worker.worker(app=celery).run
else:
from celery.bin.base import CLIContext
worker_fn = lambda: worker.worker(
obj=CLIContext(app=celery, no_color=True, workdir=".", quiet=False),
args=[],
)
worker_thread = threading.Thread(target=worker_fn)
worker_thread.daemon = True
worker_thread.start()
else:
raise ValueError(backend)
return celery
return inner
@pytest.fixture
def celery(init_celery):
return 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.apply_async(args=(x, y)),
{"args": [x, y], "kwargs": {}},
),
lambda task, x, y: (
task.apply_async(kwargs=dict(x=x, y=y)),
{"args": [], "kwargs": {"x": x, "y": y}},
),
]
)
def celery_invocation(request):
"""
Invokes a task in multiple ways Celery allows you to (testing our apply_async monkeypatch).
Currently limited to a task signature of the form foo(x, y)
"""
return request.param
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")
def dummy_task(x, y):
foo = 42 # noqa
return x / y
with start_transaction(op="unit test transaction") as transaction:
celery_invocation(dummy_task, 1, 2)
_, expected_context = celery_invocation(dummy_task, 1, 0)
(_, error_event, _, _) = events
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,) = 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)
@celery.task(name="dummy_task")
def dummy_task(x, y):
return x / y
# XXX: For some reason the first call does not get instrumented properly.
celery_invocation(dummy_task, 1, 1)
events = capture_events()
with start_transaction(name="submission") as transaction:
celery_invocation(dummy_task, 1, 0 if task_fails else 1)
if task_fails:
error_event = events.pop(0)
assert error_event["contexts"]["trace"]["trace_id"] == transaction.trace_id
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
assert submission_event["contexts"]["trace"]["trace_id"] == transaction.trace_id
if task_fails:
assert execution_event["contexts"]["trace"]["status"] == "internal_error"
else:
assert execution_event["contexts"]["trace"]["status"] == "ok"
assert execution_event["spans"] == []
assert submission_event["spans"] == [
{
"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),
}
]
def test_no_stackoverflows(celery):
"""We used to have a bug in the Celery integration where its monkeypatching
was repeated for every task invocation, leading to stackoverflows.
See https://github.com/getsentry/sentry-python/issues/265
"""
results = []
@celery.task(name="dummy_task")
def dummy_task():
with configure_scope() as scope:
scope.set_tag("foo", "bar")
results.append(42)
for _ in range(10000):
dummy_task.delay()
assert results == [42] * 10000
with configure_scope() as scope:
assert not scope._tags
def test_simple_no_propagation(capture_events, init_celery):
celery = init_celery(propagate_traces=False)
events = capture_events()
@celery.task(name="dummy_task")
def dummy_task():
1 / 0
with start_transaction() as transaction:
dummy_task.delay()
(event,) = events
assert event["contexts"]["trace"]["trace_id"] != transaction.trace_id
assert event["transaction"] == "dummy_task"
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
def test_ignore_expected(capture_events, celery):
events = capture_events()
@celery.task(name="dummy_task", throws=(ZeroDivisionError,))
def dummy_task(x, y):
return x / y
dummy_task.delay(1, 2)
dummy_task.delay(1, 0)
assert not events
def test_broken_prerun(init_celery, connect_signal):
from celery.signals import task_prerun
stack_lengths = []
def crash(*args, **kwargs):
# scope should exist in prerun
stack_lengths.append(len(Hub.current._stack))
1 / 0
# Order here is important to reproduce the bug: In Celery 3, a crashing
# prerun would prevent other preruns from running.
connect_signal(task_prerun, crash)
celery = init_celery()
assert len(Hub.current._stack) == 1
@celery.task(name="dummy_task")
def dummy_task(x, y):
stack_lengths.append(len(Hub.current._stack))
return x / y
if VERSION >= (4,):
dummy_task.delay(2, 2)
else:
with pytest.raises(ZeroDivisionError):
dummy_task.delay(2, 2)
assert len(Hub.current._stack) == 1
if VERSION < (4,):
assert stack_lengths == [2]
else:
assert stack_lengths == [2, 2]
@pytest.mark.xfail(
(4, 2, 0) <= VERSION < (4, 4, 3),
strict=True,
reason="https://github.com/celery/celery/issues/4661",
)
def test_retry(celery, capture_events):
events = capture_events()
failures = [True, True, False]
runs = []
@celery.task(name="dummy_task", bind=True)
def dummy_task(self):
runs.append(1)
try:
if failures.pop(0):
1 / 0
except Exception as exc:
self.retry(max_retries=2, exc=exc)
dummy_task.delay()
assert len(runs) == 3
assert not events
failures = [True, True, True]
runs = []
dummy_task.delay()
assert len(runs) == 3
(event,) = events
exceptions = event["exception"]["values"]
for e in exceptions:
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):
celery = init_celery(traces_sample_rate=1.0, backend="redis", debug=True)
events = capture_events_forksafe()
runs = []
@celery.task(name="dummy_task", bind=True)
def dummy_task(self):
runs.append(1)
1 / 0
with start_transaction(name="submit_celery"):
# Curious: Cannot use delay() here or py2.7-celery-4.2 crashes
res = dummy_task.apply_async()
with pytest.raises(Exception): # noqa: B017
# Celery 4.1 raises a gibberish exception
res.wait()
# if this is nonempty, the worker never really forked
assert not runs
submit_transaction = events.read_event()
assert submit_transaction["type"] == "transaction"
assert submit_transaction["transaction"] == "submit_celery"
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()
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
transaction = events.read_event()
assert (
transaction["contexts"]["trace"]["trace_id"]
== event["contexts"]["trace"]["trace_id"]
== submit_transaction["contexts"]["trace"]["trace_id"]
)
events.read_flush()
# if this is nonempty, the worker never really forked
assert not runs
@pytest.mark.forked
@pytest.mark.parametrize("newrelic_order", ["sentry_first", "sentry_last"])
def test_newrelic_interference(init_celery, newrelic_order, celery_invocation):
def instrument_newrelic():
import celery.app.trace as celery_mod
from newrelic.hooks.application_celery import instrument_celery_execute_trace
assert hasattr(celery_mod, "build_tracer")
instrument_celery_execute_trace(celery_mod)
if newrelic_order == "sentry_first":
celery = init_celery()
instrument_newrelic()
elif newrelic_order == "sentry_last":
instrument_newrelic()
celery = init_celery()
else:
raise ValueError(newrelic_order)
@celery.task(name="dummy_task", bind=True)
def dummy_task(self, x, y):
return x / y
assert dummy_task.apply(kwargs={"x": 1, "y": 1}).wait() == 1
assert celery_invocation(dummy_task, 1, 1)[0].wait() == 1
def test_traces_sampler_gets_task_info_in_sampling_context(
init_celery, celery_invocation, DictionaryContaining # noqa:N803
):
traces_sampler = mock.Mock()
celery = init_celery(traces_sampler=traces_sampler)
@celery.task(name="dog_walk")
def walk_dogs(x, y):
dogs, route = x
num_loops = y
return dogs, route, num_loops
_, args_kwargs = celery_invocation(
walk_dogs, [["Maisey", "Charlie", "Bodhi", "Cory"], "Dog park round trip"], 1
)
traces_sampler.assert_any_call(
# depending on the iteration of celery_invocation, the data might be
# passed as args or as kwargs, so make this generic
DictionaryContaining({"celery_job": dict(task="dog_walk", **args_kwargs)})
)
def test_abstract_task(capture_events, celery, celery_invocation):
events = capture_events()
class AbstractTask(celery.Task):
abstract = True
def __call__(self, *args, **kwargs):
try:
return self.run(*args, **kwargs)
except ZeroDivisionError:
return None
@celery.task(name="dummy_task", base=AbstractTask)
def dummy_task(x, y):
return x / y
with start_transaction():
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", bind=True)
def dummy_task(self, x, y):
return _get_headers(self)
# 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()`
result = dummy_task.apply_async(args=(1, 0), headers=sentry_crons_setup)
assert result.get() == sentry_crons_setup
def test_baggage_propagation(init_celery):
celery = init_celery(traces_sample_rate=1.0, release="abcdef")
@celery.task(name="dummy_task", bind=True)
def dummy_task(self, x, y):
return _get_headers(self)
with start_transaction() as transaction:
result = dummy_task.apply_async(
args=(1, 0),
headers={"baggage": "custom=value"},
).get()
assert sorted(result["baggage"].split(",")) == sorted(
[
"sentry-release=abcdef",
"sentry-trace_id={}".format(transaction.trace_id),
"sentry-environment=production",
"sentry-sample_rate=1.0",
"sentry-sampled=true",
"custom=value",
]
)
def test_sentry_propagate_traces_override(init_celery):
"""
Test if the `sentry-propagate-traces` header given to `apply_async`
overrides the `propagate_traces` parameter in the integration constructor.
"""
celery = init_celery(
propagate_traces=True, traces_sample_rate=1.0, release="abcdef"
)
@celery.task(name="dummy_task", bind=True)
def dummy_task(self, message):
trace_id = get_current_span().trace_id
return trace_id
with start_transaction() as transaction:
transaction_trace_id = transaction.trace_id
# should propagate trace
task_transaction_id = dummy_task.apply_async(
args=("some message",),
).get()
assert transaction_trace_id == task_transaction_id
# should NOT propagate trace (overrides `propagate_traces` parameter in integration constructor)
task_transaction_id = dummy_task.apply_async(
args=("another message",),
headers={"sentry-propagate-traces": False},
).get()
assert transaction_trace_id != task_transaction_id
def test_apply_async_manually_span(sentry_init):
sentry_init(
integrations=[CeleryIntegration()],
)
def dummy_function(*args, **kwargs):
headers = kwargs.get("headers")
assert "sentry-trace" in headers
assert "baggage" in headers
wrapped = _wrap_apply_async(dummy_function)
wrapped(mock.MagicMock(), (), headers={})
def test_apply_async_from_beat_no_span(sentry_init):
sentry_init(
integrations=[CeleryIntegration()],
)
def dummy_function(*args, **kwargs):
headers = kwargs.get("headers")
assert "sentry-trace" not in headers
assert "baggage" not in headers
wrapped = _wrap_apply_async(dummy_function)
wrapped(
mock.MagicMock(),
[
"BEAT",
],
headers={},
)
def test_apply_async_no_args(init_celery):
celery = init_celery()
@celery.task
def example_task():
return "success"
try:
result = example_task.apply_async(None, {})
except TypeError:
pytest.fail("Calling `apply_async` without arguments raised a TypeError")
assert result.get() == "success"
sentry-python-1.39.2/tests/integrations/celery/test_celery_beat_crons.py 0000664 0000000 0000000 00000033176 14547447232 0026725 0 ustar 00root root 0000000 0000000 import datetime
import sys
import pytest
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.timezone = "Europe/Vienna"
# schedule with the default timezone
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "crontab",
"value": "*/10 12 3 * *",
},
"timezone": "UTC", # the default because `crontab` does not know about the app
}
assert "unit" not in monitor_config["schedule"]
# schedule with the timezone from the app
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10", app=app)
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "crontab",
"value": "*/10 12 3 * *",
},
"timezone": "Europe/Vienna", # the timezone from the app
}
# schedule without a timezone, the celery integration will read the config from the app
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
celery_schedule.tz = None
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "crontab",
"value": "*/10 12 3 * *",
},
"timezone": "Europe/Vienna", # the timezone from the app
}
# schedule without a timezone, and an app without timezone, the celery integration will fall back to UTC
app = MagicMock()
app.timezone = None
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
celery_schedule.tz = None
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "crontab",
"value": "*/10 12 3 * *",
},
"timezone": "UTC", # default timezone from celery integration
}
def test_get_monitor_config_seconds():
app = MagicMock()
app.timezone = "Europe/Vienna"
celery_schedule = schedule(run_every=3) # seconds
with mock.patch(
"sentry_sdk.integrations.celery.logger.warning"
) as mock_logger_warning:
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
mock_logger_warning.assert_called_with(
"Intervals shorter than one minute are not supported by Sentry Crons. Monitor '%s' has an interval of %s seconds. Use the `exclude_beat_tasks` option in the celery integration to exclude it.",
"foo",
3,
)
assert monitor_config == {}
def test_get_monitor_config_minutes():
app = MagicMock()
app.timezone = "Europe/Vienna"
# schedule with the default timezone
celery_schedule = schedule(run_every=60) # seconds
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "interval",
"value": 1,
"unit": "minute",
},
"timezone": "UTC",
}
# schedule with the timezone from the app
celery_schedule = schedule(run_every=60, app=app) # seconds
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "interval",
"value": 1,
"unit": "minute",
},
"timezone": "Europe/Vienna", # the timezone from the app
}
# schedule without a timezone, the celery integration will read the config from the app
celery_schedule = schedule(run_every=60) # seconds
celery_schedule.tz = None
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "interval",
"value": 1,
"unit": "minute",
},
"timezone": "Europe/Vienna", # the timezone from the app
}
# schedule without a timezone, and an app without timezone, the celery integration will fall back to UTC
app = MagicMock()
app.timezone = None
celery_schedule = schedule(run_every=60) # seconds
celery_schedule.tz = None
monitor_config = _get_monitor_config(celery_schedule, app, "foo")
assert monitor_config == {
"schedule": {
"type": "interval",
"value": 1,
"unit": "minute",
},
"timezone": "UTC", # default timezone from celery integration
}
def test_get_monitor_config_unknown():
app = MagicMock()
app.timezone = "Europe/Vienna"
unknown_celery_schedule = MagicMock()
monitor_config = _get_monitor_config(unknown_celery_schedule, app, "foo")
assert monitor_config == {}
def test_get_monitor_config_default_timezone():
app = MagicMock()
app.timezone = None
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
monitor_config = _get_monitor_config(celery_schedule, app, "dummy_monitor_name")
assert monitor_config["timezone"] == "UTC"
def test_get_monitor_config_timezone_in_app_conf():
app = MagicMock()
app.timezone = "Asia/Karachi"
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
celery_schedule.tz = None
monitor_config = _get_monitor_config(celery_schedule, app, "dummy_monitor_name")
assert monitor_config["timezone"] == "Asia/Karachi"
@pytest.mark.skipif(
sys.version_info < (3, 0),
reason="no datetime.timezone for Python 2, so skipping this test.",
)
def test_get_monitor_config_timezone_in_celery_schedule():
app = MagicMock()
app.timezone = "Asia/Karachi"
panama_tz = datetime.timezone(datetime.timedelta(hours=-5), name="America/Panama")
celery_schedule = crontab(day_of_month="3", hour="12", minute="*/10")
celery_schedule.tz = panama_tz
monitor_config = _get_monitor_config(celery_schedule, app, "dummy_monitor_name")
assert monitor_config["timezone"] == str(panama_tz)
@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
sentry-python-1.39.2/tests/integrations/chalice/ 0000775 0000000 0000000 00000000000 14547447232 0021725 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/chalice/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024037 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("chalice")
sentry-python-1.39.2/tests/integrations/chalice/test_chalice.py 0000664 0000000 0000000 00000010445 14547447232 0024732 0 ustar 00root root 0000000 0000000 import pytest
import time
from chalice import Chalice, BadRequestError
from chalice.local import LambdaContext, LocalGateway
from sentry_sdk import capture_message
from sentry_sdk.integrations.chalice import CHALICE_VERSION, ChaliceIntegration
from sentry_sdk.utils import parse_version
from pytest_chalice.handlers import RequestHandler
def _generate_lambda_context(self):
# Monkeypatch of the function _generate_lambda_context
# from the class LocalGateway
# for mock the timeout
# type: () -> LambdaContext
if self._config.lambda_timeout is None:
timeout = 10 * 1000
else:
timeout = self._config.lambda_timeout * 1000
return LambdaContext(
function_name=self._config.function_name,
memory_size=self._config.lambda_memory_size,
max_runtime_ms=timeout,
)
@pytest.fixture
def app(sentry_init):
sentry_init(integrations=[ChaliceIntegration()])
app = Chalice(app_name="sentry_chalice")
@app.route("/boom")
def boom():
raise Exception("boom goes the dynamite!")
@app.route("/context")
def has_request():
raise Exception("boom goes the dynamite!")
@app.route("/badrequest")
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
@pytest.fixture
def lambda_context_args():
return ["lambda_name", 256]
def test_exception_boom(app, client: RequestHandler) -> None:
response = client.get("/boom")
assert response.status_code == 500
assert response.json == {
"Code": "InternalServerError",
"Message": "An internal server error occurred.",
}
def test_has_request(app, capture_events, client: RequestHandler):
events = capture_events()
response = client.get("/context")
assert response.status_code == 500
(event,) = events
assert event["level"] == "error"
(exception,) = event["exception"]["values"]
assert exception["type"] == "Exception"
def test_scheduled_event(app, lambda_context_args):
@app.schedule("rate(1 minutes)")
def every_hour(event):
raise Exception("schedule event!")
context = LambdaContext(
*lambda_context_args, max_runtime_ms=10000, time_source=time
)
lambda_event = {
"version": "0",
"account": "120987654312",
"region": "us-west-1",
"detail": {},
"detail-type": "Scheduled Event",
"source": "aws.events",
"time": "1970-01-01T00:00:00Z",
"id": "event-id",
"resources": ["arn:aws:events:us-west-1:120987654312:rule/my-schedule"],
}
with pytest.raises(Exception) as exc_info:
every_hour(lambda_event, context=context)
assert str(exc_info.value) == "schedule event!"
@pytest.mark.skipif(
parse_version(CHALICE_VERSION) >= (1, 28),
reason="different behavior based on chalice version",
)
def test_bad_request_old(client: RequestHandler) -> None:
response = client.get("/badrequest")
assert response.status_code == 400
assert response.json == {
"Code": "BadRequestError",
"Message": "BadRequestError: bad-request",
}
@pytest.mark.skipif(
parse_version(CHALICE_VERSION) < (1, 28),
reason="different behavior based on chalice version",
)
def test_bad_request(client: RequestHandler) -> None:
response = client.get("/badrequest")
assert response.status_code == 400
assert response.json == {
"Code": "BadRequestError",
"Message": "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}
sentry-python-1.39.2/tests/integrations/clickhouse_driver/ 0000775 0000000 0000000 00000000000 14547447232 0024041 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/clickhouse_driver/__init__.py 0000664 0000000 0000000 00000000070 14547447232 0026147 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("clickhouse_driver")
sentry-python-1.39.2/tests/integrations/clickhouse_driver/test_clickhouse_driver.py 0000664 0000000 0000000 00000067015 14547447232 0031167 0 ustar 00root root 0000000 0000000 """
Tests need a local clickhouse instance running, this can best be done using
```sh
docker run -d -p 18123:8123 -p9000:9000 --name clickhouse-test --ulimit nofile=262144:262144 --rm clickhouse/clickhouse-server
```
"""
import clickhouse_driver
from clickhouse_driver import Client, connect
from sentry_sdk import start_transaction, capture_message
from sentry_sdk.integrations.clickhouse_driver import ClickhouseDriverIntegration
EXPECT_PARAMS_IN_SELECT = True
if clickhouse_driver.VERSION < (0, 2, 6):
EXPECT_PARAMS_IN_SELECT = False
def test_clickhouse_client_breadcrumbs(sentry_init, capture_events) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
_experiments={"record_sql_params": True},
)
events = capture_events()
client = Client("localhost")
client.execute("DROP TABLE IF EXISTS test")
client.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
client.execute("INSERT INTO test (x) VALUES", [{"x": 100}])
client.execute("INSERT INTO test (x) VALUES", [[170], [200]])
res = client.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
assert res[0][0] == 370
capture_message("hi")
(event,) = events
expected_breadcrumbs = [
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "DROP TABLE IF EXISTS test",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "CREATE TABLE test (x Int32) ENGINE = Memory",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "SELECT sum(x) FROM test WHERE x > 150",
"type": "default",
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_breadcrumbs[-1]["data"].pop("db.params", None)
for crumb in event["breadcrumbs"]["values"]:
crumb.pop("timestamp", None)
assert event["breadcrumbs"]["values"] == expected_breadcrumbs
def test_clickhouse_client_breadcrumbs_with_pii(sentry_init, capture_events) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
send_default_pii=True,
_experiments={"record_sql_params": True},
)
events = capture_events()
client = Client("localhost")
client.execute("DROP TABLE IF EXISTS test")
client.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
client.execute("INSERT INTO test (x) VALUES", [{"x": 100}])
client.execute("INSERT INTO test (x) VALUES", [[170], [200]])
res = client.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
assert res[0][0] == 370
capture_message("hi")
(event,) = events
expected_breadcrumbs = [
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [],
},
"message": "DROP TABLE IF EXISTS test",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [],
},
"message": "CREATE TABLE test (x Int32) ENGINE = Memory",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [{"x": 100}],
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [[170], [200]],
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [[370]],
"db.params": {"minv": 150},
},
"message": "SELECT sum(x) FROM test WHERE x > 150",
"type": "default",
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_breadcrumbs[-1]["data"].pop("db.params", None)
for crumb in event["breadcrumbs"]["values"]:
crumb.pop("timestamp", None)
assert event["breadcrumbs"]["values"] == expected_breadcrumbs
def test_clickhouse_client_spans(
sentry_init, capture_events, capture_envelopes
) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
_experiments={"record_sql_params": True},
traces_sample_rate=1.0,
)
events = capture_events()
transaction_trace_id = None
transaction_span_id = None
with start_transaction(name="test_clickhouse_transaction") as transaction:
transaction_trace_id = transaction.trace_id
transaction_span_id = transaction.span_id
client = Client("localhost")
client.execute("DROP TABLE IF EXISTS test")
client.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
client.execute("INSERT INTO test (x) VALUES", [{"x": 100}])
client.execute("INSERT INTO test (x) VALUES", [[170], [200]])
res = client.execute(
"SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150}
)
assert res[0][0] == 370
(event,) = events
expected_spans = [
{
"op": "db",
"description": "DROP TABLE IF EXISTS test",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "CREATE TABLE test (x Int32) ENGINE = Memory",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "SELECT sum(x) FROM test WHERE x > 150",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_spans[-1]["data"].pop("db.params", None)
for span in event["spans"]:
span.pop("span_id", None)
span.pop("start_timestamp", None)
span.pop("timestamp", None)
assert event["spans"] == expected_spans
def test_clickhouse_client_spans_with_pii(
sentry_init, capture_events, capture_envelopes
) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
_experiments={"record_sql_params": True},
traces_sample_rate=1.0,
send_default_pii=True,
)
events = capture_events()
transaction_trace_id = None
transaction_span_id = None
with start_transaction(name="test_clickhouse_transaction") as transaction:
transaction_trace_id = transaction.trace_id
transaction_span_id = transaction.span_id
client = Client("localhost")
client.execute("DROP TABLE IF EXISTS test")
client.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
client.execute("INSERT INTO test (x) VALUES", [{"x": 100}])
client.execute("INSERT INTO test (x) VALUES", [[170], [200]])
res = client.execute(
"SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150}
)
assert res[0][0] == 370
(event,) = events
expected_spans = [
{
"op": "db",
"description": "DROP TABLE IF EXISTS test",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "CREATE TABLE test (x Int32) ENGINE = Memory",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [{"x": 100}],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [[170], [200]],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "SELECT sum(x) FROM test WHERE x > 150",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": {"minv": 150},
"db.result": [[370]],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_spans[-1]["data"].pop("db.params", None)
for span in event["spans"]:
span.pop("span_id", None)
span.pop("start_timestamp", None)
span.pop("timestamp", None)
assert event["spans"] == expected_spans
def test_clickhouse_dbapi_breadcrumbs(sentry_init, capture_events) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
)
events = capture_events()
conn = connect("clickhouse://localhost")
cursor = conn.cursor()
cursor.execute("DROP TABLE IF EXISTS test")
cursor.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
cursor.executemany("INSERT INTO test (x) VALUES", [{"x": 100}])
cursor.executemany("INSERT INTO test (x) VALUES", [[170], [200]])
cursor.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
res = cursor.fetchall()
assert res[0][0] == 370
capture_message("hi")
(event,) = events
expected_breadcrumbs = [
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "DROP TABLE IF EXISTS test",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "CREATE TABLE test (x Int32) ENGINE = Memory",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"message": "SELECT sum(x) FROM test WHERE x > 150",
"type": "default",
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_breadcrumbs[-1]["data"].pop("db.params", None)
for crumb in event["breadcrumbs"]["values"]:
crumb.pop("timestamp", None)
assert event["breadcrumbs"]["values"] == expected_breadcrumbs
def test_clickhouse_dbapi_breadcrumbs_with_pii(sentry_init, capture_events) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
send_default_pii=True,
)
events = capture_events()
conn = connect("clickhouse://localhost")
cursor = conn.cursor()
cursor.execute("DROP TABLE IF EXISTS test")
cursor.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
cursor.executemany("INSERT INTO test (x) VALUES", [{"x": 100}])
cursor.executemany("INSERT INTO test (x) VALUES", [[170], [200]])
cursor.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
res = cursor.fetchall()
assert res[0][0] == 370
capture_message("hi")
(event,) = events
expected_breadcrumbs = [
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [[], []],
},
"message": "DROP TABLE IF EXISTS test",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [[], []],
},
"message": "CREATE TABLE test (x Int32) ENGINE = Memory",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [{"x": 100}],
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [[170], [200]],
},
"message": "INSERT INTO test (x) VALUES",
"type": "default",
},
{
"category": "query",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": {"minv": 150},
"db.result": [[["370"]], [["'sum(x)'", "'Int64'"]]],
},
"message": "SELECT sum(x) FROM test WHERE x > 150",
"type": "default",
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_breadcrumbs[-1]["data"].pop("db.params", None)
for crumb in event["breadcrumbs"]["values"]:
crumb.pop("timestamp", None)
assert event["breadcrumbs"]["values"] == expected_breadcrumbs
def test_clickhouse_dbapi_spans(sentry_init, capture_events, capture_envelopes) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
_experiments={"record_sql_params": True},
traces_sample_rate=1.0,
)
events = capture_events()
transaction_trace_id = None
transaction_span_id = None
with start_transaction(name="test_clickhouse_transaction") as transaction:
transaction_trace_id = transaction.trace_id
transaction_span_id = transaction.span_id
conn = connect("clickhouse://localhost")
cursor = conn.cursor()
cursor.execute("DROP TABLE IF EXISTS test")
cursor.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
cursor.executemany("INSERT INTO test (x) VALUES", [{"x": 100}])
cursor.executemany("INSERT INTO test (x) VALUES", [[170], [200]])
cursor.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
res = cursor.fetchall()
assert res[0][0] == 370
(event,) = events
expected_spans = [
{
"op": "db",
"description": "DROP TABLE IF EXISTS test",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "CREATE TABLE test (x Int32) ENGINE = Memory",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "SELECT sum(x) FROM test WHERE x > 150",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_spans[-1]["data"].pop("db.params", None)
for span in event["spans"]:
span.pop("span_id", None)
span.pop("start_timestamp", None)
span.pop("timestamp", None)
assert event["spans"] == expected_spans
def test_clickhouse_dbapi_spans_with_pii(
sentry_init, capture_events, capture_envelopes
) -> None:
sentry_init(
integrations=[ClickhouseDriverIntegration()],
_experiments={"record_sql_params": True},
traces_sample_rate=1.0,
send_default_pii=True,
)
events = capture_events()
transaction_trace_id = None
transaction_span_id = None
with start_transaction(name="test_clickhouse_transaction") as transaction:
transaction_trace_id = transaction.trace_id
transaction_span_id = transaction.span_id
conn = connect("clickhouse://localhost")
cursor = conn.cursor()
cursor.execute("DROP TABLE IF EXISTS test")
cursor.execute("CREATE TABLE test (x Int32) ENGINE = Memory")
cursor.executemany("INSERT INTO test (x) VALUES", [{"x": 100}])
cursor.executemany("INSERT INTO test (x) VALUES", [[170], [200]])
cursor.execute("SELECT sum(x) FROM test WHERE x > %(minv)i", {"minv": 150})
res = cursor.fetchall()
assert res[0][0] == 370
(event,) = events
expected_spans = [
{
"op": "db",
"description": "DROP TABLE IF EXISTS test",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [[], []],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "CREATE TABLE test (x Int32) ENGINE = Memory",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.result": [[], []],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [{"x": 100}],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "INSERT INTO test (x) VALUES",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": [[170], [200]],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
{
"op": "db",
"description": "SELECT sum(x) FROM test WHERE x > 150",
"data": {
"db.system": "clickhouse",
"db.name": "",
"db.user": "default",
"server.address": "localhost",
"server.port": 9000,
"db.params": {"minv": 150},
"db.result": [[[370]], [["sum(x)", "Int64"]]],
},
"same_process_as_parent": True,
"trace_id": transaction_trace_id,
"parent_span_id": transaction_span_id,
},
]
if not EXPECT_PARAMS_IN_SELECT:
expected_spans[-1]["data"].pop("db.params", None)
for span in event["spans"]:
span.pop("span_id", None)
span.pop("start_timestamp", None)
span.pop("timestamp", None)
assert event["spans"] == expected_spans
sentry-python-1.39.2/tests/integrations/cloud_resource_context/ 0000775 0000000 0000000 00000000000 14547447232 0025116 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/cloud_resource_context/__init__.py 0000664 0000000 0000000 00000000000 14547447232 0027215 0 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/cloud_resource_context/test_cloud_resource_context.py 0000664 0000000 0000000 00000031044 14547447232 0033312 0 ustar 00root root 0000000 0000000 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()
sentry-python-1.39.2/tests/integrations/conftest.py 0000664 0000000 0000000 00000001060 14547447232 0022531 0 ustar 00root root 0000000 0000000 import pytest
import sentry_sdk
@pytest.fixture
def capture_exceptions(monkeypatch):
def inner():
errors = set()
old_capture_event = sentry_sdk.Hub.capture_event
def capture_event(self, event, hint=None):
if hint:
if "exc_info" in hint:
error = hint["exc_info"][1]
errors.add(error)
return old_capture_event(self, event, hint=hint)
monkeypatch.setattr(sentry_sdk.Hub, "capture_event", capture_event)
return errors
return inner
sentry-python-1.39.2/tests/integrations/django/ 0000775 0000000 0000000 00000000000 14547447232 0021577 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/django/__init__.py 0000664 0000000 0000000 00000000055 14547447232 0023710 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("django")
sentry-python-1.39.2/tests/integrations/django/asgi/ 0000775 0000000 0000000 00000000000 14547447232 0022522 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/django/asgi/__init__.py 0000664 0000000 0000000 00000000057 14547447232 0024635 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("channels")
sentry-python-1.39.2/tests/integrations/django/asgi/image.png 0000664 0000000 0000000 00000000464 14547447232 0024316 0 ustar 00root root 0000000 0000000 PNG
IHDR
IDATWc HsWT ,pƃ ϟ+e+FQ0}^-//CfR3
V W hgVd2ܺ lzjVB!H#SM/;'15e0H6$[7 2iȃM32bXd;PS1KJ04`H 2fÌ 5b.rfO_` 4;PלfŘ
M
fh@ 4 x8L IENDB` sentry-python-1.39.2/tests/integrations/django/asgi/test_asgi.py 0000664 0000000 0000000 00000037267 14547447232 0025075 0 ustar 00root root 0000000 0000000 import base64
import json
import os
import django
import pytest
from channels.testing import HttpCommunicator
from sentry_sdk import capture_message
from sentry_sdk.integrations.django import DjangoIntegration
from tests.integrations.django.myapp.asgi import channels_application
try:
from django.urls import reverse
except ImportError:
from django.core.urlresolvers import reverse
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
APPS += [asgi_application]
@pytest.mark.parametrize("application", APPS)
@pytest.mark.asyncio
@pytest.mark.forked
async def test_basic(sentry_init, capture_events, application):
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
events = capture_events()
comm = HttpCommunicator(application, "GET", "/view-exc?test=query")
response = await comm.get_response()
assert response["status"] == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
# Test that the ASGI middleware got set up correctly. Right now this needs
# to be installed manually (see myapp/asgi.py)
assert event["transaction"] == "/view-exc"
assert event["request"] == {
"cookies": {},
"headers": {},
"method": "GET",
"query_string": "test=query",
"url": "/view-exc",
}
capture_message("hi")
event = events[-1]
assert "request" not in event
@pytest.mark.parametrize("application", APPS)
@pytest.mark.asyncio
@pytest.mark.forked
@pytest.mark.skipif(
django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
)
async def test_async_views(sentry_init, capture_events, application):
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
events = capture_events()
comm = HttpCommunicator(application, "GET", "/async_message")
response = await comm.get_response()
assert response["status"] == 200
(event,) = events
assert event["transaction"] == "/async_message"
assert event["request"] == {
"cookies": {},
"headers": {},
"method": "GET",
"query_string": None,
"url": "/async_message",
}
@pytest.mark.parametrize("application", APPS)
@pytest.mark.parametrize("endpoint", ["/sync/thread_ids", "/async/thread_ids"])
@pytest.mark.asyncio
@pytest.mark.forked
@pytest.mark.skipif(
django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
)
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.forked
@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
settings.MIDDLEWARE = []
asgi_application.load_middleware(is_async=True)
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
comm = HttpCommunicator(asgi_application, "GET", "/my_async_view")
comm2 = HttpCommunicator(asgi_application, "GET", "/my_async_view")
loop = asyncio.get_event_loop()
start = time.time()
r1 = loop.create_task(comm.get_response(timeout=5))
r2 = loop.create_task(comm2.get_response(timeout=5))
(resp1, resp2), _ = await asyncio.wait({r1, r2})
end = time.time()
assert resp1.result()["status"] == 200
assert resp2.result()["status"] == 200
assert end - start < 1.5
@pytest.mark.asyncio
@pytest.mark.forked
@pytest.mark.skipif(
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, settings
):
import asyncio
import time
settings.MIDDLEWARE = [
"tests.integrations.django.myapp.middleware.simple_middleware"
]
asgi_application.load_middleware(is_async=True)
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
comm = HttpCommunicator(asgi_application, "GET", "/my_async_view")
comm2 = HttpCommunicator(asgi_application, "GET", "/my_async_view")
loop = asyncio.get_event_loop()
start = time.time()
r1 = loop.create_task(comm.get_response(timeout=5))
r2 = loop.create_task(comm2.get_response(timeout=5))
(resp1, resp2), _ = await asyncio.wait({r1, r2})
end = time.time()
assert resp1.result()["status"] == 200
assert resp2.result()["status"] == 200
assert end - start < 1.5
@pytest.mark.asyncio
@pytest.mark.forked
@pytest.mark.skipif(
django.VERSION < (3, 1), reason="async views have been introduced in Django 3.1"
)
async def test_async_middleware_spans(
sentry_init, render_span_tree, capture_events, settings
):
settings.MIDDLEWARE = [
"django.contrib.sessions.middleware.SessionMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"tests.integrations.django.myapp.settings.TestMiddleware",
]
asgi_application.load_middleware(is_async=True)
sentry_init(
integrations=[DjangoIntegration(middleware_spans=True)],
traces_sample_rate=1.0,
_experiments={"record_sql_params": True},
)
events = capture_events()
comm = HttpCommunicator(asgi_application, "GET", "/async_message")
response = await comm.get_response()
assert response["status"] == 200
await comm.wait()
message, transaction = events
assert (
render_span_tree(transaction)
== """\
- op="http.server": description=null
- 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.forked
@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.forked
@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.forked
@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.forked
@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
PICTURE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "image.png")
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="image.png"\r\nContent-Type: image/png\r\nContent-Transfer-Encoding: base64\r\n\r\n{{image_data}}\r\n--fd721ef49ea403a6--\r\n""".replace(
"{{image_data}}", base64.b64encode(open(PICTURE, "rb").read()).decode("utf-8")
).encode(
"utf-8"
)
BODY_FORM_CONTENT_LENGTH = str(len(BODY_FORM)).encode("utf-8")
@pytest.mark.parametrize("application", APPS)
@pytest.mark.parametrize(
"send_default_pii,method,headers,url_name,body,expected_data",
[
(
True,
"POST",
[(b"content-type", b"text/plain")],
"post_echo_async",
b"",
None,
),
(
True,
"POST",
[(b"content-type", b"text/plain")],
"post_echo_async",
b"some raw text body",
"",
),
(
True,
"POST",
[(b"content-type", b"application/json")],
"post_echo_async",
b'{"username":"xyz","password":"xyz"}',
{"username": "xyz", "password": "xyz"},
),
(
True,
"POST",
[(b"content-type", b"application/xml")],
"post_echo_async",
b'\n',
rendered_meta,
)
assert match is not None
assert match.group(1) == traceparent
# Python 2 does not preserve sort order
rendered_baggage = match.group(2)
assert sorted(rendered_baggage.split(",")) == sorted(baggage.split(","))
@pytest.mark.parametrize("with_executing_integration", [[], [ExecutingIntegration()]])
def test_template_exception(
sentry_init, client, capture_events, with_executing_integration
):
sentry_init(integrations=[DjangoIntegration()] + with_executing_integration)
events = capture_events()
content, status, headers = unpack_werkzeug_response(
client.get(reverse("template_exc"))
)
assert status.lower() == "500 internal server error"
(event,) = events
exception = event["exception"]["values"][-1]
assert exception["type"] == "TemplateSyntaxError"
frames = [
f
for f in exception["stacktrace"]["frames"]
if not f["filename"].startswith("django/")
]
view_frame, template_frame = frames[-2:]
assert template_frame["context_line"] == "{% invalid template tag %}\n"
assert template_frame["pre_context"] == ["5\n", "6\n", "7\n", "8\n", "9\n"]
assert template_frame["post_context"] == ["11\n", "12\n", "13\n", "14\n", "15\n"]
assert template_frame["lineno"] == 10
assert template_frame["filename"].endswith("error.html")
filenames = [
(f.get("function"), f.get("module")) for f in exception["stacktrace"]["frames"]
]
if with_executing_integration:
assert filenames[-3:] == [
("Parser.parse", "django.template.base"),
(None, None),
("Parser.invalid_block_tag", "django.template.base"),
]
else:
assert filenames[-3:] == [
("parse", "django.template.base"),
(None, None),
("invalid_block_tag", "django.template.base"),
]
@pytest.mark.parametrize(
"route", ["rest_framework_exc", "rest_framework_read_body_and_exc"]
)
@pytest.mark.parametrize(
"ct,body",
[
["application/json", {"foo": "bar"}],
["application/json", 1],
["application/json", "foo"],
["application/x-www-form-urlencoded", {"foo": "bar"}],
],
)
def test_rest_framework_basic(
sentry_init, client, capture_events, capture_exceptions, ct, body, route
):
pytest.importorskip("rest_framework")
sentry_init(integrations=[DjangoIntegration()], send_default_pii=True)
exceptions = capture_exceptions()
events = capture_events()
if ct == "application/json":
client.post(
reverse(route), data=json.dumps(body), content_type="application/json"
)
elif ct == "application/x-www-form-urlencoded":
client.post(reverse(route), data=body)
else:
raise AssertionError("unreachable")
(error,) = exceptions
assert isinstance(error, ZeroDivisionError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "django"
assert event["request"]["data"] == body
assert event["request"]["headers"]["Content-Type"] == ct
@pytest.mark.parametrize(
"endpoint", ["rest_permission_denied_exc", "permission_denied_exc"]
)
def test_does_not_capture_403(sentry_init, client, capture_events, endpoint):
if endpoint == "rest_permission_denied_exc":
pytest.importorskip("rest_framework")
sentry_init(integrations=[DjangoIntegration()])
events = capture_events()
_, status, _ = unpack_werkzeug_response(client.get(reverse(endpoint)))
assert status.lower() == "403 forbidden"
assert not events
def test_render_spans(sentry_init, client, capture_events, render_span_tree):
sentry_init(
integrations=[DjangoIntegration()],
traces_sample_rate=1.0,
)
views_tests = [
(
reverse("template_test2"),
'- op="template.render": description="[user_name.html, ...]"',
),
]
if DJANGO_VERSION >= (1, 7):
views_tests.append(
(
reverse("template_test"),
'- op="template.render": description="user_name.html"',
),
)
for url, expected_line in views_tests:
events = capture_events()
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(signals_spans=False),
],
traces_sample_rate=1.0,
)
events = capture_events()
client.get(reverse("message"))
message, transaction = events
assert message["message"] == "hi"
assert render_span_tree(transaction) == EXPECTED_MIDDLEWARE_SPANS
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"])
EXPECTED_SIGNALS_SPANS = """\
- op="http.server": description=null
- op="event.django": description="django.db.reset_queries"
- op="event.django": description="django.db.close_old_connections"\
"""
def test_signals_spans(sentry_init, client, capture_events, render_span_tree):
sentry_init(
integrations=[
DjangoIntegration(middleware_spans=False),
],
traces_sample_rate=1.0,
)
events = capture_events()
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"]
def test_csrf(sentry_init, client):
"""
Assert that CSRF view decorator works even with the view wrapped in our own
callable.
"""
sentry_init(integrations=[DjangoIntegration()])
content, status, _headers = unpack_werkzeug_response(
client.post(reverse("csrf_hello_not_exempt"))
)
assert status.lower() == "403 forbidden"
content, status, _headers = unpack_werkzeug_response(
client.post(reverse("sentryclass_csrf"))
)
assert status.lower() == "403 forbidden"
content, status, _headers = unpack_werkzeug_response(
client.post(reverse("sentryclass"))
)
assert status.lower() == "200 ok"
assert content == b"ok"
content, status, _headers = unpack_werkzeug_response(
client.post(reverse("classbased"))
)
assert status.lower() == "200 ok"
assert content == b"ok"
content, status, _headers = unpack_werkzeug_response(
client.post(reverse("message"))
)
assert status.lower() == "200 ok"
assert content == b"ok"
@pytest.mark.skipif(DJANGO_VERSION < (2, 0), reason="Requires Django > 2.0")
def test_custom_urlconf_middleware(
settings, sentry_init, client, capture_events, render_span_tree
):
"""
Some middlewares (for instance in django-tenants) overwrite request.urlconf.
Test that the resolver picks up the correct urlconf for transaction naming.
"""
urlconf = "tests.integrations.django.myapp.middleware.custom_urlconf_middleware"
settings.ROOT_URLCONF = ""
settings.MIDDLEWARE.insert(0, urlconf)
client.application.load_middleware()
sentry_init(integrations=[DjangoIntegration()], traces_sample_rate=1.0)
events = capture_events()
content, status, _headers = unpack_werkzeug_response(client.get("/custom/ok"))
assert status.lower() == "200 ok"
assert content == b"custom ok"
event = events.pop(0)
assert event["transaction"] == "/custom/ok"
assert "custom_urlconf_middleware" in render_span_tree(event)
_content, status, _headers = unpack_werkzeug_response(client.get("/custom/exc"))
assert status.lower() == "500 internal server error"
error_event, transaction_event = events
assert error_event["transaction"] == "/custom/exc"
assert error_event["exception"]["values"][-1]["mechanism"]["type"] == "django"
assert transaction_event["transaction"] == "/custom/exc"
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
):
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
):
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
sentry-python-1.39.2/tests/integrations/django/test_data_scrubbing.py 0000664 0000000 0000000 00000004610 14547447232 0026160 0 ustar 00root root 0000000 0000000 import pytest
from werkzeug.test import Client
from sentry_sdk.integrations.django import DjangoIntegration
from tests.conftest import werkzeug_set_cookie
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()
werkzeug_set_cookie(client, "localhost", "sessionid", "123")
werkzeug_set_cookie(client, "localhost", "csrftoken", "456")
werkzeug_set_cookie(client, "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()
werkzeug_set_cookie(client, "localhost", "sessionid", "123")
werkzeug_set_cookie(client, "localhost", "csrftoken", "456")
werkzeug_set_cookie(client, "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()
werkzeug_set_cookie(client, "localhost", "my_sess", "123")
werkzeug_set_cookie(client, "localhost", "csrf_secret", "456")
werkzeug_set_cookie(client, "localhost", "foo", "bar")
client.get(reverse("view_exc"))
(event,) = events
assert event["request"]["cookies"] == {
"my_sess": "[Filtered]",
"csrf_secret": "[Filtered]",
"foo": "bar",
}
sentry-python-1.39.2/tests/integrations/django/test_db_query_data.py 0000664 0000000 0000000 00000017045 14547447232 0026022 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import os
import pytest
from django import VERSION as DJANGO_VERSION
from django.db import connections
try:
from django.urls import reverse
except ImportError:
from django.core.urlresolvers import reverse
from werkzeug.test import Client
from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.django import DjangoIntegration
from tests.conftest import unpack_werkzeug_response
from tests.integrations.django.utils import pytest_mark_django_db_decorator
from tests.integrations.django.myapp.wsgi import application
@pytest.fixture
def client():
return Client(application)
@pytest.mark.forked
@pytest_mark_django_db_decorator(transaction=True)
@pytest.mark.parametrize("enable_db_query_source", [None, False])
def test_query_source_disabled(
sentry_init, client, capture_events, enable_db_query_source
):
sentry_options = {
"integrations": [DjangoIntegration()],
"send_default_pii": True,
"traces_sample_rate": 1.0,
}
if enable_db_query_source is not None:
sentry_options["enable_db_query_source"] = enable_db_query_source
sentry_options["db_query_source_threshold_ms"] = 0
sentry_init(**sentry_options)
if "postgres" not in connections:
pytest.skip("postgres tests disabled")
# trigger Django to open a new connection by marking the existing one as None.
connections["postgres"].connection = None
events = capture_events()
_, status, _ = unpack_werkzeug_response(client.get(reverse("postgres_select_orm")))
assert status == "200 OK"
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and "auth_user" in span.get("description"):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO not in data
assert SPANDATA.CODE_NAMESPACE not in data
assert SPANDATA.CODE_FILEPATH not in data
assert SPANDATA.CODE_FUNCTION not in data
break
else:
raise AssertionError("No db span found")
@pytest.mark.forked
@pytest_mark_django_db_decorator(transaction=True)
def test_query_source(sentry_init, client, capture_events):
sentry_init(
integrations=[DjangoIntegration()],
send_default_pii=True,
traces_sample_rate=1.0,
enable_db_query_source=True,
db_query_source_threshold_ms=0,
)
if "postgres" not in connections:
pytest.skip("postgres tests disabled")
# trigger Django to open a new connection by marking the existing one as None.
connections["postgres"].connection = None
events = capture_events()
_, status, _ = unpack_werkzeug_response(client.get(reverse("postgres_select_orm")))
assert status == "200 OK"
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and "auth_user" in span.get("description"):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO in data
assert SPANDATA.CODE_NAMESPACE in data
assert SPANDATA.CODE_FILEPATH in data
assert SPANDATA.CODE_FUNCTION in data
assert type(data.get(SPANDATA.CODE_LINENO)) == int
assert data.get(SPANDATA.CODE_LINENO) > 0
assert (
data.get(SPANDATA.CODE_NAMESPACE)
== "tests.integrations.django.myapp.views"
)
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"tests/integrations/django/myapp/views.py"
)
is_relative_path = data.get(SPANDATA.CODE_FILEPATH)[0] != os.sep
assert is_relative_path
assert data.get(SPANDATA.CODE_FUNCTION) == "postgres_select_orm"
break
else:
raise AssertionError("No db span found")
@pytest.mark.forked
@pytest_mark_django_db_decorator(transaction=True)
def test_query_source_with_in_app_exclude(sentry_init, client, capture_events):
sentry_init(
integrations=[DjangoIntegration()],
send_default_pii=True,
traces_sample_rate=1.0,
enable_db_query_source=True,
db_query_source_threshold_ms=0,
in_app_exclude=["tests.integrations.django.myapp.views"],
)
if "postgres" not in connections:
pytest.skip("postgres tests disabled")
# trigger Django to open a new connection by marking the existing one as None.
connections["postgres"].connection = None
events = capture_events()
_, status, _ = unpack_werkzeug_response(client.get(reverse("postgres_select_orm")))
assert status == "200 OK"
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and "auth_user" in span.get("description"):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO in data
assert SPANDATA.CODE_NAMESPACE in data
assert SPANDATA.CODE_FILEPATH in data
assert SPANDATA.CODE_FUNCTION in data
assert type(data.get(SPANDATA.CODE_LINENO)) == int
assert data.get(SPANDATA.CODE_LINENO) > 0
if DJANGO_VERSION >= (1, 11):
assert (
data.get(SPANDATA.CODE_NAMESPACE)
== "tests.integrations.django.myapp.settings"
)
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"tests/integrations/django/myapp/settings.py"
)
assert data.get(SPANDATA.CODE_FUNCTION) == "middleware"
else:
assert (
data.get(SPANDATA.CODE_NAMESPACE)
== "tests.integrations.django.test_db_query_data"
)
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"tests/integrations/django/test_db_query_data.py"
)
assert (
data.get(SPANDATA.CODE_FUNCTION)
== "test_query_source_with_in_app_exclude"
)
break
else:
raise AssertionError("No db span found")
@pytest.mark.forked
@pytest_mark_django_db_decorator(transaction=True)
def test_query_source_with_in_app_include(sentry_init, client, capture_events):
sentry_init(
integrations=[DjangoIntegration()],
send_default_pii=True,
traces_sample_rate=1.0,
enable_db_query_source=True,
db_query_source_threshold_ms=0,
in_app_include=["django"],
)
if "postgres" not in connections:
pytest.skip("postgres tests disabled")
# trigger Django to open a new connection by marking the existing one as None.
connections["postgres"].connection = None
events = capture_events()
_, status, _ = unpack_werkzeug_response(client.get(reverse("postgres_select_orm")))
assert status == "200 OK"
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and "auth_user" in span.get("description"):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO in data
assert SPANDATA.CODE_NAMESPACE in data
assert SPANDATA.CODE_FILEPATH in data
assert SPANDATA.CODE_FUNCTION in data
assert type(data.get(SPANDATA.CODE_LINENO)) == int
assert data.get(SPANDATA.CODE_LINENO) > 0
assert data.get(SPANDATA.CODE_NAMESPACE) == "django.db.models.sql.compiler"
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"django/db/models/sql/compiler.py"
)
assert data.get(SPANDATA.CODE_FUNCTION) == "execute_sql"
break
else:
raise AssertionError("No db span found")
sentry-python-1.39.2/tests/integrations/django/test_transactions.py 0000664 0000000 0000000 00000007755 14547447232 0025736 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import pytest
import django
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
# django<2.0 has only `url` with regex based patterns.
# django>=2.0 renames `url` to `re_path`, and additionally introduces `path`
# for new style URL patterns, e.g. .
if django.VERSION >= (2, 0):
from django.urls import path, re_path
from django.urls.converters import PathConverter
from django.conf.urls import include
else:
from django.conf.urls import url as re_path, include
if django.VERSION < (1, 9):
included_url_conf = (re_path(r"^foo/bar/(?P[\w]+)", lambda x: ""),), "", ""
else:
included_url_conf = ((re_path(r"^foo/bar/(?P[\w]+)", lambda x: ""),), "")
from sentry_sdk.integrations.django.transactions import RavenResolver
example_url_conf = (
re_path(r"^api/(?P[\w_-]+)/store/$", lambda x: ""),
re_path(r"^api/(?P(v1|v2))/author/$", lambda x: ""),
re_path(
r"^api/(?P[^\/]+)/product/(?P(?:\d+|[A-Fa-f0-9-]{32,36}))/$",
lambda x: "",
),
re_path(r"^report/", lambda x: ""),
re_path(r"^example/", include(included_url_conf)),
)
def test_resolver_no_match():
resolver = RavenResolver()
result = resolver.resolve("/foo/bar", example_url_conf)
assert result is None
def test_resolver_re_path_complex_match():
resolver = RavenResolver()
result = resolver.resolve("/api/1234/store/", example_url_conf)
assert result == "/api/{project_id}/store/"
def test_resolver_re_path_complex_either_match():
resolver = RavenResolver()
result = resolver.resolve("/api/v1/author/", example_url_conf)
assert result == "/api/{version}/author/"
result = resolver.resolve("/api/v2/author/", example_url_conf)
assert result == "/api/{version}/author/"
def test_resolver_re_path_included_match():
resolver = RavenResolver()
result = resolver.resolve("/example/foo/bar/baz", example_url_conf)
assert result == "/example/foo/bar/{param}"
def test_resolver_re_path_multiple_groups():
resolver = RavenResolver()
result = resolver.resolve(
"/api/myproject/product/cb4ef1caf3554c34ae134f3c1b3d605f/", example_url_conf
)
assert result == "/api/{project_id}/product/{pid}/"
@pytest.mark.skipif(
django.VERSION < (2, 0),
reason="Django>=2.0 required for patterns",
)
def test_resolver_path_group():
url_conf = (path("api/v2//store/", lambda x: ""),)
resolver = RavenResolver()
result = resolver.resolve("/api/v2/1234/store/", url_conf)
assert result == "/api/v2/{project_id}/store/"
@pytest.mark.skipif(
django.VERSION < (2, 0),
reason="Django>=2.0 required for patterns",
)
def test_resolver_path_multiple_groups():
url_conf = (path("api/v2//product/", lambda x: ""),)
resolver = RavenResolver()
result = resolver.resolve("/api/v2/myproject/product/5689", url_conf)
assert result == "/api/v2/{project_id}/product/{pid}"
@pytest.mark.skipif(
django.VERSION < (2, 0),
reason="Django>=2.0 required for patterns",
)
def test_resolver_path_complex_path():
class CustomPathConverter(PathConverter):
regex = r"[^/]+(/[^/]+){0,2}"
with mock.patch(
"django.urls.resolvers.get_converter", return_value=CustomPathConverter
):
url_conf = (path("api/v3/", lambda x: ""),)
resolver = RavenResolver()
result = resolver.resolve("/api/v3/abc/def/ghi", url_conf)
assert result == "/api/v3/{my_path}"
@pytest.mark.skipif(
django.VERSION < (2, 0),
reason="Django>=2.0 required for patterns",
)
def test_resolver_path_no_converter():
url_conf = (path("api/v4/", lambda x: ""),)
resolver = RavenResolver()
result = resolver.resolve("/api/v4/myproject", url_conf)
assert result == "/api/v4/{project_id}"
sentry-python-1.39.2/tests/integrations/django/utils.py 0000664 0000000 0000000 00000001331 14547447232 0023307 0 ustar 00root root 0000000 0000000 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
sentry-python-1.39.2/tests/integrations/excepthook/ 0000775 0000000 0000000 00000000000 14547447232 0022506 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/excepthook/test_excepthook.py 0000664 0000000 0000000 00000003305 14547447232 0026271 0 ustar 00root root 0000000 0000000 import pytest
import sys
import subprocess
from textwrap import dedent
def test_excepthook(tmpdir):
app = tmpdir.join("app.py")
app.write(
dedent(
"""
from sentry_sdk import init, transport
def send_event(self, event):
print("capture event was called")
print(event)
transport.HttpTransport._send_event = send_event
init("http://foobar@localhost/123")
frame_value = "LOL"
1/0
"""
)
)
with pytest.raises(subprocess.CalledProcessError) as excinfo:
subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
output = excinfo.value.output
print(output)
assert b"ZeroDivisionError" in output
assert b"LOL" in output
assert b"capture event was called" in output
def test_always_value_excepthook(tmpdir):
app = tmpdir.join("app.py")
app.write(
dedent(
"""
import sys
from sentry_sdk import init, transport
from sentry_sdk.integrations.excepthook import ExcepthookIntegration
def send_event(self, event):
print("capture event was called")
print(event)
transport.HttpTransport._send_event = send_event
sys.ps1 = "always_value_test"
init("http://foobar@localhost/123",
integrations=[ExcepthookIntegration(always_run=True)]
)
frame_value = "LOL"
1/0
"""
)
)
with pytest.raises(subprocess.CalledProcessError) as excinfo:
subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
output = excinfo.value.output
print(output)
assert b"ZeroDivisionError" in output
assert b"LOL" in output
assert b"capture event was called" in output
sentry-python-1.39.2/tests/integrations/falcon/ 0000775 0000000 0000000 00000000000 14547447232 0021577 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/falcon/__init__.py 0000664 0000000 0000000 00000000055 14547447232 0023710 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("falcon")
sentry-python-1.39.2/tests/integrations/falcon/test_falcon.py 0000664 0000000 0000000 00000030223 14547447232 0024452 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import logging
import pytest
import falcon
import falcon.testing
import sentry_sdk
from sentry_sdk.integrations.falcon import FalconIntegration
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.utils import parse_version
try:
import falcon.asgi
except ImportError:
pass
else:
import falcon.inspect # We only need this module for the ASGI test
FALCON_VERSION = parse_version(falcon.__version__)
@pytest.fixture
def make_app(sentry_init):
def inner():
class MessageResource:
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"
class CustomError(Exception):
pass
class CustomErrorResource:
def on_get(self, req, resp):
raise CustomError()
def custom_error_handler(*args, **kwargs):
raise falcon.HTTPError(status=falcon.HTTP_400)
app = falcon.API()
app.add_route("/message", MessageResource())
app.add_route("/message/{message_id:int}", MessageByIdResource())
app.add_route("/custom-error", CustomErrorResource())
app.add_error_handler(CustomError, custom_error_handler)
return app
return inner
@pytest.fixture
def make_client(make_app):
def inner():
app = make_app()
return falcon.testing.TestClient(app)
return inner
def test_has_context(sentry_init, capture_events, make_client):
sentry_init(integrations=[FalconIntegration()])
events = capture_events()
client = make_client()
response = client.simulate_get("/message")
assert response.status == falcon.HTTP_200
(event,) = events
assert event["transaction"] == "/message" # Falcon URI template
assert "data" not in event["request"]
assert event["request"]["url"] == "http://falconframework.org/message"
@pytest.mark.parametrize(
"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,
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(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):
sentry_init(integrations=[FalconIntegration()], debug=True)
class Resource:
def on_get(self, req, resp):
1 / 0
app = falcon.API()
app.add_route("/", Resource())
exceptions = capture_exceptions()
events = capture_events()
client = falcon.testing.TestClient(app)
try:
client.simulate_get("/")
except ZeroDivisionError:
pass
(exc,) = exceptions
assert isinstance(exc, ZeroDivisionError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "falcon"
assert " by zero" in event["exception"]["values"][0]["value"]
def test_raised_5xx_errors(sentry_init, capture_exceptions, capture_events):
sentry_init(integrations=[FalconIntegration()], debug=True)
class Resource:
def on_get(self, req, resp):
raise falcon.HTTPError(falcon.HTTP_502)
app = falcon.API()
app.add_route("/", Resource())
exceptions = capture_exceptions()
events = capture_events()
client = falcon.testing.TestClient(app)
client.simulate_get("/")
(exc,) = exceptions
assert isinstance(exc, falcon.HTTPError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "falcon"
assert event["exception"]["values"][0]["type"] == "HTTPError"
def test_raised_4xx_errors(sentry_init, capture_exceptions, capture_events):
sentry_init(integrations=[FalconIntegration()], debug=True)
class Resource:
def on_get(self, req, resp):
raise falcon.HTTPError(falcon.HTTP_400)
app = falcon.API()
app.add_route("/", Resource())
exceptions = capture_exceptions()
events = capture_events()
client = falcon.testing.TestClient(app)
client.simulate_get("/")
assert len(exceptions) == 0
assert len(events) == 0
def test_http_status(sentry_init, capture_exceptions, capture_events):
"""
This just demonstrates, that if Falcon raises a HTTPStatus with code 500
(instead of a HTTPError with code 500) Sentry will not capture it.
"""
sentry_init(integrations=[FalconIntegration()], debug=True)
class Resource:
def on_get(self, req, resp):
raise falcon.http_status.HTTPStatus(falcon.HTTP_508)
app = falcon.API()
app.add_route("/", Resource())
exceptions = capture_exceptions()
events = capture_events()
client = falcon.testing.TestClient(app)
client.simulate_get("/")
assert len(exceptions) == 0
assert len(events) == 0
def test_falcon_large_json_request(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
data = {"foo": {"bar": "a" * 2000}}
class Resource:
def on_post(self, req, resp):
assert req.media == data
sentry_sdk.capture_message("hi")
resp.media = "ok"
app = falcon.API()
app.add_route("/", Resource())
events = capture_events()
client = falcon.testing.TestClient(app)
response = client.simulate_post("/", json=data)
assert response.status == falcon.HTTP_200
(event,) = events
assert event["_meta"]["request"]["data"]["foo"]["bar"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
def test_falcon_empty_json_request(sentry_init, capture_events, data):
sentry_init(integrations=[FalconIntegration()])
class Resource:
def on_post(self, req, resp):
assert req.media == data
sentry_sdk.capture_message("hi")
resp.media = "ok"
app = falcon.API()
app.add_route("/", Resource())
events = capture_events()
client = falcon.testing.TestClient(app)
response = client.simulate_post("/", json=data)
assert response.status == falcon.HTTP_200
(event,) = events
assert event["request"]["data"] == data
def test_falcon_raw_data_request(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
class Resource:
def on_post(self, req, resp):
sentry_sdk.capture_message("hi")
resp.media = "ok"
app = falcon.API()
app.add_route("/", Resource())
events = capture_events()
client = falcon.testing.TestClient(app)
response = client.simulate_post("/", body="hi")
assert response.status == falcon.HTTP_200
(event,) = events
assert event["request"]["headers"]["Content-Length"] == "2"
assert event["request"]["data"] == ""
def test_logging(sentry_init, capture_events):
sentry_init(
integrations=[FalconIntegration(), LoggingIntegration(event_level="ERROR")]
)
logger = logging.getLogger()
app = falcon.API()
class Resource:
def on_get(self, req, resp):
logger.error("hi")
resp.media = "ok"
app.add_route("/", Resource())
events = capture_events()
client = falcon.testing.TestClient(app)
client.simulate_get("/")
(event,) = events
assert event["level"] == "error"
def test_500(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
app = falcon.API()
class Resource:
def on_get(self, req, resp):
1 / 0
app.add_route("/", Resource())
def http500_handler(ex, req, resp, params):
sentry_sdk.capture_exception(ex)
resp.media = {"message": "Sentry error: %s" % sentry_sdk.last_event_id()}
app.add_error_handler(Exception, http500_handler)
events = capture_events()
client = falcon.testing.TestClient(app)
response = client.simulate_get("/")
(event,) = events
assert response.json == {"message": "Sentry error: %s" % event["event_id"]}
def test_error_in_errorhandler(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
app = falcon.API()
class Resource:
def on_get(self, req, resp):
raise ValueError()
app.add_route("/", Resource())
def http500_handler(ex, req, resp, params):
1 / 0
app.add_error_handler(Exception, http500_handler)
events = capture_events()
client = falcon.testing.TestClient(app)
with pytest.raises(ZeroDivisionError):
client.simulate_get("/")
(event,) = events
last_ex_values = event["exception"]["values"][-1]
assert last_ex_values["type"] == "ZeroDivisionError"
assert last_ex_values["stacktrace"]["frames"][-1]["vars"]["ex"] == "ValueError()"
def test_bad_request_not_captured(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
events = capture_events()
app = falcon.API()
class Resource:
def on_get(self, req, resp):
raise falcon.HTTPBadRequest()
app.add_route("/", Resource())
client = falcon.testing.TestClient(app)
client.simulate_get("/")
assert not events
def test_does_not_leak_scope(sentry_init, capture_events):
sentry_init(integrations=[FalconIntegration()])
events = capture_events()
with sentry_sdk.configure_scope() as scope:
scope.set_tag("request_data", False)
app = falcon.API()
class Resource:
def on_get(self, req, resp):
with sentry_sdk.configure_scope() as scope:
scope.set_tag("request_data", True)
def generator():
for row in range(1000):
with sentry_sdk.configure_scope() as scope:
assert scope._tags["request_data"]
yield (str(row) + "\n").encode()
resp.stream = generator()
app.add_route("/", Resource())
client = falcon.testing.TestClient(app)
response = client.simulate_get("/")
expected_response = "".join(str(row) + "\n" for row in range(1000))
assert response.text == expected_response
assert not events
with sentry_sdk.configure_scope() as scope:
assert not scope._tags["request_data"]
@pytest.mark.skipif(
not hasattr(falcon, "asgi"), reason="This Falcon version lacks ASGI support."
)
def test_falcon_not_breaking_asgi(sentry_init):
"""
This test simply verifies that the Falcon integration does not break ASGI
Falcon apps.
The test does not verify ASGI Falcon support, since our Falcon integration
currently lacks support for ASGI Falcon apps.
"""
sentry_init(integrations=[FalconIntegration()])
asgi_app = falcon.asgi.App()
try:
falcon.inspect.inspect_app(asgi_app)
except TypeError:
pytest.fail("Falcon integration causing errors in ASGI apps.")
@pytest.mark.skipif(
(FALCON_VERSION or ()) < (3,),
reason="The Sentry Falcon integration only supports custom error handlers on Falcon 3+",
)
def test_falcon_custom_error_handler(sentry_init, make_app, capture_events):
"""
When a custom error handler handles what otherwise would have resulted in a 5xx error,
changing the HTTP status to a non-5xx status, no error event should be sent to Sentry.
"""
sentry_init(integrations=[FalconIntegration()])
events = capture_events()
app = make_app()
client = falcon.testing.TestClient(app)
client.simulate_get("/custom-error")
assert len(events) == 0
sentry-python-1.39.2/tests/integrations/fastapi/ 0000775 0000000 0000000 00000000000 14547447232 0021764 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/fastapi/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024076 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("fastapi")
sentry-python-1.39.2/tests/integrations/fastapi/test_fastapi.py 0000664 0000000 0000000 00000034001 14547447232 0025022 0 ustar 00root root 0000000 0000000 import json
import logging
import threading
import pytest
from sentry_sdk.integrations.fastapi import FastApiIntegration
from fastapi import FastAPI, Request
from fastapi.testclient import TestClient
from fastapi.middleware.trustedhost import TrustedHostMiddleware
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("/error")
async def _error():
capture_message("Hi")
1 / 0
return {"message": "Hi"}
@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]"
@pytest.mark.asyncio
def test_response_status_code_ok_in_transaction_context(sentry_init, capture_envelopes):
"""
Tests that the response status code is added to the transaction "response" context.
"""
sentry_init(
integrations=[StarletteIntegration(), FastApiIntegration()],
traces_sample_rate=1.0,
release="demo-release",
)
envelopes = capture_envelopes()
app = fastapi_app_factory()
client = TestClient(app)
client.get("/message")
(_, transaction_envelope) = envelopes
transaction = transaction_envelope.get_transaction_event()
assert transaction["type"] == "transaction"
assert len(transaction["contexts"]) > 0
assert (
"response" in transaction["contexts"].keys()
), "Response context not found in transaction"
assert transaction["contexts"]["response"]["status_code"] == 200
@pytest.mark.asyncio
def test_response_status_code_error_in_transaction_context(
sentry_init,
capture_envelopes,
):
"""
Tests that the response status code is added to the transaction "response" context.
"""
sentry_init(
integrations=[StarletteIntegration(), FastApiIntegration()],
traces_sample_rate=1.0,
release="demo-release",
)
envelopes = capture_envelopes()
app = fastapi_app_factory()
client = TestClient(app)
with pytest.raises(ZeroDivisionError):
client.get("/error")
(
_,
_,
transaction_envelope,
) = envelopes
transaction = transaction_envelope.get_transaction_event()
assert transaction["type"] == "transaction"
assert len(transaction["contexts"]) > 0
assert (
"response" in transaction["contexts"].keys()
), "Response context not found in transaction"
assert transaction["contexts"]["response"]["status_code"] == 500
@pytest.mark.asyncio
def test_response_status_code_not_found_in_transaction_context(
sentry_init,
capture_envelopes,
):
"""
Tests that the response status code is added to the transaction "response" context.
"""
sentry_init(
integrations=[StarletteIntegration(), FastApiIntegration()],
traces_sample_rate=1.0,
release="demo-release",
)
envelopes = capture_envelopes()
app = fastapi_app_factory()
client = TestClient(app)
client.get("/non-existing-route-123")
(transaction_envelope,) = envelopes
transaction = transaction_envelope.get_transaction_event()
assert transaction["type"] == "transaction"
assert len(transaction["contexts"]) > 0
assert (
"response" in transaction["contexts"].keys()
), "Response context not found in transaction"
assert transaction["contexts"]["response"]["status_code"] == 404
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"tests.integrations.fastapi.test_fastapi.fastapi_app_factory.._message_with_id",
"component",
),
(
"/message/123456",
"url",
"/message/{message_id}",
"route",
),
],
)
def test_transaction_name(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
capture_envelopes,
):
"""
Tests that the transaction name is something meaningful.
"""
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[
StarletteIntegration(transaction_style=transaction_style),
FastApiIntegration(transaction_style=transaction_style),
],
traces_sample_rate=1.0,
debug=True,
)
envelopes = capture_envelopes()
app = fastapi_app_factory()
client = TestClient(app)
client.get(request_url)
(_, transaction_envelope) = envelopes
transaction_event = transaction_envelope.get_transaction_event()
assert transaction_event["transaction"] == expected_transaction_name
assert (
transaction_event["transaction_info"]["source"] == expected_transaction_source
)
def test_route_endpoint_equal_dependant_call(sentry_init):
"""
Tests that the route endpoint name is equal to the wrapped dependant call name.
"""
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[
StarletteIntegration(),
FastApiIntegration(),
],
traces_sample_rate=1.0,
debug=True,
)
app = fastapi_app_factory()
for route in app.router.routes:
if not hasattr(route, "dependant"):
continue
assert route.endpoint.__qualname__ == route.dependant.call.__qualname__
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"http://testserver/message/123456",
"url",
),
(
"/message/123456",
"url",
"http://testserver/message/123456",
"url",
),
],
)
def test_transaction_name_in_traces_sampler(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
):
"""
Tests that a custom traces_sampler retrieves a meaningful transaction name.
In this case the URL or endpoint, because we do not have the route yet.
"""
def dummy_traces_sampler(sampling_context):
assert (
sampling_context["transaction_context"]["name"] == expected_transaction_name
)
assert (
sampling_context["transaction_context"]["source"]
== expected_transaction_source
)
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[StarletteIntegration(transaction_style=transaction_style)],
traces_sampler=dummy_traces_sampler,
traces_sample_rate=1.0,
debug=True,
)
app = fastapi_app_factory()
client = TestClient(app)
client.get(request_url)
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"starlette.middleware.trustedhost.TrustedHostMiddleware",
"component",
),
(
"/message/123456",
"url",
"http://testserver/message/123456",
"url",
),
],
)
def test_transaction_name_in_middleware(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
capture_envelopes,
):
"""
Tests that the transaction name is something meaningful.
"""
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[
StarletteIntegration(transaction_style=transaction_style),
FastApiIntegration(transaction_style=transaction_style),
],
traces_sample_rate=1.0,
debug=True,
)
envelopes = capture_envelopes()
app = fastapi_app_factory()
app.add_middleware(
TrustedHostMiddleware,
allowed_hosts=[
"example.com",
],
)
client = TestClient(app)
client.get(request_url)
(transaction_envelope,) = envelopes
transaction_event = transaction_envelope.get_transaction_event()
assert transaction_event["contexts"]["response"]["status_code"] == 400
assert transaction_event["transaction"] == expected_transaction_name
assert (
transaction_event["transaction_info"]["source"] == expected_transaction_source
)
sentry-python-1.39.2/tests/integrations/flask/ 0000775 0000000 0000000 00000000000 14547447232 0021435 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/flask/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0023545 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("flask")
sentry-python-1.39.2/tests/integrations/flask/test_flask.py 0000664 0000000 0000000 00000065412 14547447232 0024156 0 ustar 00root root 0000000 0000000 import json
import re
import logging
from io import BytesIO
import pytest
from flask import (
Flask,
Response,
request,
abort,
stream_with_context,
render_template_string,
)
from flask.views import View
from flask_login import LoginManager, login_user
try:
from werkzeug.wrappers.request import UnsupportedMediaType
except ImportError:
UnsupportedMediaType = None
import sentry_sdk.integrations.flask as flask_sentry
from sentry_sdk import (
set_tag,
configure_scope,
capture_message,
capture_exception,
last_event_id,
Hub,
)
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.serializer import MAX_DATABAG_BREADTH
login_manager = LoginManager()
@pytest.fixture
def app():
app = Flask(__name__)
app.config["TESTING"] = True
app.secret_key = "haha"
login_manager.init_app(app)
@app.route("/message")
def hi():
capture_message("hi")
return "ok"
@app.route("/message/")
def hi_with_id(message_id):
capture_message("hi again")
return "ok"
return app
@pytest.fixture(params=("auto", "manual"))
def integration_enabled_params(request):
if request.param == "auto":
return {"auto_enabling_integrations": True}
elif request.param == "manual":
return {"integrations": [flask_sentry.FlaskIntegration()]}
else:
raise ValueError(request.param)
def test_has_context(sentry_init, app, capture_events):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
client = app.test_client()
response = client.get("/message")
assert response.status_code == 200
(event,) = events
assert event["transaction"] == "hi"
assert "data" not in event["request"]
assert event["request"]["url"] == "http://localhost/message"
@pytest.mark.parametrize(
"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,
url,
transaction_style,
expected_transaction,
expected_source,
):
sentry_init(
integrations=[
flask_sentry.FlaskIntegration(transaction_style=transaction_style)
]
)
events = capture_events()
client = app.test_client()
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))
@pytest.mark.parametrize("testing", (True, False))
def test_errors(
sentry_init,
capture_exceptions,
capture_events,
app,
debug,
testing,
integration_enabled_params,
):
sentry_init(debug=True, **integration_enabled_params)
app.debug = debug
app.testing = testing
@app.route("/")
def index():
1 / 0
exceptions = capture_exceptions()
events = capture_events()
client = app.test_client()
try:
client.get("/")
except ZeroDivisionError:
pass
(exc,) = exceptions
assert isinstance(exc, ZeroDivisionError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "flask"
def test_flask_login_not_installed(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
monkeypatch.setattr(flask_sentry, "flask_login", None)
events = capture_events()
client = app.test_client()
client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
def test_flask_login_not_configured(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
assert flask_sentry.flask_login
events = capture_events()
client = app.test_client()
client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
def test_flask_login_partially_configured(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
events = capture_events()
login_manager = LoginManager()
login_manager.init_app(app)
client = app.test_client()
client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
@pytest.mark.parametrize("send_default_pii", [True, False])
@pytest.mark.parametrize("user_id", [None, "42", 3])
def test_flask_login_configured(
send_default_pii,
sentry_init,
app,
user_id,
capture_events,
monkeypatch,
integration_enabled_params,
):
sentry_init(send_default_pii=send_default_pii, **integration_enabled_params)
class User(object):
is_authenticated = is_active = True
is_anonymous = user_id is not None
def get_id(self):
return str(user_id)
@login_manager.user_loader
def load_user(user_id):
if user_id is not None:
return User()
@app.route("/login")
def login():
if user_id is not None:
login_user(User())
return "ok"
events = capture_events()
client = app.test_client()
assert client.get("/login").status_code == 200
assert not events
assert client.get("/message").status_code == 200
(event,) = events
if user_id is None or not send_default_pii:
assert event.get("user", {}).get("id") is None
else:
assert event["user"]["id"] == str(user_id)
def test_flask_large_json_request(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
data = {"foo": {"bar": "a" * 2000}}
@app.route("/", methods=["POST"])
def index():
assert request.get_json() == data
assert request.get_data() == json.dumps(data).encode("ascii")
assert not request.form
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["_meta"]["request"]["data"]["foo"]["bar"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]["bar"]) == 1024
def test_flask_session_tracking(sentry_init, capture_envelopes, app):
sentry_init(
integrations=[flask_sentry.FlaskIntegration()],
release="demo-release",
)
@app.route("/")
def index():
with configure_scope() as scope:
scope.set_user({"ip_address": "1.2.3.4", "id": "42"})
try:
raise ValueError("stuff")
except Exception:
logging.exception("stuff happened")
1 / 0
envelopes = capture_envelopes()
with app.test_client() as client:
try:
client.get("/", headers={"User-Agent": "blafasel/1.0"})
except ZeroDivisionError:
pass
Hub.current.client.flush()
(first_event, error_event, session) = envelopes
first_event = first_event.get_event()
error_event = error_event.get_event()
session = session.items[0].payload.json
aggregates = session["aggregates"]
assert first_event["exception"]["values"][0]["type"] == "ValueError"
assert error_event["exception"]["values"][0]["type"] == "ZeroDivisionError"
assert len(aggregates) == 1
assert aggregates[0]["crashed"] == 1
assert aggregates[0]["started"]
assert session["attrs"]["release"] == "demo-release"
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
def test_flask_empty_json_request(sentry_init, capture_events, app, data):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
@app.route("/", methods=["POST"])
def index():
assert request.get_json() == data
assert request.get_data() == json.dumps(data).encode("ascii")
assert not request.form
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
def test_flask_medium_formdata_request(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
data = {"foo": "a" * 2000}
@app.route("/", methods=["POST"])
def index():
assert request.form["foo"] == data["foo"]
assert not request.get_data()
try:
assert not request.get_json()
except UnsupportedMediaType:
# flask/werkzeug 3
pass
capture_message("hi")
return "ok"
events = capture_events()
client = app.test_client()
response = client.post("/", data=data)
assert response.status_code == 200
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]) == 1024
def test_flask_formdata_request_appear_transaction_body(
sentry_init, capture_events, app
):
"""
Test that ensures that transaction request data contains body, even if no exception was raised
"""
sentry_init(integrations=[flask_sentry.FlaskIntegration()], traces_sample_rate=1.0)
data = {"username": "sentry-user", "age": "26"}
@app.route("/", methods=["POST"])
def index():
assert request.form["username"] == data["username"]
assert request.form["age"] == data["age"]
assert not request.get_data()
try:
assert not request.get_json()
except UnsupportedMediaType:
# flask/werkzeug 3
pass
set_tag("view", "yes")
capture_message("hi")
return "ok"
events = capture_events()
client = app.test_client()
response = client.post("/", data=data)
assert response.status_code == 200
event, transaction_event = events
assert "request" in transaction_event
assert "data" in transaction_event["request"]
assert transaction_event["request"]["data"] == data
@pytest.mark.parametrize("input_char", ["a", b"a"])
def test_flask_too_large_raw_request(sentry_init, input_char, capture_events, app):
sentry_init(
integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="small"
)
data = input_char * 2000
@app.route("/", methods=["POST"])
def index():
assert not request.form
if isinstance(data, bytes):
assert request.get_data() == data
else:
assert request.get_data() == data.encode("ascii")
try:
assert not request.get_json()
except UnsupportedMediaType:
# flask/werkzeug 3
pass
capture_message("hi")
return "ok"
events = capture_events()
client = app.test_client()
response = client.post("/", data=data)
assert response.status_code == 200
(event,) = events
assert event["_meta"]["request"]["data"] == {"": {"rem": [["!config", "x"]]}}
assert not event["request"]["data"]
def test_flask_files_and_form(sentry_init, capture_events, app):
sentry_init(
integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="always"
)
data = {"foo": "a" * 2000, "file": (BytesIO(b"hello"), "hello.txt")}
@app.route("/", methods=["POST"])
def index():
assert list(request.form) == ["foo"]
assert list(request.files) == ["file"]
try:
assert not request.get_json()
except UnsupportedMediaType:
# flask/werkzeug 3
pass
capture_message("hi")
return "ok"
events = capture_events()
client = app.test_client()
response = client.post("/", data=data)
assert response.status_code == 200
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]) == 1024
assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}}
assert not event["request"]["data"]["file"]
def test_json_not_truncated_if_max_request_body_size_is_always(
sentry_init, capture_events, app
):
sentry_init(
integrations=[flask_sentry.FlaskIntegration()], max_request_body_size="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",
[
[flask_sentry.FlaskIntegration()],
[flask_sentry.FlaskIntegration(), LoggingIntegration(event_level="ERROR")],
],
)
def test_errors_not_reported_twice(sentry_init, integrations, capture_events, app):
sentry_init(integrations=integrations)
@app.route("/")
def index():
try:
1 / 0
except Exception as e:
app.logger.exception(e)
raise e
events = capture_events()
client = app.test_client()
with pytest.raises(ZeroDivisionError):
client.get("/")
assert len(events) == 1
def test_logging(sentry_init, capture_events, app):
# ensure that Flask's logger magic doesn't break ours
sentry_init(
integrations=[
flask_sentry.FlaskIntegration(),
LoggingIntegration(event_level="ERROR"),
]
)
@app.route("/")
def index():
app.logger.error("hi")
return "ok"
events = capture_events()
client = app.test_client()
client.get("/")
(event,) = events
assert event["level"] == "error"
def test_no_errors_without_request(app, sentry_init):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
with app.app_context():
capture_exception(ValueError())
def test_cli_commands_raise(app):
if not hasattr(app, "cli"):
pytest.skip("Too old flask version")
from flask.cli import ScriptInfo
@app.cli.command()
def foo():
1 / 0
def create_app(*_):
return app
with pytest.raises(ZeroDivisionError):
app.cli.main(
args=["foo"], prog_name="myapp", obj=ScriptInfo(create_app=create_app)
)
def test_wsgi_level_error_is_caught(
app, capture_exceptions, capture_events, sentry_init
):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
def wsgi_app(environ, start_response):
1 / 0
app.wsgi_app = wsgi_app
client = app.test_client()
exceptions = capture_exceptions()
events = capture_events()
with pytest.raises(ZeroDivisionError) as exc:
client.get("/")
(error,) = exceptions
assert error is exc.value
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "wsgi"
def test_500(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
app.debug = False
app.testing = False
@app.route("/")
def index():
1 / 0
@app.errorhandler(500)
def error_handler(err):
return "Sentry error: %s" % last_event_id()
events = capture_events()
client = app.test_client()
response = client.get("/")
(event,) = events
assert response.data.decode("utf-8") == "Sentry error: %s" % event["event_id"]
def test_error_in_errorhandler(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
app.debug = False
app.testing = False
@app.route("/")
def index():
raise ValueError()
@app.errorhandler(500)
def error_handler(err):
1 / 0
events = capture_events()
client = app.test_client()
with pytest.raises(ZeroDivisionError):
client.get("/")
event1, event2 = events
(exception,) = event1["exception"]["values"]
assert exception["type"] == "ValueError"
exception = event2["exception"]["values"][-1]
assert exception["type"] == "ZeroDivisionError"
def test_bad_request_not_captured(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
@app.route("/")
def index():
abort(400)
client = app.test_client()
client.get("/")
assert not events
def test_does_not_leak_scope(sentry_init, capture_events, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
with configure_scope() as scope:
scope.set_tag("request_data", False)
@app.route("/")
def index():
with configure_scope() as scope:
scope.set_tag("request_data", True)
def generate():
for row in range(1000):
with configure_scope() as scope:
assert scope._tags["request_data"]
yield str(row) + "\n"
return Response(stream_with_context(generate()), mimetype="text/csv")
client = app.test_client()
response = client.get("/")
assert response.data.decode() == "".join(str(row) + "\n" for row in range(1000))
assert not events
with configure_scope() as scope:
assert not scope._tags["request_data"]
def test_scoped_test_client(sentry_init, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
@app.route("/")
def index():
return "ok"
with app.test_client() as client:
response = client.get("/")
assert response.status_code == 200
@pytest.mark.parametrize("exc_cls", [ZeroDivisionError, Exception])
def test_errorhandler_for_exception_swallows_exception(
sentry_init, app, capture_events, exc_cls
):
# In contrast to error handlers for a status code, error
# handlers for exceptions can swallow the exception (this is
# just how the Flask signal works)
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
@app.route("/")
def index():
1 / 0
@app.errorhandler(exc_cls)
def zerodivision(e):
return "ok"
with app.test_client() as client:
response = client.get("/")
assert response.status_code == 200
assert not events
def test_tracing_success(sentry_init, capture_events, app):
sentry_init(traces_sample_rate=1.0, integrations=[flask_sentry.FlaskIntegration()])
@app.before_request
def _():
set_tag("before_request", "yes")
@app.route("/message_tx")
def hi_tx():
set_tag("view", "yes")
capture_message("hi")
return "ok"
events = capture_events()
with app.test_client() as client:
response = client.get("/message_tx")
assert response.status_code == 200
message_event, transaction_event = events
assert transaction_event["type"] == "transaction"
assert transaction_event["transaction"] == "hi_tx"
assert transaction_event["contexts"]["trace"]["status"] == "ok"
assert transaction_event["tags"]["view"] == "yes"
assert transaction_event["tags"]["before_request"] == "yes"
assert message_event["message"] == "hi"
assert message_event["transaction"] == "hi_tx"
assert message_event["tags"]["view"] == "yes"
assert message_event["tags"]["before_request"] == "yes"
def test_tracing_error(sentry_init, capture_events, app):
sentry_init(traces_sample_rate=1.0, 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, transaction_event = events
assert transaction_event["type"] == "transaction"
assert transaction_event["transaction"] == "error"
assert transaction_event["contexts"]["trace"]["status"] == "internal_error"
assert error_event["transaction"] == "error"
(exception,) = error_event["exception"]["values"]
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()
@app.route("/")
class HelloClass(View):
def dispatch_request(self):
capture_message("hi")
return "ok"
app.add_url_rule("/hello-class/", view_func=HelloClass.as_view("hello_class"))
with app.test_client() as client:
response = client.get("/hello-class/")
assert response.status_code == 200
(event,) = events
assert event["message"] == "hi"
assert event["transaction"] == "hello_class"
@pytest.mark.parametrize(
"template_string", ["{{ sentry_trace }}", "{{ sentry_trace_meta }}"]
)
def test_template_tracing_meta(sentry_init, app, capture_events, template_string):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
events = capture_events()
@app.route("/")
def index():
hub = Hub.current
capture_message(hub.get_traceparent() + "\n" + hub.get_baggage())
return render_template_string(template_string)
with app.test_client() as client:
response = client.get("/")
assert response.status_code == 200
rendered_meta = response.data.decode("utf-8")
traceparent, baggage = events[0]["message"].split("\n")
assert traceparent != ""
assert baggage != ""
match = re.match(
r'^',
rendered_meta,
)
assert match is not None
assert match.group(1) == traceparent
# Python 2 does not preserve sort order
rendered_baggage = match.group(2)
assert sorted(rendered_baggage.split(",")) == sorted(baggage.split(","))
def test_dont_override_sentry_trace_context(sentry_init, app):
sentry_init(integrations=[flask_sentry.FlaskIntegration()])
@app.route("/")
def index():
return render_template_string("{{ sentry_trace }}", sentry_trace="hi")
with app.test_client() as client:
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]"
@pytest.mark.parametrize("traces_sample_rate", [None, 1.0])
def test_replay_event_context(sentry_init, capture_events, app, traces_sample_rate):
"""
Tests that the replay context is added to the event context.
This is not strictly a Flask integration test, but it's the easiest way to test this.
"""
sentry_init(traces_sample_rate=traces_sample_rate)
@app.route("/error")
def error():
return 1 / 0
events = capture_events()
client = app.test_client()
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,sentry-replay_id=12312012123120121231201212312012",
"sentry-trace": "771a43a4192642f0b136d5159a501700-1234567890abcdef-1",
}
with pytest.raises(ZeroDivisionError):
client.get("/error", headers=headers)
event = events[0]
assert event["contexts"]
assert event["contexts"]["replay"]
assert (
event["contexts"]["replay"]["replay_id"] == "12312012123120121231201212312012"
)
def test_response_status_code_ok_in_transaction_context(
sentry_init, capture_envelopes, app
):
"""
Tests that the response status code is added to the transaction context.
This also works for when there is an Exception during the request, but somehow the test flask app doesn't seem to trigger that.
"""
sentry_init(
integrations=[flask_sentry.FlaskIntegration()],
traces_sample_rate=1.0,
release="demo-release",
)
envelopes = capture_envelopes()
client = app.test_client()
client.get("/message")
Hub.current.client.flush()
(_, transaction_envelope, _) = envelopes
transaction = transaction_envelope.get_transaction_event()
assert transaction["type"] == "transaction"
assert len(transaction["contexts"]) > 0
assert (
"response" in transaction["contexts"].keys()
), "Response context not found in transaction"
assert transaction["contexts"]["response"]["status_code"] == 200
def test_response_status_code_not_found_in_transaction_context(
sentry_init, capture_envelopes, app
):
sentry_init(
integrations=[flask_sentry.FlaskIntegration()],
traces_sample_rate=1.0,
release="demo-release",
)
envelopes = capture_envelopes()
client = app.test_client()
client.get("/not-existing-route")
Hub.current.client.flush()
(transaction_envelope, _) = envelopes
transaction = transaction_envelope.get_transaction_event()
assert transaction["type"] == "transaction"
assert len(transaction["contexts"]) > 0
assert (
"response" in transaction["contexts"].keys()
), "Response context not found in transaction"
assert transaction["contexts"]["response"]["status_code"] == 404
sentry-python-1.39.2/tests/integrations/gcp/ 0000775 0000000 0000000 00000000000 14547447232 0021106 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/gcp/test_gcp.py 0000664 0000000 0000000 00000042150 14547447232 0023272 0 ustar 00root root 0000000 0000000 """
# GCP Cloud Functions unit tests
"""
import json
from textwrap import dedent
import tempfile
import sys
import subprocess
import pytest
import os.path
import os
pytestmark = pytest.mark.skipif(
not hasattr(tempfile, "TemporaryDirectory"), reason="need Python 3.2+"
)
FUNCTIONS_PRELUDE = """
from unittest.mock import Mock
import __main__ as gcp_functions
import os
# Initializing all the necessary environment variables
os.environ["FUNCTION_TIMEOUT_SEC"] = "3"
os.environ["FUNCTION_NAME"] = "Google Cloud function"
os.environ["ENTRY_POINT"] = "cloud_function"
os.environ["FUNCTION_IDENTITY"] = "func_ID"
os.environ["FUNCTION_REGION"] = "us-central1"
os.environ["GCP_PROJECT"] = "serverless_project"
def log_return_value(func):
def inner(*args, **kwargs):
rv = func(*args, **kwargs)
print("\\nRETURN VALUE: {}\\n".format(json.dumps(rv)))
return rv
return inner
gcp_functions.worker_v1 = Mock()
gcp_functions.worker_v1.FunctionHandler = Mock()
gcp_functions.worker_v1.FunctionHandler.invoke_user_function = log_return_value(cloud_function)
import sentry_sdk
from sentry_sdk.integrations.gcp import GcpIntegration
import json
import time
from sentry_sdk.transport import HttpTransport
def event_processor(event):
# Adding delay which would allow us to capture events.
time.sleep(1)
return event
def envelope_processor(envelope):
(item,) = envelope.items
return item.get_bytes()
class TestTransport(HttpTransport):
def _send_event(self, event):
event = event_processor(event)
# Writing a single string to stdout holds the GIL (seems like) and
# therefore cannot be interleaved with other threads. This is why we
# explicitly add a newline at the end even though `print` would provide
# us one.
print("\\nEVENT: {}\\n".format(json.dumps(event)))
def _send_envelope(self, envelope):
envelope = envelope_processor(envelope)
print("\\nENVELOPE: {}\\n".format(envelope.decode(\"utf-8\")))
def init_sdk(timeout_warning=False, **extra_init_args):
sentry_sdk.init(
dsn="https://123abc@example.com/123",
transport=TestTransport,
integrations=[GcpIntegration(timeout_warning=timeout_warning)],
shutdown_timeout=10,
# excepthook -> dedupe -> event_processor client report gets added
# which we don't really care about for these tests
send_client_reports=False,
**extra_init_args
)
"""
@pytest.fixture
def run_cloud_function():
def inner(code, subprocess_kwargs=()):
events = []
envelopes = []
return_value = None
# STEP : Create a zip of cloud function
subprocess_kwargs = dict(subprocess_kwargs)
with tempfile.TemporaryDirectory() as tmpdir:
main_py = os.path.join(tmpdir, "main.py")
with open(main_py, "w") as f:
f.write(code)
setup_cfg = os.path.join(tmpdir, "setup.cfg")
with open(setup_cfg, "w") as f:
f.write("[install]\nprefix=")
subprocess.check_call(
[sys.executable, "setup.py", "sdist", "-d", os.path.join(tmpdir, "..")],
**subprocess_kwargs
)
subprocess.check_call(
"pip install ../*.tar.gz -t .",
cwd=tmpdir,
shell=True,
**subprocess_kwargs
)
stream = os.popen("python {}/main.py".format(tmpdir))
stream_data = stream.read()
stream.close()
for line in stream_data.splitlines():
print("GCP:", line)
if line.startswith("EVENT: "):
line = line[len("EVENT: ") :]
events.append(json.loads(line))
elif line.startswith("ENVELOPE: "):
line = line[len("ENVELOPE: ") :]
envelopes.append(json.loads(line))
elif line.startswith("RETURN VALUE: "):
line = line[len("RETURN VALUE: ") :]
return_value = json.loads(line)
else:
continue
stream.close()
return envelopes, events, return_value
return inner
def test_handled_exception(run_cloud_function):
_, events, return_value = run_cloud_function(
dedent(
"""
functionhandler = None
event = {}
def cloud_function(functionhandler, event):
raise Exception("something went wrong")
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(
"""
init_sdk(timeout_warning=False)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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"
assert not exception["mechanism"]["handled"]
def test_unhandled_exception(run_cloud_function):
_, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
event = {}
def cloud_function(functionhandler, event):
x = 3/0
return "3"
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(
"""
init_sdk(timeout_warning=False)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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"
assert not exception["mechanism"]["handled"]
def test_timeout_error(run_cloud_function):
_, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
event = {}
def cloud_function(functionhandler, event):
time.sleep(10)
return "3"
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(
"""
init_sdk(timeout_warning=True)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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"
assert not exception["mechanism"]["handled"]
def test_performance_no_error(run_cloud_function):
envelopes, _, _ = run_cloud_function(
dedent(
"""
functionhandler = None
event = {}
def cloud_function(functionhandler, event):
return "test_string"
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(
"""
init_sdk(traces_sample_rate=1.0)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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):
envelopes, events, _ = run_cloud_function(
dedent(
"""
functionhandler = None
event = {}
def cloud_function(functionhandler, event):
raise Exception("something went wrong")
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(
"""
init_sdk(traces_sample_rate=1.0)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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"
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(
run_cloud_function, DictionaryContaining # noqa:N803
):
# TODO: There are some decent sized hacks below. For more context, see the
# long comment in the test of the same name in the AWS integration. The
# situations there and here aren't identical, but they're similar enough
# that solving one would probably solve both.
import inspect
envelopes, events, return_value = run_cloud_function(
dedent(
"""
functionhandler = None
event = {
"type": "chase",
"chasers": ["Maisey", "Charlie"],
"num_squirrels": 2,
}
def cloud_function(functionhandler, event):
# this runs after the transaction has started, which means we
# can make assertions about traces_sampler
try:
traces_sampler.assert_any_call(
DictionaryContaining({
"gcp_env": DictionaryContaining({
"function_name": "chase_into_tree",
"function_region": "dogpark",
"function_project": "SquirrelChasing",
}),
"gcp_event": {
"type": "chase",
"chasers": ["Maisey", "Charlie"],
"num_squirrels": 2,
},
})
)
except AssertionError:
# catch the error and return it because the error itself will
# get swallowed by the SDK as an "internal exception"
return {"AssertionError raised": True,}
return {"AssertionError raised": False,}
"""
)
+ FUNCTIONS_PRELUDE
+ dedent(inspect.getsource(DictionaryContaining))
+ dedent(
"""
os.environ["FUNCTION_NAME"] = "chase_into_tree"
os.environ["FUNCTION_REGION"] = "dogpark"
os.environ["GCP_PROJECT"] = "SquirrelChasing"
def _safe_is_equal(x, y):
# copied from conftest.py - see docstring and comments there
try:
is_equal = x.__eq__(y)
except AttributeError:
is_equal = NotImplemented
if is_equal == NotImplemented:
return x == y
return is_equal
traces_sampler = Mock(return_value=True)
init_sdk(
traces_sampler=traces_sampler,
)
gcp_functions.worker_v1.FunctionHandler.invoke_user_function(functionhandler, event)
"""
)
)
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"
)
sentry-python-1.39.2/tests/integrations/gql/ 0000775 0000000 0000000 00000000000 14547447232 0021120 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/gql/__init__.py 0000664 0000000 0000000 00000000052 14547447232 0023226 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("gql")
sentry-python-1.39.2/tests/integrations/gql/test_gql.py 0000664 0000000 0000000 00000016306 14547447232 0023322 0 ustar 00root root 0000000 0000000 import pytest
import responses
from gql import gql
from gql import Client
from gql.transport.exceptions import TransportQueryError
from gql.transport.requests import RequestsHTTPTransport
from graphql import DocumentNode
from sentry_sdk.integrations.gql import GQLIntegration
from unittest.mock import MagicMock, patch
class _MockClientBase(MagicMock):
"""
Mocked version of GQL Client class, following same spec as GQL Client.
"""
def __init__(self, *args, **kwargs):
kwargs["spec"] = Client
super().__init__(*args, **kwargs)
transport = MagicMock()
@responses.activate
def _execute_mock_query(response_json):
url = "http://example.com/graphql"
query_string = """
query Example {
example
}
"""
# Mock the GraphQL server response
responses.add(
method=responses.POST,
url=url,
json=response_json,
status=200,
)
transport = RequestsHTTPTransport(url=url)
client = Client(transport=transport)
query = gql(query_string)
return client.execute(query)
def _make_erroneous_query(capture_events):
"""
Make an erroneous GraphQL query, and assert that the error was reraised, that
exactly one event was recorded, and that the exception recorded was a
TransportQueryError. Then, return the event to allow further verifications.
"""
events = capture_events()
response_json = {"errors": ["something bad happened"]}
with pytest.raises(TransportQueryError):
_execute_mock_query(response_json)
assert (
len(events) == 1
), "the sdk captured %d events, but 1 event was expected" % len(events)
(event,) = events
(exception,) = event["exception"]["values"]
assert (
exception["type"] == "TransportQueryError"
), "%s was captured, but we expected a TransportQueryError" % exception(type)
assert "request" in event
return event
def test_gql_init(sentry_init):
"""
Integration test to ensure we can initialize the SDK with the GQL Integration
"""
sentry_init(integrations=[GQLIntegration()])
@patch("sentry_sdk.integrations.gql.Hub")
def test_setup_once_patches_execute_and_patched_function_calls_original(_):
"""
Unit test which ensures the following:
1. The GQLIntegration setup_once function patches the gql.Client.execute method
2. The patched gql.Client.execute method still calls the original method, and it
forwards its arguments to the original method.
3. The patched gql.Client.execute method returns the same value that the original
method returns.
"""
original_method_return_value = MagicMock()
class OriginalMockClient(_MockClientBase):
"""
This mock client always returns the mock original_method_return_value when a query
is executed. This can be used to simulate successful GraphQL queries.
"""
execute = MagicMock(
spec=Client.execute, return_value=original_method_return_value
)
original_execute_method = OriginalMockClient.execute
with patch(
"sentry_sdk.integrations.gql.gql.Client", new=OriginalMockClient
) as PatchedMockClient: # noqa: N806
# Below line should patch the PatchedMockClient with Sentry SDK magic
GQLIntegration.setup_once()
# We expect GQLIntegration.setup_once to patch the execute method.
assert (
PatchedMockClient.execute is not original_execute_method
), "execute method not patched"
# Now, let's instantiate a client and send it a query. Original execute still should get called.
mock_query = MagicMock(spec=DocumentNode)
client_instance = PatchedMockClient()
patched_method_return_value = client_instance.execute(mock_query)
# Here, we check that the original execute was called
original_execute_method.assert_called_once_with(client_instance, mock_query)
# Also, let's verify that the patched execute returns the expected value.
assert (
patched_method_return_value is original_method_return_value
), "pathced execute method returns a different value than the original execute method"
@patch("sentry_sdk.integrations.gql.event_from_exception")
@patch("sentry_sdk.integrations.gql.Hub")
def test_patched_gql_execute_captures_and_reraises_graphql_exception(
mock_hub, mock_event_from_exception
):
"""
Unit test which ensures that in the case that calling the execute method results in a
TransportQueryError (which gql raises when a GraphQL error occurs), the patched method
captures the event on the current Hub and it reraises the error.
"""
mock_event_from_exception.return_value = (dict(), MagicMock())
class OriginalMockClient(_MockClientBase):
"""
This mock client always raises a TransportQueryError when a GraphQL query is attempted.
This simulates a GraphQL query which results in errors.
"""
execute = MagicMock(
spec=Client.execute, side_effect=TransportQueryError("query failed")
)
with patch(
"sentry_sdk.integrations.gql.gql.Client", new=OriginalMockClient
) as PatchedMockClient: # noqa: N806
# Below line should patch the PatchedMockClient with Sentry SDK magic
GQLIntegration.setup_once()
mock_query = MagicMock(spec=DocumentNode)
client_instance = PatchedMockClient()
# The error should still get raised even though we have instrumented the execute method.
with pytest.raises(TransportQueryError):
client_instance.execute(mock_query)
# However, we should have also captured the error on the hub.
mock_capture_event = mock_hub.current.capture_event
mock_capture_event.assert_called_once()
def test_real_gql_request_no_error(sentry_init, capture_events):
"""
Integration test verifying that the GQLIntegration works as expected with successful query.
"""
sentry_init(integrations=[GQLIntegration()])
events = capture_events()
response_data = {"example": "This is the example"}
response_json = {"data": response_data}
result = _execute_mock_query(response_json)
assert (
result == response_data
), "client.execute returned a different value from what it received from the server"
assert (
len(events) == 0
), "the sdk captured an event, even though the query was successful"
def test_real_gql_request_with_error_no_pii(sentry_init, capture_events):
"""
Integration test verifying that the GQLIntegration works as expected with query resulting
in a GraphQL error, and that PII is not sent.
"""
sentry_init(integrations=[GQLIntegration()])
event = _make_erroneous_query(capture_events)
assert "data" not in event["request"]
assert "response" not in event["contexts"]
def test_real_gql_request_with_error_with_pii(sentry_init, capture_events):
"""
Integration test verifying that the GQLIntegration works as expected with query resulting
in a GraphQL error, and that PII is not sent.
"""
sentry_init(integrations=[GQLIntegration()], send_default_pii=True)
event = _make_erroneous_query(capture_events)
assert "data" in event["request"]
assert "response" in event["contexts"]
sentry-python-1.39.2/tests/integrations/graphene/ 0000775 0000000 0000000 00000000000 14547447232 0022126 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/graphene/__init__.py 0000664 0000000 0000000 00000000153 14547447232 0024236 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("graphene")
pytest.importorskip("fastapi")
pytest.importorskip("flask")
sentry-python-1.39.2/tests/integrations/graphene/test_graphene_py3.py 0000664 0000000 0000000 00000013037 14547447232 0026127 0 ustar 00root root 0000000 0000000 from fastapi import FastAPI, Request
from fastapi.testclient import TestClient
from flask import Flask, request, jsonify
from graphene import ObjectType, String, Schema
from sentry_sdk.integrations.fastapi import FastApiIntegration
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.graphene import GrapheneIntegration
from sentry_sdk.integrations.starlette import StarletteIntegration
class Query(ObjectType):
hello = String(first_name=String(default_value="stranger"))
goodbye = String()
def resolve_hello(root, info, first_name): # noqa: N805
return "Hello {}!".format(first_name)
def resolve_goodbye(root, info): # noqa: N805
raise RuntimeError("oh no!")
def test_capture_request_if_available_and_send_pii_is_on_async(
sentry_init, capture_events
):
sentry_init(
send_default_pii=True,
integrations=[
GrapheneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = Schema(query=Query)
async_app = FastAPI()
@async_app.post("/graphql")
async def graphql_server_async(request: Request):
data = await request.json()
result = await schema.execute_async(data["query"])
return result.data
query = {"query": "query ErrorQuery {goodbye}"}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "graphene"
assert event["request"]["api_target"] == "graphql"
assert event["request"]["data"] == query
def test_capture_request_if_available_and_send_pii_is_on_sync(
sentry_init, capture_events
):
sentry_init(
send_default_pii=True,
integrations=[GrapheneIntegration(), FlaskIntegration()],
)
events = capture_events()
schema = Schema(query=Query)
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server_sync():
data = request.get_json()
result = schema.execute(data["query"])
return jsonify(result.data), 200
query = {"query": "query ErrorQuery {goodbye}"}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "graphene"
assert event["request"]["api_target"] == "graphql"
assert event["request"]["data"] == query
def test_do_not_capture_request_if_send_pii_is_off_async(sentry_init, capture_events):
sentry_init(
integrations=[
GrapheneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = Schema(query=Query)
async_app = FastAPI()
@async_app.post("/graphql")
async def graphql_server_async(request: Request):
data = await request.json()
result = await schema.execute_async(data["query"])
return result.data
query = {"query": "query ErrorQuery {goodbye}"}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "graphene"
assert "data" not in event["request"]
assert "response" not in event["contexts"]
def test_do_not_capture_request_if_send_pii_is_off_sync(sentry_init, capture_events):
sentry_init(
integrations=[GrapheneIntegration(), FlaskIntegration()],
)
events = capture_events()
schema = Schema(query=Query)
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server_sync():
data = request.get_json()
result = schema.execute(data["query"])
return jsonify(result.data), 200
query = {"query": "query ErrorQuery {goodbye}"}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 1
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "graphene"
assert "data" not in event["request"]
assert "response" not in event["contexts"]
def test_no_event_if_no_errors_async(sentry_init, capture_events):
sentry_init(
integrations=[
GrapheneIntegration(),
FastApiIntegration(),
StarletteIntegration(),
],
)
events = capture_events()
schema = Schema(query=Query)
async_app = FastAPI()
@async_app.post("/graphql")
async def graphql_server_async(request: Request):
data = await request.json()
result = await schema.execute_async(data["query"])
return result.data
query = {
"query": "query GreetingQuery { hello }",
}
client = TestClient(async_app)
client.post("/graphql", json=query)
assert len(events) == 0
def test_no_event_if_no_errors_sync(sentry_init, capture_events):
sentry_init(
integrations=[
GrapheneIntegration(),
FlaskIntegration(),
],
)
events = capture_events()
schema = Schema(query=Query)
sync_app = Flask(__name__)
@sync_app.route("/graphql", methods=["POST"])
def graphql_server_sync():
data = request.get_json()
result = schema.execute(data["query"])
return jsonify(result.data), 200
query = {
"query": "query GreetingQuery { hello }",
}
client = sync_app.test_client()
client.post("/graphql", json=query)
assert len(events) == 0
sentry-python-1.39.2/tests/integrations/grpc/ 0000775 0000000 0000000 00000000000 14547447232 0021270 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/grpc/__init__.py 0000664 0000000 0000000 00000000261 14547447232 0023400 0 ustar 00root root 0000000 0000000 import sys
from pathlib import Path
import pytest
# For imports inside gRPC autogenerated code to work
sys.path.append(str(Path(__file__).parent))
pytest.importorskip("grpc")
sentry-python-1.39.2/tests/integrations/grpc/compile_test_services.sh 0000775 0000000 0000000 00000000623 14547447232 0026222 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
# Run this script from the project root to generate the python code
TARGET_PATH=./tests/integrations/grpc
# Create python file
python -m grpc_tools.protoc \
--proto_path=$TARGET_PATH/protos/ \
--python_out=$TARGET_PATH/ \
--pyi_out=$TARGET_PATH/ \
--grpc_python_out=$TARGET_PATH/ \
$TARGET_PATH/protos/grpc_test_service.proto
echo Code generation successfull
sentry-python-1.39.2/tests/integrations/grpc/grpc_test_service_pb2.py 0000664 0000000 0000000 00000003110 14547447232 0026112 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: grpc_test_service.proto
"""Generated protocol buffer code."""
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
from google.protobuf.internal import builder as _builder
# @@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(\t2\xf8\x02\n\x0fgRPCTestService\x12Q\n\tTestServe\x12!.grpc_test_server.gRPCTestMessage\x1a!.grpc_test_server.gRPCTestMessage\x12Y\n\x0fTestUnaryStream\x12!.grpc_test_server.gRPCTestMessage\x1a!.grpc_test_server.gRPCTestMessage0\x01\x12\\\n\x10TestStreamStream\x12!.grpc_test_server.gRPCTestMessage\x1a!.grpc_test_server.gRPCTestMessage(\x01\x30\x01\x12Y\n\x0fTestStreamUnary\x12!.grpc_test_server.gRPCTestMessage\x1a!.grpc_test_server.gRPCTestMessage(\x01\x62\x06proto3')
_globals = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'grpc_test_service_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS == False:
DESCRIPTOR._options = None
_globals['_GRPCTESTMESSAGE']._serialized_start=45
_globals['_GRPCTESTMESSAGE']._serialized_end=76
_globals['_GRPCTESTSERVICE']._serialized_start=79
_globals['_GRPCTESTSERVICE']._serialized_end=455
# @@protoc_insertion_point(module_scope)
sentry-python-1.39.2/tests/integrations/grpc/grpc_test_service_pb2.pyi 0000664 0000000 0000000 00000000605 14547447232 0026271 0 ustar 00root root 0000000 0000000 from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from typing import ClassVar as _ClassVar, Optional as _Optional
DESCRIPTOR: _descriptor.FileDescriptor
class gRPCTestMessage(_message.Message):
__slots__ = ["text"]
TEXT_FIELD_NUMBER: _ClassVar[int]
text: str
def __init__(self, text: _Optional[str] = ...) -> None: ...
sentry-python-1.39.2/tests/integrations/grpc/grpc_test_service_pb2_grpc.py 0000664 0000000 0000000 00000016605 14547447232 0027142 0 ustar 00root root 0000000 0000000 # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import 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,
)
self.TestUnaryStream = channel.unary_stream(
'/grpc_test_server.gRPCTestService/TestUnaryStream',
request_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
response_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
)
self.TestStreamStream = channel.stream_stream(
'/grpc_test_server.gRPCTestService/TestStreamStream',
request_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
response_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
)
self.TestStreamUnary = channel.stream_unary(
'/grpc_test_server.gRPCTestService/TestStreamUnary',
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 TestUnaryStream(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 TestStreamStream(self, request_iterator, 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 TestStreamUnary(self, request_iterator, 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,
),
'TestUnaryStream': grpc.unary_stream_rpc_method_handler(
servicer.TestUnaryStream,
request_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
response_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
),
'TestStreamStream': grpc.stream_stream_rpc_method_handler(
servicer.TestStreamStream,
request_deserializer=grpc__test__service__pb2.gRPCTestMessage.FromString,
response_serializer=grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
),
'TestStreamUnary': grpc.stream_unary_rpc_method_handler(
servicer.TestStreamUnary,
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)
@staticmethod
def TestUnaryStream(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_stream(request, target, '/grpc_test_server.gRPCTestService/TestUnaryStream',
grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
grpc__test__service__pb2.gRPCTestMessage.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def TestStreamStream(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/grpc_test_server.gRPCTestService/TestStreamStream',
grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
grpc__test__service__pb2.gRPCTestMessage.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def TestStreamUnary(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_unary(request_iterator, target, '/grpc_test_server.gRPCTestService/TestStreamUnary',
grpc__test__service__pb2.gRPCTestMessage.SerializeToString,
grpc__test__service__pb2.gRPCTestMessage.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
sentry-python-1.39.2/tests/integrations/grpc/protos/ 0000775 0000000 0000000 00000000000 14547447232 0022616 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/grpc/protos/grpc_test_service.proto 0000664 0000000 0000000 00000000631 14547447232 0027415 0 ustar 00root root 0000000 0000000 syntax = "proto3";
package grpc_test_server;
service gRPCTestService{
rpc TestServe(gRPCTestMessage) returns (gRPCTestMessage);
rpc TestUnaryStream(gRPCTestMessage) returns (stream gRPCTestMessage);
rpc TestStreamStream(stream gRPCTestMessage) returns (stream gRPCTestMessage);
rpc TestStreamUnary(stream gRPCTestMessage) returns (gRPCTestMessage);
}
message gRPCTestMessage {
string text = 1;
}
sentry-python-1.39.2/tests/integrations/grpc/test_grpc.py 0000664 0000000 0000000 00000024234 14547447232 0023641 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import os
from typing import List, Optional
from concurrent import futures
from unittest.mock import Mock
import grpc
import pytest
from sentry_sdk import Hub, start_transaction
from sentry_sdk.consts import OP
from sentry_sdk.integrations.grpc import GRPCIntegration
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, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(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_other_interceptors(sentry_init, capture_events_forksafe):
"""Ensure compatibility with additional server interceptors."""
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
mock_intercept = lambda continuation, handler_call_details: continuation(
handler_call_details
)
mock_interceptor = Mock()
mock_interceptor.intercept_service.side_effect = mock_intercept
server = _set_up(interceptors=[mock_interceptor])
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
stub = gRPCTestServiceStub(channel)
stub.TestServe(gRPCTestMessage(text="test"))
_tear_down(server=server)
mock_interceptor.intercept_service.assert_called_once()
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, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(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, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
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_unary_stream_starts_span(sentry_init, capture_events_forksafe):
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
stub = gRPCTestServiceStub(channel)
with start_transaction():
[el for el in stub.TestUnaryStream(gRPCTestMessage(text="test"))]
_tear_down(server=server)
events.write_file.close()
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 stream call to /grpc_test_server.gRPCTestService/TestUnaryStream"
)
assert span["data"] == {
"type": "unary stream",
"method": "/grpc_test_server.gRPCTestService/TestUnaryStream",
}
# using unittest.mock.Mock not possible because grpc verifies
# that the interceptor is of the correct type
class MockClientInterceptor(grpc.UnaryUnaryClientInterceptor):
call_counter = 0
def intercept_unary_unary(self, continuation, client_call_details, request):
self.__class__.call_counter += 1
return continuation(client_call_details, request)
@pytest.mark.forked
def test_grpc_client_other_interceptor(sentry_init, capture_events_forksafe):
"""Ensure compatibility with additional client interceptors."""
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
channel = grpc.intercept_channel(channel, MockClientInterceptor())
stub = gRPCTestServiceStub(channel)
with start_transaction():
stub.TestServe(gRPCTestMessage(text="test"))
_tear_down(server=server)
assert MockClientInterceptor.call_counter == 1
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, integrations=[GRPCIntegration()])
events = capture_events_forksafe()
server = _set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
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"]
)
@pytest.mark.forked
def test_stream_stream(sentry_init):
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
_set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
stub = gRPCTestServiceStub(channel)
response_iterator = stub.TestStreamStream(iter((gRPCTestMessage(text="test"),)))
for response in response_iterator:
assert response.text == "test"
def test_stream_unary(sentry_init):
"""Test to verify stream-stream works.
Tracing not supported for it yet.
"""
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
_set_up()
with grpc.insecure_channel("localhost:{}".format(PORT)) as channel:
stub = gRPCTestServiceStub(channel)
response = stub.TestStreamUnary(iter((gRPCTestMessage(text="test"),)))
assert response.text == "test"
def _set_up(interceptors: Optional[List[grpc.ServerInterceptor]] = None):
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=2),
interceptors=interceptors,
)
add_gRPCTestServiceServicer_to_server(TestService(), server)
server.add_insecure_port("[::]:{}".format(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)
@staticmethod
def TestUnaryStream(request, context): # noqa: N802
for _ in range(3):
yield gRPCTestMessage(text=request.text)
@staticmethod
def TestStreamStream(request, context): # noqa: N802
for r in request:
yield r
@staticmethod
def TestStreamUnary(request, context): # noqa: N802
requests = [r for r in request]
return requests.pop()
sentry-python-1.39.2/tests/integrations/grpc/test_grpc_aio.py 0000664 0000000 0000000 00000017603 14547447232 0024473 0 ustar 00root root 0000000 0000000 from __future__ import absolute_import
import asyncio
import os
import grpc
import pytest
import pytest_asyncio
import sentry_sdk
from sentry_sdk import Hub, start_transaction
from sentry_sdk.consts import OP
from sentry_sdk.integrations.grpc import GRPCIntegration
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,
)
AIO_PORT = 50052
AIO_PORT += os.getpid() % 100 # avoid port conflicts when running tests in parallel
@pytest.fixture(scope="function")
def event_loop(request):
"""Create an instance of the default event loop for each test case."""
loop = asyncio.new_event_loop()
yield loop
loop.close()
@pytest_asyncio.fixture(scope="function")
async def grpc_server(sentry_init, event_loop):
sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
server = grpc.aio.server()
server.add_insecure_port("[::]:{}".format(AIO_PORT))
add_gRPCTestServiceServicer_to_server(TestService, server)
await event_loop.create_task(server.start())
try:
yield server
finally:
await server.stop(None)
@pytest.mark.asyncio
async def test_grpc_server_starts_transaction(capture_events, grpc_server):
events = capture_events()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
await stub.TestServe(gRPCTestMessage(text="test"))
(event,) = events
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.asyncio
async def test_grpc_server_continues_transaction(capture_events, grpc_server):
events = capture_events()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
with sentry_sdk.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,
),
),
)
await stub.TestServe(gRPCTestMessage(text="test"), metadata=metadata)
(event, _) = events
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.asyncio
async def test_grpc_server_exception(capture_events, grpc_server):
events = capture_events()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
try:
await stub.TestServe(gRPCTestMessage(text="exception"))
raise AssertionError()
except Exception:
pass
(event, _) = events
assert event["exception"]["values"][0]["type"] == "TestService.TestException"
assert event["exception"]["values"][0]["value"] == "test"
assert event["exception"]["values"][0]["mechanism"]["handled"] is False
assert event["exception"]["values"][0]["mechanism"]["type"] == "grpc"
@pytest.mark.asyncio
async def test_grpc_server_abort(capture_events, grpc_server):
events = capture_events()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
try:
await stub.TestServe(gRPCTestMessage(text="abort"))
raise AssertionError()
except Exception:
pass
assert len(events) == 1
@pytest.mark.asyncio
async def test_grpc_client_starts_span(
grpc_server, sentry_init, capture_events_forksafe
):
events = capture_events_forksafe()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
with start_transaction():
await stub.TestServe(gRPCTestMessage(text="test"))
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.asyncio
async def test_grpc_client_unary_stream_starts_span(
grpc_server, capture_events_forksafe
):
events = capture_events_forksafe()
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
with start_transaction():
response = stub.TestUnaryStream(gRPCTestMessage(text="test"))
[_ async for _ in response]
events.write_file.close()
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 stream call to /grpc_test_server.gRPCTestService/TestUnaryStream"
)
assert span["data"] == {
"type": "unary stream",
"method": "/grpc_test_server.gRPCTestService/TestUnaryStream",
}
@pytest.mark.asyncio
async def test_stream_stream(grpc_server):
"""Test to verify stream-stream works.
Tracing not supported for it yet.
"""
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
response = stub.TestStreamStream((gRPCTestMessage(text="test"),))
async for r in response:
assert r.text == "test"
@pytest.mark.asyncio
async def test_stream_unary(grpc_server):
"""Test to verify stream-stream works.
Tracing not supported for it yet.
"""
async with grpc.aio.insecure_channel("localhost:{}".format(AIO_PORT)) as channel:
stub = gRPCTestServiceStub(channel)
response = await stub.TestStreamUnary((gRPCTestMessage(text="test"),))
assert response.text == "test"
class TestService(gRPCTestServiceServicer):
class TestException(Exception):
def __init__(self):
super().__init__("test")
@classmethod
async def TestServe(cls, request, context): # noqa: N802
hub = Hub.current
with hub.start_span(op="test", description="test"):
pass
if request.text == "exception":
raise cls.TestException()
if request.text == "abort":
await context.abort(grpc.StatusCode.ABORTED)
return gRPCTestMessage(text=request.text)
@classmethod
async def TestUnaryStream(cls, request, context): # noqa: N802
for _ in range(3):
yield gRPCTestMessage(text=request.text)
@classmethod
async def TestStreamStream(cls, request, context): # noqa: N802
async for r in request:
yield r
@classmethod
async def TestStreamUnary(cls, request, context): # noqa: N802
requests = [r async for r in request]
return requests.pop()
sentry-python-1.39.2/tests/integrations/httpx/ 0000775 0000000 0000000 00000000000 14547447232 0021504 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/httpx/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0023614 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("httpx")
sentry-python-1.39.2/tests/integrations/httpx/test_httpx.py 0000664 0000000 0000000 00000020611 14547447232 0024264 0 ustar 00root root 0000000 0000000 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
@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)
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()])
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",
(httpx.Client(), httpx.AsyncClient()),
)
def test_outgoing_trace_headers_append_to_baggage(sentry_init, httpx_client):
sentry_init(
traces_sample_rate=1.0,
integrations=[HttpxIntegration()],
release="d08ebdb9309e1b004c6f52202de58a09c2268e42",
)
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, headers={"baGGage": "custom=data"})
)
else:
response = httpx_client.get(url, headers={"baGGage": "custom=data"})
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,
)
assert (
response.request.headers["baggage"]
== "custom=data,sentry-trace_id=01234567890123456789012345678901,sentry-environment=production,sentry-release=d08ebdb9309e1b004c6f52202de58a09c2268e42,sentry-transaction=/interactions/other-dogs/new-dog,sentry-sample_rate=1.0,sentry-sampled=true"
)
@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
}
sentry-python-1.39.2/tests/integrations/huey/ 0000775 0000000 0000000 00000000000 14547447232 0021307 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/huey/__init__.py 0000664 0000000 0000000 00000000053 14547447232 0023416 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("huey")
sentry-python-1.39.2/tests/integrations/huey/test_huey.py 0000664 0000000 0000000 00000010763 14547447232 0023701 0 ustar 00root root 0000000 0000000 import pytest
from decimal import DivisionByZero
from sentry_sdk import start_transaction
from sentry_sdk.integrations.huey import HueyIntegration
from sentry_sdk.utils import parse_version
from huey import __version__ as HUEY_VERSION
from huey.api import MemoryHuey, Result
from huey.exceptions import RetryTask
HUEY_VERSION = parse_version(HUEY_VERSION)
@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
@pytest.mark.parametrize("lock_name", ["lock.a", "lock.b"], ids=["locked", "unlocked"])
@pytest.mark.skipif(HUEY_VERSION < (2, 5), reason="is_locked was added in 2.5")
def test_task_lock(capture_events, init_huey, lock_name):
huey = init_huey()
task_lock_name = "lock.a"
should_be_locked = task_lock_name == lock_name
@huey.task()
@huey.lock_task(task_lock_name)
def maybe_locked_task():
pass
events = capture_events()
with huey.lock_task(lock_name):
assert huey.is_locked(task_lock_name) == should_be_locked
result = execute_huey_task(huey, maybe_locked_task)
(event,) = events
assert event["transaction"] == "maybe_locked_task"
assert event["tags"]["huey_task_id"] == result.task.id
assert (
event["contexts"]["trace"]["status"] == "aborted" if should_be_locked else "ok"
)
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"
sentry-python-1.39.2/tests/integrations/logging/ 0000775 0000000 0000000 00000000000 14547447232 0021763 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/logging/test_logging.py 0000664 0000000 0000000 00000015400 14547447232 0025022 0 ustar 00root root 0000000 0000000 # coding: utf-8
import sys
import pytest
import logging
import warnings
from sentry_sdk.integrations.logging import LoggingIntegration, ignore_logger
other_logger = logging.getLogger("testfoo")
logger = logging.getLogger(__name__)
@pytest.fixture(autouse=True)
def reset_level():
other_logger.setLevel(logging.DEBUG)
logger.setLevel(logging.DEBUG)
@pytest.mark.parametrize("logger", [logger, other_logger])
def test_logging_works_with_many_loggers(sentry_init, capture_events, logger):
sentry_init(integrations=[LoggingIntegration(event_level="ERROR")])
events = capture_events()
logger.info("bread")
logger.critical("LOL")
(event,) = events
assert event["level"] == "fatal"
assert not event["logentry"]["params"]
assert event["logentry"]["message"] == "LOL"
assert any(crumb["message"] == "bread" for crumb in event["breadcrumbs"]["values"])
@pytest.mark.parametrize("integrations", [None, [], [LoggingIntegration()]])
@pytest.mark.parametrize(
"kwargs", [{"exc_info": None}, {}, {"exc_info": 0}, {"exc_info": False}]
)
def test_logging_defaults(integrations, sentry_init, capture_events, kwargs):
sentry_init(integrations=integrations)
events = capture_events()
logger.info("bread")
logger.critical("LOL", **kwargs)
(event,) = events
assert event["level"] == "fatal"
assert any(crumb["message"] == "bread" for crumb in event["breadcrumbs"]["values"])
assert not any(
crumb["message"] == "LOL" for crumb in event["breadcrumbs"]["values"]
)
assert "threads" not in event
def test_logging_extra_data(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
logger.info("bread", extra=dict(foo=42))
logger.critical("lol", extra=dict(bar=69))
(event,) = events
assert event["level"] == "fatal"
assert event["extra"] == {"bar": 69}
assert any(
crumb["message"] == "bread" and crumb["data"] == {"foo": 42}
for crumb in event["breadcrumbs"]["values"]
)
def test_logging_extra_data_integer_keys(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
logger.critical("integer in extra keys", extra={1: 1})
(event,) = events
assert event["extra"] == {"1": 1}
@pytest.mark.xfail(sys.version_info[:2] == (3, 4), reason="buggy logging module")
def test_logging_stack(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
logger.error("first", exc_info=True)
logger.error("second")
(
event_with,
event_without,
) = events
assert event_with["level"] == "error"
assert event_with["threads"]["values"][0]["stacktrace"]["frames"]
assert event_without["level"] == "error"
assert "threads" not in event_without
def test_logging_level(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
logger.setLevel(logging.WARNING)
logger.error("hi")
(event,) = events
assert event["level"] == "error"
assert event["logentry"]["message"] == "hi"
del events[:]
logger.setLevel(logging.ERROR)
logger.warning("hi")
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()
should_log = False
class MyFilter(logging.Filter):
def filter(self, record):
return should_log
logger.addFilter(MyFilter())
logger.error("hi")
assert not events
should_log = True
logger.error("hi")
(event,) = events
assert event["logentry"]["message"] == "hi"
def test_logging_captured_warnings(sentry_init, capture_events, recwarn):
sentry_init(
integrations=[LoggingIntegration(event_level="WARNING")],
default_integrations=False,
)
events = capture_events()
logging.captureWarnings(True)
warnings.warn("first", stacklevel=2)
warnings.warn("second", stacklevel=2)
logging.captureWarnings(False)
warnings.warn("third", stacklevel=2)
assert len(events) == 2
assert events[0]["level"] == "warning"
# Captured warnings start with the path where the warning was raised
assert "UserWarning: first" in events[0]["logentry"]["message"]
assert events[0]["logentry"]["params"] == []
assert events[1]["level"] == "warning"
assert "UserWarning: second" in events[1]["logentry"]["message"]
assert events[1]["logentry"]["params"] == []
# Using recwarn suppresses the "third" warning in the test output
assert len(recwarn) == 1
assert str(recwarn[0].message) == "third"
def test_ignore_logger(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
ignore_logger("testfoo")
other_logger.error("hi")
assert not events
def test_ignore_logger_wildcard(sentry_init, capture_events):
sentry_init(integrations=[LoggingIntegration()], default_integrations=False)
events = capture_events()
ignore_logger("testfoo.*")
nested_logger = logging.getLogger("testfoo.submodule")
logger.error("hi")
nested_logger.error("bye")
(event,) = events
assert event["logentry"]["message"] == "hi"
sentry-python-1.39.2/tests/integrations/loguru/ 0000775 0000000 0000000 00000000000 14547447232 0021652 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/loguru/__init__.py 0000664 0000000 0000000 00000000055 14547447232 0023763 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("loguru")
sentry-python-1.39.2/tests/integrations/loguru/test_loguru.py 0000664 0000000 0000000 00000006302 14547447232 0024601 0 ustar 00root root 0000000 0000000 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
def test_breadcrumb_format(sentry_init, capture_events):
sentry_init(
integrations=[
LoguruIntegration(
level=LoggingLevels.INFO.value,
event_level=None,
breadcrumb_format="{message}",
)
],
default_integrations=False,
)
logger.info("test")
formatted_message = "test"
breadcrumbs = sentry_sdk.Hub.current.scope._breadcrumbs
(breadcrumb,) = breadcrumbs
assert breadcrumb["message"] == formatted_message
def test_event_format(sentry_init, capture_events):
sentry_init(
integrations=[
LoguruIntegration(
level=None,
event_level=LoggingLevels.ERROR.value,
event_format="{message}",
)
],
default_integrations=False,
)
events = capture_events()
logger.error("test")
formatted_message = "test"
(event,) = events
assert event["logentry"]["message"] == formatted_message
sentry-python-1.39.2/tests/integrations/modules/ 0000775 0000000 0000000 00000000000 14547447232 0022005 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/modules/test_modules.py 0000664 0000000 0000000 00000000557 14547447232 0025075 0 ustar 00root root 0000000 0000000 import sentry_sdk
from sentry_sdk.integrations.modules import ModulesIntegration
def test_basic(sentry_init, capture_events):
sentry_init(integrations=[ModulesIntegration()])
events = capture_events()
sentry_sdk.capture_exception(ValueError())
(event,) = events
assert "sentry-sdk" in event["modules"]
assert "pytest" in event["modules"]
sentry-python-1.39.2/tests/integrations/opentelemetry/ 0000775 0000000 0000000 00000000000 14547447232 0023231 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/opentelemetry/__init__.py 0000664 0000000 0000000 00000000064 14547447232 0025342 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("opentelemetry")
sentry-python-1.39.2/tests/integrations/opentelemetry/test_experimental.py 0000664 0000000 0000000 00000001741 14547447232 0027342 0 ustar 00root root 0000000 0000000 try:
# python 3.3 and above
from unittest.mock import MagicMock
except ImportError:
# python < 3.3
from mock import MagicMock
from sentry_sdk.integrations.opentelemetry.integration import OpenTelemetryIntegration
def test_integration_enabled_if_option_is_on(sentry_init):
OpenTelemetryIntegration.setup_once = MagicMock()
sentry_init(
_experiments={
"otel_powered_performance": True,
}
)
OpenTelemetryIntegration.setup_once.assert_called_once()
def test_integration_not_enabled_if_option_is_off(sentry_init):
OpenTelemetryIntegration.setup_once = MagicMock()
sentry_init(
_experiments={
"otel_powered_performance": False,
}
)
OpenTelemetryIntegration.setup_once.assert_not_called()
def test_integration_not_enabled_if_option_is_missing(sentry_init):
OpenTelemetryIntegration.setup_once = MagicMock()
sentry_init()
OpenTelemetryIntegration.setup_once.assert_not_called()
sentry-python-1.39.2/tests/integrations/opentelemetry/test_propagator.py 0000664 0000000 0000000 00000017417 14547447232 0027032 0 ustar 00root root 0000000 0000000 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.get_span_context.return_value = 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.get_span_context.return_value = 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.get_span_context.return_value = 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(),
)
sentry-python-1.39.2/tests/integrations/opentelemetry/test_span_processor.py 0000664 0000000 0000000 00000043243 14547447232 0027710 0 ustar 00root root 0000000 0000000 from datetime import datetime
from datetime import timezone
import time
import pytest
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, Status, StatusCode
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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"] == "/"
@pytest.mark.parametrize(
"otel_status, expected_status",
[
pytest.param(Status(StatusCode.UNSET), None, id="unset"),
pytest.param(Status(StatusCode.OK), "ok", id="ok"),
pytest.param(Status(StatusCode.ERROR), "internal_error", id="error"),
],
)
def test_update_span_with_otel_status(otel_status, expected_status):
sentry_span = Span()
otel_span = MagicMock()
otel_span.name = "Test OTel Span"
otel_span.kind = SpanKind.INTERNAL
otel_span.status = otel_status
span_processor = SentrySpanProcessor()
span_processor._update_span_with_otel_status(sentry_span, otel_span)
assert sentry_span.get_trace_context().get("status") == expected_status
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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, timezone.utc
),
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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, timezone.utc
),
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()
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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.status = Status(StatusCode.OK)
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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.set_status.assert_called_once_with("ok")
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.status = Status(StatusCode.OK)
span_context = SpanContext(
trace_id=int("1234567890abcdef1234567890abcdef", 16),
span_id=int("1234567890abcdef", 16),
is_remote=True,
)
otel_span.get_span_context.return_value = span_context
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.set_status.assert_called_once_with("ok")
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"}
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
sentry-python-1.39.2/tests/integrations/pure_eval/ 0000775 0000000 0000000 00000000000 14547447232 0022317 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/pure_eval/__init__.py 0000664 0000000 0000000 00000000060 14547447232 0024424 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("pure_eval")
sentry-python-1.39.2/tests/integrations/pure_eval/test_pure_eval.py 0000664 0000000 0000000 00000004615 14547447232 0025720 0 ustar 00root root 0000000 0000000 import sys
from types import SimpleNamespace
import pytest
from sentry_sdk import capture_exception, serializer
from sentry_sdk.integrations.pure_eval import PureEvalIntegration
@pytest.mark.parametrize("integrations", [[], [PureEvalIntegration()]])
def test_include_local_variables_enabled(sentry_init, capture_events, integrations):
sentry_init(include_local_variables=True, integrations=integrations)
events = capture_events()
def foo():
namespace = SimpleNamespace()
q = 1
w = 2
e = 3
r = 4
t = 5
y = 6
u = 7
i = 8
o = 9
p = 10
a = 11
s = 12
str((q, w, e, r, t, y, u, i, o, p, a, s)) # use variables for linter
namespace.d = {1: 2}
print(namespace.d[1] / 0)
# Appearances of variables after the main statement don't affect order
print(q)
print(s)
print(events)
try:
foo()
except Exception:
capture_exception()
(event,) = events
assert all(
frame["vars"]
for frame in event["exception"]["values"][0]["stacktrace"]["frames"]
)
frame_vars = event["exception"]["values"][0]["stacktrace"]["frames"][-1]["vars"]
if integrations:
# Values closest to the exception line appear first
# Test this order if possible given the Python version and dict order
expected_keys = [
"namespace",
"namespace.d",
"namespace.d[1]",
"s",
"a",
"p",
"o",
"i",
"u",
"y",
]
if sys.version_info[:2] == (3, 5):
assert frame_vars.keys() == set(expected_keys)
else:
assert list(frame_vars.keys()) == expected_keys
assert frame_vars["namespace.d"] == {"1": "2"}
assert frame_vars["namespace.d[1]"] == "2"
else:
# Without pure_eval, the variables are unpredictable.
# In later versions, those at the top appear first and are thus included
assert frame_vars.keys() <= {
"namespace",
"q",
"w",
"e",
"r",
"t",
"y",
"u",
"i",
"o",
"p",
"a",
"s",
"events",
}
assert len(frame_vars) == serializer.MAX_DATABAG_BREADTH
sentry-python-1.39.2/tests/integrations/pymongo/ 0000775 0000000 0000000 00000000000 14547447232 0022025 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/pymongo/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024137 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("pymongo")
sentry-python-1.39.2/tests/integrations/pymongo/test_pymongo.py 0000664 0000000 0000000 00000034131 14547447232 0025130 0 ustar 00root root 0000000 0000000 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"
assert span["data"][SPANDATA.DB_NAME] == "test_db"
assert span["data"][SPANDATA.SERVER_ADDRESS] == "localhost"
assert span["data"][SPANDATA.SERVER_PORT] == mongo_server.port
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"]
sentry-python-1.39.2/tests/integrations/pyramid/ 0000775 0000000 0000000 00000000000 14547447232 0022002 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/pyramid/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024114 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("pyramid")
sentry-python-1.39.2/tests/integrations/pyramid/test_pyramid.py 0000664 0000000 0000000 00000025500 14547447232 0025062 0 ustar 00root root 0000000 0000000 import json
import logging
from io import BytesIO
import pyramid.testing
import pytest
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.response import Response
from werkzeug.test import Client
from sentry_sdk import capture_message, add_breadcrumb
from sentry_sdk.integrations.pyramid import PyramidIntegration
from sentry_sdk.serializer import MAX_DATABAG_BREADTH
from tests.conftest import unpack_werkzeug_response
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):
capture_message("hi")
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()
@pytest.fixture
def route(pyramid_config):
def inner(url):
def wrapper(f):
pyramid_config.add_route(f.__name__, url)
pyramid_config.add_view(f, route_name=f.__name__)
return f
return wrapper
return inner
@pytest.fixture
def get_client(pyramid_config):
def inner():
return Client(pyramid_config.make_wsgi_app())
return inner
def test_view_exceptions(
get_client, route, sentry_init, capture_events, capture_exceptions
):
sentry_init(integrations=[PyramidIntegration()])
events = capture_events()
exceptions = capture_exceptions()
add_breadcrumb({"message": "hi"})
@route("/errors")
def errors(request):
add_breadcrumb({"message": "hi2"})
1 / 0
client = get_client()
with pytest.raises(ZeroDivisionError):
client.get("/errors")
(error,) = exceptions
assert isinstance(error, ZeroDivisionError)
(event,) = events
(breadcrumb,) = event["breadcrumbs"]["values"]
assert breadcrumb["message"] == "hi2"
# 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("/context_message/{msg}")
def hi2(request):
capture_message(request.matchdict["msg"])
return Response("hi")
client = get_client()
client.get("/context_message/yoo")
(event,) = events
assert event["message"] == "yoo"
assert event["request"] == {
"env": {"SERVER_NAME": "localhost", "SERVER_PORT": "80"},
"headers": {"Host": "localhost"},
"method": "GET",
"query_string": "",
"url": "http://localhost/context_message/yoo",
}
assert event["transaction"] == "hi2"
@pytest.mark.parametrize(
"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,
url,
transaction_style,
expected_transaction,
expected_source,
):
sentry_init(integrations=[PyramidIntegration(transaction_style=transaction_style)])
events = capture_events()
client = get_client()
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):
sentry_init(integrations=[PyramidIntegration()])
data = {"foo": {"bar": "a" * 2000}}
@route("/")
def index(request):
assert request.json == data
assert request.text == json.dumps(data)
assert not request.POST
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["_meta"]["request"]["data"]["foo"]["bar"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]["bar"]) == 1024
@pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"])
def test_flask_empty_json_request(sentry_init, capture_events, route, get_client, data):
sentry_init(integrations=[PyramidIntegration()])
@route("/")
def index(request):
assert request.json == data
assert request.text == json.dumps(data)
assert not request.POST
capture_message("hi")
return Response("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
def test_json_not_truncated_if_max_request_body_size_is_always(
sentry_init, capture_events, route, get_client
):
sentry_init(integrations=[PyramidIntegration()], max_request_body_size="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()], max_request_body_size="always")
data = {"foo": "a" * 2000, "file": (BytesIO(b"hello"), "hello.txt")}
@route("/")
def index(request):
capture_message("hi")
return Response("ok")
events = capture_events()
client = get_client()
client.post("/", data=data)
(event,) = events
assert event["_meta"]["request"]["data"]["foo"] == {
"": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]}
}
assert len(event["request"]["data"]["foo"]) == 1024
assert event["_meta"]["request"]["data"]["file"] == {"": {"rem": [["!raw", "x"]]}}
assert not event["request"]["data"]["file"]
def test_bad_request_not_captured(
sentry_init, pyramid_config, capture_events, route, get_client
):
import pyramid.httpexceptions as exc
sentry_init(integrations=[PyramidIntegration()])
events = capture_events()
@route("/")
def index(request):
raise exc.HTTPBadRequest()
def errorhandler(exc, request):
return Response("bad request")
pyramid_config.add_view(errorhandler, context=exc.HTTPBadRequest)
client = get_client()
client.get("/")
assert not events
def test_errorhandler_ok(
sentry_init, pyramid_config, capture_exceptions, route, get_client
):
sentry_init(integrations=[PyramidIntegration()])
errors = capture_exceptions()
@route("/")
def index(request):
raise Exception()
def errorhandler(exc, request):
return Response("bad request")
pyramid_config.add_view(errorhandler, context=Exception)
client = get_client()
client.get("/")
assert not errors
@pytest.mark.skipif(
PYRAMID_VERSION < (1, 9),
reason="We don't have the right hooks in older Pyramid versions",
)
def test_errorhandler_500(
sentry_init, pyramid_config, capture_exceptions, route, get_client
):
sentry_init(integrations=[PyramidIntegration()])
errors = capture_exceptions()
@route("/")
def index(request):
1 / 0
def errorhandler(exc, request):
return Response("bad request", status=500)
pyramid_config.add_view(errorhandler, context=Exception)
client = get_client()
app_iter, status, headers = unpack_werkzeug_response(client.get("/"))
assert app_iter == b"bad request"
assert status.lower() == "500 internal server error"
(error,) = errors
assert isinstance(error, ZeroDivisionError)
def test_error_in_errorhandler(
sentry_init, pyramid_config, capture_events, route, get_client
):
sentry_init(integrations=[PyramidIntegration()])
@route("/")
def index(request):
raise ValueError()
def error_handler(err, request):
1 / 0
pyramid_config.add_view(error_handler, context=ValueError)
events = capture_events()
client = get_client()
with pytest.raises(ZeroDivisionError):
client.get("/")
(event,) = events
exception = event["exception"]["values"][-1]
assert exception["type"] == "ZeroDivisionError"
def test_error_in_authenticated_userid(
sentry_init, pyramid_config, capture_events, route, get_client
):
from sentry_sdk.integrations.logging import LoggingIntegration
sentry_init(
send_default_pii=True,
integrations=[
PyramidIntegration(),
LoggingIntegration(event_level=logging.ERROR),
],
)
logger = logging.getLogger("test_pyramid")
class AuthenticationPolicy(object):
def authenticated_userid(self, request):
logger.error("failed to identify user")
pyramid_config.set_authorization_policy(ACLAuthorizationPolicy())
pyramid_config.set_authentication_policy(AuthenticationPolicy())
events = capture_events()
client = get_client()
client.get("/message")
assert len(events) == 1
def tween_factory(handler, registry):
def tween(request):
try:
response = handler(request)
except Exception:
mroute = request.matched_route
if mroute and mroute.name in ("index",):
return Response("bad request", status_code=400)
return response
return tween
def test_tween_ok(sentry_init, pyramid_config, capture_exceptions, route, get_client):
sentry_init(integrations=[PyramidIntegration()])
errors = capture_exceptions()
@route("/")
def index(request):
raise Exception()
pyramid_config.add_tween(
"tests.integrations.pyramid.test_pyramid.tween_factory",
under=pyramid.tweens.INGRESS,
)
client = get_client()
client.get("/")
assert not errors
sentry-python-1.39.2/tests/integrations/quart/ 0000775 0000000 0000000 00000000000 14547447232 0021471 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/quart/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0023601 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("quart")
sentry-python-1.39.2/tests/integrations/quart/test_quart.py 0000664 0000000 0000000 00000034314 14547447232 0024243 0 ustar 00root root 0000000 0000000 import json
import threading
import pytest
import pytest_asyncio
from sentry_sdk import (
set_tag,
configure_scope,
capture_message,
capture_exception,
last_event_id,
)
from sentry_sdk.integrations.logging import LoggingIntegration
import sentry_sdk.integrations.quart as quart_sentry
from quart import Quart, Response, abort, stream_with_context
from quart.views import View
from quart_auth import AuthUser, login_user
try:
from quart_auth import QuartAuth
auth_manager = QuartAuth()
except ImportError:
from quart_auth import AuthManager
auth_manager = AuthManager()
@pytest_asyncio.fixture
async def app():
app = Quart(__name__)
app.debug = False
app.config["TESTING"] = False
app.secret_key = "haha"
auth_manager.init_app(app)
@app.route("/message")
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
@pytest.fixture(params=("manual",))
def integration_enabled_params(request):
if request.param == "manual":
return {"integrations": [quart_sentry.QuartIntegration()]}
else:
raise ValueError(request.param)
@pytest.mark.asyncio
async def test_has_context(sentry_init, app, capture_events):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
client = app.test_client()
response = await client.get("/message")
assert response.status_code == 200
(event,) = events
assert event["transaction"] == "hi"
assert "data" not in event["request"]
assert event["request"]["url"] == "http://localhost/message"
@pytest.mark.asyncio
@pytest.mark.parametrize(
"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,
url,
transaction_style,
expected_transaction,
expected_source,
):
sentry_init(
integrations=[
quart_sentry.QuartIntegration(transaction_style=transaction_style)
]
)
events = capture_events()
client = app.test_client()
response = await client.get(url)
assert response.status_code == 200
(event,) = events
assert event["transaction"] == expected_transaction
@pytest.mark.asyncio
async def test_errors(
sentry_init,
capture_exceptions,
capture_events,
app,
integration_enabled_params,
):
sentry_init(debug=True, **integration_enabled_params)
@app.route("/")
async def index():
1 / 0
exceptions = capture_exceptions()
events = capture_events()
client = app.test_client()
try:
await client.get("/")
except ZeroDivisionError:
pass
(exc,) = exceptions
assert isinstance(exc, ZeroDivisionError)
(event,) = events
assert event["exception"]["values"][0]["mechanism"]["type"] == "quart"
@pytest.mark.asyncio
async def test_quart_auth_not_installed(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
monkeypatch.setattr(quart_sentry, "quart_auth", None)
events = capture_events()
client = app.test_client()
await client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
@pytest.mark.asyncio
async def test_quart_auth_not_configured(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
assert quart_sentry.quart_auth
events = capture_events()
client = app.test_client()
await client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
@pytest.mark.asyncio
async def test_quart_auth_partially_configured(
sentry_init, app, capture_events, monkeypatch, integration_enabled_params
):
sentry_init(**integration_enabled_params)
events = capture_events()
client = app.test_client()
await client.get("/message")
(event,) = events
assert event.get("user", {}).get("id") is None
@pytest.mark.asyncio
@pytest.mark.parametrize("send_default_pii", [True, False])
@pytest.mark.parametrize("user_id", [None, "42", "3"])
async def test_quart_auth_configured(
send_default_pii,
sentry_init,
app,
user_id,
capture_events,
monkeypatch,
integration_enabled_params,
):
sentry_init(send_default_pii=send_default_pii, **integration_enabled_params)
@app.route("/login")
async def login():
if user_id is not None:
login_user(AuthUser(user_id))
return "ok"
events = capture_events()
client = app.test_client()
assert (await client.get("/login")).status_code == 200
assert not events
assert (await client.get("/message")).status_code == 200
(event,) = events
if user_id is None or not send_default_pii:
assert event.get("user", {}).get("id") is None
else:
assert event["user"]["id"] == str(user_id)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"integrations",
[
[quart_sentry.QuartIntegration()],
[quart_sentry.QuartIntegration(), LoggingIntegration(event_level="ERROR")],
],
)
async def test_errors_not_reported_twice(
sentry_init, integrations, capture_events, app
):
sentry_init(integrations=integrations)
@app.route("/")
async def index():
try:
1 / 0
except Exception as e:
app.logger.exception(e)
raise e
events = capture_events()
client = app.test_client()
# with pytest.raises(ZeroDivisionError):
await client.get("/")
assert len(events) == 1
@pytest.mark.asyncio
async def test_logging(sentry_init, capture_events, app):
# ensure that Quart's logger magic doesn't break ours
sentry_init(
integrations=[
quart_sentry.QuartIntegration(),
LoggingIntegration(event_level="ERROR"),
]
)
@app.route("/")
async def index():
app.logger.error("hi")
return "ok"
events = capture_events()
client = app.test_client()
await client.get("/")
(event,) = events
assert event["level"] == "error"
@pytest.mark.asyncio
async def test_no_errors_without_request(app, sentry_init):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
async with app.app_context():
capture_exception(ValueError())
def test_cli_commands_raise(app):
if not hasattr(app, "cli"):
pytest.skip("Too old quart version")
from quart.cli import ScriptInfo
@app.cli.command()
def foo():
1 / 0
with pytest.raises(ZeroDivisionError):
app.cli.main(
args=["foo"], prog_name="myapp", obj=ScriptInfo(create_app=lambda _: app)
)
@pytest.mark.asyncio
async def test_500(sentry_init, capture_events, app):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
@app.route("/")
async def index():
1 / 0
@app.errorhandler(500)
async def error_handler(err):
return "Sentry error: %s" % last_event_id()
events = capture_events()
client = app.test_client()
response = await client.get("/")
(event,) = events
assert (await response.get_data(as_text=True)) == "Sentry error: %s" % event[
"event_id"
]
@pytest.mark.asyncio
async def test_error_in_errorhandler(sentry_init, capture_events, app):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
@app.route("/")
async def index():
raise ValueError()
@app.errorhandler(500)
async def error_handler(err):
1 / 0
events = capture_events()
client = app.test_client()
with pytest.raises(ZeroDivisionError):
await client.get("/")
event1, event2 = events
(exception,) = event1["exception"]["values"]
assert exception["type"] == "ValueError"
exception = event2["exception"]["values"][-1]
assert exception["type"] == "ZeroDivisionError"
@pytest.mark.asyncio
async def test_bad_request_not_captured(sentry_init, capture_events, app):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
@app.route("/")
async def index():
abort(400)
client = app.test_client()
await client.get("/")
assert not events
@pytest.mark.asyncio
async def test_does_not_leak_scope(sentry_init, capture_events, app):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
with configure_scope() as scope:
scope.set_tag("request_data", False)
@app.route("/")
async def index():
with configure_scope() as scope:
scope.set_tag("request_data", True)
async def generate():
for row in range(1000):
with configure_scope() as scope:
assert scope._tags["request_data"]
yield str(row) + "\n"
return Response(stream_with_context(generate)(), mimetype="text/csv")
client = app.test_client()
response = await client.get("/")
assert (await response.get_data(as_text=True)) == "".join(
str(row) + "\n" for row in range(1000)
)
assert not events
with configure_scope() as scope:
assert not scope._tags["request_data"]
@pytest.mark.asyncio
async def test_scoped_test_client(sentry_init, app):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
@app.route("/")
async def index():
return "ok"
async with app.test_client() as client:
response = await client.get("/")
assert response.status_code == 200
@pytest.mark.asyncio
@pytest.mark.parametrize("exc_cls", [ZeroDivisionError, Exception])
async def test_errorhandler_for_exception_swallows_exception(
sentry_init, app, capture_events, exc_cls
):
# In contrast to error handlers for a status code, error
# handlers for exceptions can swallow the exception (this is
# just how the Quart signal works)
sentry_init(integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
@app.route("/")
async def index():
1 / 0
@app.errorhandler(exc_cls)
async def zerodivision(e):
return "ok"
async with app.test_client() as client:
response = await client.get("/")
assert response.status_code == 200
assert not events
@pytest.mark.asyncio
async def test_tracing_success(sentry_init, capture_events, app):
sentry_init(traces_sample_rate=1.0, integrations=[quart_sentry.QuartIntegration()])
@app.before_request
async def _():
set_tag("before_request", "yes")
@app.route("/message_tx")
async def hi_tx():
set_tag("view", "yes")
capture_message("hi")
return "ok"
events = capture_events()
async with app.test_client() as client:
response = await client.get("/message_tx")
assert response.status_code == 200
message_event, transaction_event = events
assert transaction_event["type"] == "transaction"
assert transaction_event["transaction"] == "hi_tx"
assert transaction_event["tags"]["view"] == "yes"
assert transaction_event["tags"]["before_request"] == "yes"
assert message_event["message"] == "hi"
assert message_event["transaction"] == "hi_tx"
assert message_event["tags"]["view"] == "yes"
assert message_event["tags"]["before_request"] == "yes"
@pytest.mark.asyncio
async def test_tracing_error(sentry_init, capture_events, app):
sentry_init(traces_sample_rate=1.0, integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
@app.route("/error")
async def error():
1 / 0
async with app.test_client() as client:
response = await client.get("/error")
assert response.status_code == 500
error_event, transaction_event = events
assert transaction_event["type"] == "transaction"
assert transaction_event["transaction"] == "error"
assert error_event["transaction"] == "error"
(exception,) = error_event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
@pytest.mark.asyncio
async def test_class_based_views(sentry_init, app, capture_events):
sentry_init(integrations=[quart_sentry.QuartIntegration()])
events = capture_events()
@app.route("/")
class HelloClass(View):
methods = ["GET"]
async def dispatch_request(self):
capture_message("hi")
return "ok"
app.add_url_rule("/hello-class/", view_func=HelloClass.as_view("hello_class"))
async with app.test_client() as client:
response = await client.get("/hello-class/")
assert response.status_code == 200
(event,) = events
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"]
sentry-python-1.39.2/tests/integrations/redis/ 0000775 0000000 0000000 00000000000 14547447232 0021443 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/redis/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0023553 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("redis")
sentry-python-1.39.2/tests/integrations/redis/asyncio/ 0000775 0000000 0000000 00000000000 14547447232 0023110 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/redis/asyncio/__init__.py 0000664 0000000 0000000 00000000071 14547447232 0025217 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("fakeredis.aioredis")
sentry-python-1.39.2/tests/integrations/redis/asyncio/test_redis_asyncio.py 0000664 0000000 0000000 00000004413 14547447232 0027356 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk import capture_message, start_transaction
from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.redis import RedisIntegration
from fakeredis.aioredis import FakeRedis
@pytest.mark.asyncio
async def test_async_basic(sentry_init, capture_events):
sentry_init(integrations=[RedisIntegration()])
events = capture_events()
connection = FakeRedis()
await connection.get("foobar")
capture_message("hi")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
"data": {
"db.operation": "GET",
"redis.key": "foobar",
"redis.command": "GET",
"redis.is_cluster": False,
},
"timestamp": crumb["timestamp"],
"type": "redis",
}
@pytest.mark.parametrize(
"is_transaction, send_default_pii, expected_first_ten",
[
(False, False, ["GET 'foo'", "SET 'bar' [Filtered]", "SET 'baz' [Filtered]"]),
(True, True, ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"]),
],
)
@pytest.mark.asyncio
async def test_async_redis_pipeline(
sentry_init, capture_events, is_transaction, send_default_pii, expected_first_ten
):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
connection = FakeRedis()
with start_transaction():
pipeline = connection.pipeline(transaction=is_transaction)
pipeline.get("foo")
pipeline.set("bar", 1)
pipeline.set("baz", 2)
await 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": expected_first_ten,
},
SPANDATA.DB_SYSTEM: "redis",
SPANDATA.DB_NAME: "0",
SPANDATA.SERVER_ADDRESS: connection.connection_pool.connection_kwargs.get(
"host"
),
SPANDATA.SERVER_PORT: 6379,
}
assert span["tags"] == {
"redis.transaction": is_transaction,
"redis.is_cluster": False,
}
sentry-python-1.39.2/tests/integrations/redis/cluster/ 0000775 0000000 0000000 00000000000 14547447232 0023124 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/redis/cluster/__init__.py 0000664 0000000 0000000 00000000064 14547447232 0025235 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("redis.cluster")
sentry-python-1.39.2/tests/integrations/redis/cluster/test_redis_cluster.py 0000664 0000000 0000000 00000010307 14547447232 0027405 0 ustar 00root root 0000000 0000000 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 redis
@pytest.fixture(autouse=True)
def monkeypatch_rediscluster_class(reset_integrations):
pipeline_cls = redis.cluster.ClusterPipeline
redis.cluster.NodesManager.initialize = lambda *_, **__: None
redis.RedisCluster.command = lambda *_: []
redis.RedisCluster.pipeline = lambda *_, **__: pipeline_cls(None, None)
redis.RedisCluster.get_default_node = lambda *_, **__: redis.cluster.ClusterNode(
"localhost", 6379
)
pipeline_cls.execute = lambda *_, **__: None
redis.RedisCluster.execute_command = lambda *_, **__: []
def test_rediscluster_breadcrumb(sentry_init, capture_events):
sentry_init(integrations=[RedisIntegration()])
events = capture_events()
rc = redis.RedisCluster(host="localhost", port=6379)
rc.get("foobar")
capture_message("hi")
(event,) = events
crumbs = event["breadcrumbs"]["values"]
# on initializing a RedisCluster, a COMMAND call is made - this is not important for the test
# but must be accounted for
assert len(crumbs) in (1, 2)
assert len(crumbs) == 1 or crumbs[0]["message"] == "COMMAND"
crumb = crumbs[-1]
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
"data": {
"db.operation": "GET",
"redis.key": "foobar",
"redis.command": "GET",
"redis.is_cluster": True,
},
"timestamp": crumb["timestamp"],
"type": "redis",
}
@pytest.mark.parametrize(
"send_default_pii, description",
[
(False, "SET 'bar' [Filtered]"),
(True, "SET 'bar' 1"),
],
)
def test_rediscluster_basic(sentry_init, capture_events, send_default_pii, description):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
with start_transaction():
rc = redis.RedisCluster(host="localhost", port=6379)
rc.set("bar", 1)
(event,) = events
spans = event["spans"]
# on initializing a RedisCluster, a COMMAND call is made - this is not important for the test
# but must be accounted for
assert len(spans) in (1, 2)
assert len(spans) == 1 or spans[0]["description"] == "COMMAND"
span = spans[-1]
assert span["op"] == "db.redis"
assert span["description"] == description
assert span["data"] == {
SPANDATA.DB_SYSTEM: "redis",
# ClusterNode converts localhost to 127.0.0.1
SPANDATA.SERVER_ADDRESS: "127.0.0.1",
SPANDATA.SERVER_PORT: 6379,
}
assert span["tags"] == {
"db.operation": "SET",
"redis.command": "SET",
"redis.is_cluster": True,
"redis.key": "bar",
}
@pytest.mark.parametrize(
"send_default_pii, expected_first_ten",
[
(False, ["GET 'foo'", "SET 'bar' [Filtered]", "SET 'baz' [Filtered]"]),
(True, ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"]),
],
)
def test_rediscluster_pipeline(
sentry_init, capture_events, send_default_pii, expected_first_ten
):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
rc = redis.RedisCluster(host="localhost", port=6379)
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": expected_first_ten,
},
SPANDATA.DB_SYSTEM: "redis",
# ClusterNode converts localhost to 127.0.0.1
SPANDATA.SERVER_ADDRESS: "127.0.0.1",
SPANDATA.SERVER_PORT: 6379,
}
assert span["tags"] == {
"redis.transaction": False, # For Cluster, this is always False
"redis.is_cluster": True,
}
sentry-python-1.39.2/tests/integrations/redis/cluster_asyncio/ 0000775 0000000 0000000 00000000000 14547447232 0024651 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/redis/cluster_asyncio/__init__.py 0000664 0000000 0000000 00000000074 14547447232 0026763 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("redis.asyncio.cluster")
sentry-python-1.39.2/tests/integrations/redis/cluster_asyncio/test_redis_cluster_asyncio.py 0000664 0000000 0000000 00000007624 14547447232 0032667 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk import capture_message, start_transaction
from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.redis import RedisIntegration
from redis.asyncio import cluster
async def fake_initialize(*_, **__):
return None
async def fake_execute_command(*_, **__):
return []
async def fake_execute(*_, **__):
return None
@pytest.fixture(autouse=True)
def monkeypatch_rediscluster_asyncio_class(reset_integrations):
pipeline_cls = cluster.ClusterPipeline
cluster.NodesManager.initialize = fake_initialize
cluster.RedisCluster.get_default_node = lambda *_, **__: cluster.ClusterNode(
"localhost", 6379
)
cluster.RedisCluster.pipeline = lambda self, *_, **__: pipeline_cls(self)
pipeline_cls.execute = fake_execute
cluster.RedisCluster.execute_command = fake_execute_command
@pytest.mark.asyncio
async def test_async_breadcrumb(sentry_init, capture_events):
sentry_init(integrations=[RedisIntegration()])
events = capture_events()
connection = cluster.RedisCluster(host="localhost", port=6379)
await connection.get("foobar")
capture_message("hi")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
"data": {
"db.operation": "GET",
"redis.key": "foobar",
"redis.command": "GET",
"redis.is_cluster": True,
},
"timestamp": crumb["timestamp"],
"type": "redis",
}
@pytest.mark.parametrize(
"send_default_pii, description",
[
(False, "SET 'bar' [Filtered]"),
(True, "SET 'bar' 1"),
],
)
@pytest.mark.asyncio
async def test_async_basic(sentry_init, capture_events, send_default_pii, description):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
connection = cluster.RedisCluster(host="localhost", port=6379)
with start_transaction():
await connection.set("bar", 1)
(event,) = events
(span,) = event["spans"]
assert span["op"] == "db.redis"
assert span["description"] == description
assert span["data"] == {
SPANDATA.DB_SYSTEM: "redis",
# ClusterNode converts localhost to 127.0.0.1
SPANDATA.SERVER_ADDRESS: "127.0.0.1",
SPANDATA.SERVER_PORT: 6379,
}
assert span["tags"] == {
"redis.is_cluster": True,
"db.operation": "SET",
"redis.command": "SET",
"redis.key": "bar",
}
@pytest.mark.parametrize(
"send_default_pii, expected_first_ten",
[
(False, ["GET 'foo'", "SET 'bar' [Filtered]", "SET 'baz' [Filtered]"]),
(True, ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"]),
],
)
@pytest.mark.asyncio
async def test_async_redis_pipeline(
sentry_init, capture_events, send_default_pii, expected_first_ten
):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
connection = cluster.RedisCluster(host="localhost", port=6379)
with start_transaction():
pipeline = connection.pipeline()
pipeline.get("foo")
pipeline.set("bar", 1)
pipeline.set("baz", 2)
await 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": expected_first_ten,
},
SPANDATA.DB_SYSTEM: "redis",
# ClusterNode converts localhost to 127.0.0.1
SPANDATA.SERVER_ADDRESS: "127.0.0.1",
SPANDATA.SERVER_PORT: 6379,
}
assert span["tags"] == {
"redis.transaction": False,
"redis.is_cluster": True,
}
sentry-python-1.39.2/tests/integrations/redis/test_redis.py 0000664 0000000 0000000 00000021476 14547447232 0024174 0 ustar 00root root 0000000 0000000 import pytest
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
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
MOCK_CONNECTION_POOL = mock.MagicMock()
MOCK_CONNECTION_POOL.connection_kwargs = {
"host": "localhost",
"port": 63791,
"db": 1,
}
def test_basic(sentry_init, capture_events):
sentry_init(integrations=[RedisIntegration()])
events = capture_events()
connection = FakeStrictRedis()
connection.get("foobar")
capture_message("hi")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
"data": {
"redis.key": "foobar",
"redis.command": "GET",
"redis.is_cluster": False,
"db.operation": "GET",
},
"timestamp": crumb["timestamp"],
"type": "redis",
}
@pytest.mark.parametrize(
"is_transaction, send_default_pii, expected_first_ten",
[
(False, False, ["GET 'foo'", "SET 'bar' [Filtered]", "SET 'baz' [Filtered]"]),
(True, True, ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"]),
],
)
def test_redis_pipeline(
sentry_init, capture_events, is_transaction, send_default_pii, expected_first_ten
):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
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"][SPANDATA.DB_SYSTEM] == "redis"
assert span["data"]["redis.commands"] == {
"count": 3,
"first_ten": expected_first_ten,
}
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"],
}
def test_db_connection_attributes_client(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1.0,
integrations=[RedisIntegration()],
)
events = capture_events()
with start_transaction():
connection = FakeStrictRedis(connection_pool=MOCK_CONNECTION_POOL)
connection.get("foobar")
(event,) = events
(span,) = event["spans"]
assert span["op"] == "db.redis"
assert span["description"] == "GET 'foobar'"
assert span["data"][SPANDATA.DB_SYSTEM] == "redis"
assert span["data"][SPANDATA.DB_NAME] == "1"
assert span["data"][SPANDATA.SERVER_ADDRESS] == "localhost"
assert span["data"][SPANDATA.SERVER_PORT] == 63791
def test_db_connection_attributes_pipeline(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1.0,
integrations=[RedisIntegration()],
)
events = capture_events()
with start_transaction():
connection = FakeStrictRedis(connection_pool=MOCK_CONNECTION_POOL)
pipeline = connection.pipeline(transaction=False)
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"][SPANDATA.DB_SYSTEM] == "redis"
assert span["data"][SPANDATA.DB_NAME] == "1"
assert span["data"][SPANDATA.SERVER_ADDRESS] == "localhost"
assert span["data"][SPANDATA.SERVER_PORT] == 63791
sentry-python-1.39.2/tests/integrations/rediscluster/ 0000775 0000000 0000000 00000000000 14547447232 0023045 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/rediscluster/__init__.py 0000664 0000000 0000000 00000000063 14547447232 0025155 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("rediscluster")
sentry-python-1.39.2/tests/integrations/rediscluster/test_rediscluster.py 0000664 0000000 0000000 00000011222 14547447232 0027164 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk import capture_message
from sentry_sdk.api import start_transaction
from sentry_sdk.consts import SPANDATA
from sentry_sdk.integrations.redis import RedisIntegration
try:
from unittest import mock
except ImportError:
import mock
import rediscluster
MOCK_CONNECTION_POOL = mock.MagicMock()
MOCK_CONNECTION_POOL.connection_kwargs = {
"host": "localhost",
"port": 63791,
"db": 1,
}
rediscluster_classes = [rediscluster.RedisCluster]
if hasattr(rediscluster, "StrictRedisCluster"):
rediscluster_classes.append(rediscluster.StrictRedisCluster)
@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=MOCK_CONNECTION_POOL
)
pipeline_cls.execute = lambda *_, **__: None
for cls in rediscluster_classes:
cls.execute_command = lambda *_, **__: None
@pytest.mark.parametrize("rediscluster_cls", rediscluster_classes)
def test_rediscluster_basic(rediscluster_cls, sentry_init, capture_events):
sentry_init(integrations=[RedisIntegration()])
events = capture_events()
rc = rediscluster_cls(connection_pool=MOCK_CONNECTION_POOL)
rc.get("foobar")
capture_message("hi")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
assert crumb == {
"category": "redis",
"message": "GET 'foobar'",
"data": {
"db.operation": "GET",
"redis.key": "foobar",
"redis.command": "GET",
"redis.is_cluster": True,
},
"timestamp": crumb["timestamp"],
"type": "redis",
}
@pytest.mark.parametrize(
"send_default_pii, expected_first_ten",
[
(False, ["GET 'foo'", "SET 'bar' [Filtered]", "SET 'baz' [Filtered]"]),
(True, ["GET 'foo'", "SET 'bar' 1", "SET 'baz' 2"]),
],
)
def test_rediscluster_pipeline(
sentry_init, capture_events, send_default_pii, expected_first_ten
):
sentry_init(
integrations=[RedisIntegration()],
traces_sample_rate=1.0,
send_default_pii=send_default_pii,
)
events = capture_events()
rc = rediscluster.RedisCluster(connection_pool=MOCK_CONNECTION_POOL)
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": expected_first_ten,
},
SPANDATA.DB_SYSTEM: "redis",
SPANDATA.DB_NAME: "1",
SPANDATA.SERVER_ADDRESS: "localhost",
SPANDATA.SERVER_PORT: 63791,
}
assert span["tags"] == {
"redis.transaction": False, # For Cluster, this is always False
"redis.is_cluster": True,
}
@pytest.mark.parametrize("rediscluster_cls", rediscluster_classes)
def test_db_connection_attributes_client(sentry_init, capture_events, rediscluster_cls):
sentry_init(
traces_sample_rate=1.0,
integrations=[RedisIntegration()],
)
events = capture_events()
rc = rediscluster_cls(connection_pool=MOCK_CONNECTION_POOL)
with start_transaction():
rc.get("foobar")
(event,) = events
(span,) = event["spans"]
assert span["data"] == {
SPANDATA.DB_SYSTEM: "redis",
SPANDATA.DB_NAME: "1",
SPANDATA.SERVER_ADDRESS: "localhost",
SPANDATA.SERVER_PORT: 63791,
}
@pytest.mark.parametrize("rediscluster_cls", rediscluster_classes)
def test_db_connection_attributes_pipeline(
sentry_init, capture_events, rediscluster_cls
):
sentry_init(
traces_sample_rate=1.0,
integrations=[RedisIntegration()],
)
events = capture_events()
rc = rediscluster.RedisCluster(connection_pool=MOCK_CONNECTION_POOL)
with start_transaction():
pipeline = rc.pipeline()
pipeline.get("foo")
pipeline.execute()
(event,) = events
(span,) = event["spans"]
assert span["op"] == "db.redis"
assert span["description"] == "redis.pipeline.execute"
assert span["data"] == {
"redis.commands": {
"count": 1,
"first_ten": ["GET 'foo'"],
},
SPANDATA.DB_SYSTEM: "redis",
SPANDATA.DB_NAME: "1",
SPANDATA.SERVER_ADDRESS: "localhost",
SPANDATA.SERVER_PORT: 63791,
}
sentry-python-1.39.2/tests/integrations/requests/ 0000775 0000000 0000000 00000000000 14547447232 0022210 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/requests/__init__.py 0000664 0000000 0000000 00000000057 14547447232 0024323 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("requests")
sentry-python-1.39.2/tests/integrations/requests/test_requests.py 0000664 0000000 0000000 00000003235 14547447232 0025477 0 ustar 00root root 0000000 0000000 import requests
import responses
import pytest
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(url)
capture_message("Testing!")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
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: 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
}
sentry-python-1.39.2/tests/integrations/rq/ 0000775 0000000 0000000 00000000000 14547447232 0020757 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/rq/__init__.py 0000664 0000000 0000000 00000000051 14547447232 0023064 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("rq")
sentry-python-1.39.2/tests/integrations/rq/test_rq.py 0000664 0000000 0000000 00000020606 14547447232 0023016 0 ustar 00root root 0000000 0000000 import pytest
from fakeredis import FakeStrictRedis
from sentry_sdk import configure_scope, start_transaction
from sentry_sdk.integrations.rq import RqIntegration
from sentry_sdk.utils import parse_version
import rq
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
@pytest.fixture(autouse=True)
def _patch_rq_get_server_version(monkeypatch):
"""
Patch RQ lower than 1.5.1 to work with fakeredis.
https://github.com/jamesls/fakeredis/issues/273
"""
from distutils.version import StrictVersion
if parse_version(rq.VERSION) <= (1, 5, 1):
for k in (
"rq.job.Job.get_redis_server_version",
"rq.worker.Worker.get_redis_server_version",
):
try:
monkeypatch.setattr(k, lambda _: StrictVersion("4.0.0"))
except AttributeError:
# old RQ Job/Worker doesn't have a get_redis_server_version attr
pass
def crashing_job(foo):
1 / 0
def chew_up_shoes(dog, human, shoes):
raise Exception("{}!! Why did you eat {}'s {}??".format(dog, human, shoes))
def do_trick(dog, trick):
return "{}, can you {}? Good dog!".format(dog, trick)
def test_basic(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=42)
worker.work(burst=True)
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "rq"
assert exception["stacktrace"]["frames"][-1]["vars"]["foo"] == "42"
assert event["transaction"] == "tests.integrations.rq.test_rq.crashing_job"
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):
sentry_init(integrations=[RqIntegration()])
events = capture_events_forksafe()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.Worker([queue], connection=queue.connection)
queue.enqueue(crashing_job, foo=42)
worker.work(burst=True)
event = events.read_event()
events.read_flush()
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
def test_transaction_with_error(
sentry_init, capture_events, DictionaryContaining # noqa:N803
):
sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(chew_up_shoes, "Charlie", "Katie", shoes="flip-flops")
worker.work(burst=True)
error_event, envelope = events
assert error_event["transaction"] == "tests.integrations.rq.test_rq.chew_up_shoes"
assert error_event["contexts"]["trace"]["op"] == "queue.task.rq"
assert error_event["exception"]["values"][0]["type"] == "Exception"
assert (
error_event["exception"]["values"][0]["value"]
== "Charlie!! Why did you eat Katie's flip-flops??"
)
assert envelope["type"] == "transaction"
assert envelope["contexts"]["trace"] == error_event["contexts"]["trace"]
assert envelope["transaction"] == error_event["transaction"]
assert envelope["extra"]["rq-job"] == DictionaryContaining(
{
"args": ["Charlie", "Katie"],
"kwargs": {"shoes": "flip-flops"},
"func": "tests.integrations.rq.test_rq.chew_up_shoes",
"description": "tests.integrations.rq.test_rq.chew_up_shoes('Charlie', 'Katie', shoes='flip-flops')",
}
)
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
):
sentry_init(integrations=[RqIntegration()], traces_sample_rate=1.0)
events = capture_events()
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(do_trick, "Maisey", trick="kangaroo")
worker.work(burst=True)
envelope = events[0]
assert envelope["type"] == "transaction"
assert envelope["contexts"]["trace"]["op"] == "queue.task.rq"
assert envelope["transaction"] == "tests.integrations.rq.test_rq.do_trick"
assert envelope["extra"]["rq-job"] == DictionaryContaining(
{
"args": ["Maisey"],
"kwargs": {"trick": "kangaroo"},
"func": "tests.integrations.rq.test_rq.do_trick",
"description": "tests.integrations.rq.test_rq.do_trick('Maisey', trick='kangaroo')",
}
)
def test_traces_sampler_gets_correct_values_in_sampling_context(
sentry_init, DictionaryContaining, ObjectDescribedBy # noqa:N803
):
traces_sampler = mock.Mock(return_value=True)
sentry_init(integrations=[RqIntegration()], traces_sampler=traces_sampler)
queue = rq.Queue(connection=FakeStrictRedis())
worker = rq.SimpleWorker([queue], connection=queue.connection)
queue.enqueue(do_trick, "Bodhi", trick="roll over")
worker.work(burst=True)
traces_sampler.assert_any_call(
DictionaryContaining(
{
"rq_job": ObjectDescribedBy(
type=rq.job.Job,
attrs={
"description": "tests.integrations.rq.test_rq.do_trick('Bodhi', trick='roll over')",
"result": "Bodhi, can you roll over? Good dog!",
"func_name": "tests.integrations.rq.test_rq.do_trick",
"args": ("Bodhi",),
"kwargs": {"trick": "roll over"},
},
),
}
)
)
@pytest.mark.skipif(
parse_version(rq.__version__) < (1, 5), reason="At least rq-1.5 required"
)
def test_job_with_retries(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=42, retry=rq.Retry(max=1))
worker.work(burst=True)
assert len(events) == 1
sentry-python-1.39.2/tests/integrations/sanic/ 0000775 0000000 0000000 00000000000 14547447232 0021432 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/sanic/__init__.py 0000664 0000000 0000000 00000000054 14547447232 0023542 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("sanic")
sentry-python-1.39.2/tests/integrations/sanic/test_sanic.py 0000664 0000000 0000000 00000032302 14547447232 0024140 0 ustar 00root root 0000000 0000000 import asyncio
import contextlib
import os
import random
import sys
from unittest.mock import Mock
import pytest
from sentry_sdk import capture_message, configure_scope
from sentry_sdk.integrations.sanic import SanicIntegration
from sentry_sdk.tracing import TRANSACTION_SOURCE_COMPONENT, TRANSACTION_SOURCE_URL
from sanic import Sanic, request, response, __version__ as SANIC_VERSION_RAW
from sanic.response import HTTPResponse
from sanic.exceptions import SanicException
try:
from sanic_testing import TestManager
except ImportError:
TestManager = None
try:
from sanic_testing.reusable import ReusableClient
except ImportError:
ReusableClient = None
from sentry_sdk._types import TYPE_CHECKING
if TYPE_CHECKING:
from collections.abc import Iterable, Container
from typing import Any, Optional
SANIC_VERSION = tuple(map(int, SANIC_VERSION_RAW.split(".")))
PERFORMANCE_SUPPORTED = SANIC_VERSION >= (21, 9)
@pytest.fixture
def app():
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
sanic_app = Sanic("Test", register=False)
else:
sanic_app = Sanic("Test")
if TestManager is not None:
TestManager(sanic_app)
@sanic_app.route("/message")
def hi(request):
capture_message("hi")
return response.text("ok")
@sanic_app.route("/message/")
def hi_with_id(request, message_id):
capture_message("hi with id")
return response.text("ok with id")
@sanic_app.route("/500")
def fivehundred(_):
1 / 0
return sanic_app
def get_client(app):
@contextlib.contextmanager
def simple_client(app):
yield app.test_client
if ReusableClient is not None:
return ReusableClient(app)
else:
return simple_client(app)
def test_request_data(sentry_init, app, capture_events):
sentry_init(integrations=[SanicIntegration()])
events = capture_events()
c = get_client(app)
with c as client:
_, response = client.get("/message?foo=bar")
assert response.status == 200
(event,) = events
assert event["transaction"] == "hi"
assert event["request"]["env"] == {"REMOTE_ADDR": ""}
assert set(event["request"]["headers"]) >= {
"accept",
"accept-encoding",
"host",
"user-agent",
}
assert event["request"]["query_string"] == "foo=bar"
assert event["request"]["url"].endswith("/message")
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
@pytest.mark.parametrize(
"url,expected_transaction,expected_source",
[
("/message", "hi", "component"),
("/message/123456", "hi_with_id", "component"),
],
)
def test_transaction_name(
sentry_init, app, capture_events, url, expected_transaction, expected_source
):
sentry_init(integrations=[SanicIntegration()])
events = capture_events()
c = get_client(app)
with c as client:
_, response = 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()
@app.route("/error")
def myerror(request):
raise ValueError("oh no")
c = get_client(app)
with c as client:
_, response = client.get("/error")
assert response.status == 500
(event,) = events
assert event["transaction"] == "myerror"
(exception,) = event["exception"]["values"]
assert exception["type"] == "ValueError"
assert exception["value"] == "oh no"
assert any(
frame["filename"].endswith("test_sanic.py")
for frame in exception["stacktrace"]["frames"]
)
def test_bad_request_not_captured(sentry_init, app, capture_events):
sentry_init(integrations=[SanicIntegration()])
events = capture_events()
@app.route("/")
def index(request):
raise SanicException("...", status_code=400)
c = get_client(app)
with c as client:
_, response = client.get("/")
assert response.status == 400
assert not events
def test_error_in_errorhandler(sentry_init, app, capture_events):
sentry_init(integrations=[SanicIntegration()])
events = capture_events()
@app.route("/error")
def myerror(request):
raise ValueError("oh no")
@app.exception(ValueError)
def myhandler(request, exception):
1 / 0
c = get_client(app)
with c as client:
_, response = client.get("/error")
assert response.status == 500
event1, event2 = events
(exception,) = event1["exception"]["values"]
assert exception["type"] == "ValueError"
assert any(
frame["filename"].endswith("test_sanic.py")
for frame in exception["stacktrace"]["frames"]
)
exception = event2["exception"]["values"][-1]
assert exception["type"] == "ZeroDivisionError"
assert any(
frame["filename"].endswith("test_sanic.py")
for frame in exception["stacktrace"]["frames"]
)
def test_concurrency(sentry_init, app):
"""
Make sure we instrument Sanic in a way where request data does not leak
between request handlers. This test also implicitly tests our concept of
how async code should be instrumented, so if it breaks it likely has
ramifications for other async integrations and async usercode.
We directly call the request handler instead of using Sanic's test client
because that's the only way we could reproduce leakage with such a low
amount of concurrent tasks.
"""
sentry_init(integrations=[SanicIntegration()])
@app.route("/context-check/")
async def context_check(request, i):
with configure_scope() as scope:
scope.set_tag("i", i)
await asyncio.sleep(random.random())
with configure_scope() as scope:
assert scope._tags["i"] == i
return response.text("ok")
async def task(i):
responses = []
kwargs = {
"url_bytes": "http://localhost/context-check/{i}".format(i=i).encode(
"ascii"
),
"headers": {},
"version": "1.1",
"method": "GET",
"transport": None,
}
if SANIC_VERSION >= (19,):
kwargs["app"] = app
if SANIC_VERSION >= (21, 3):
class MockAsyncStreamer:
def __init__(self, request_body):
self.request_body = request_body
self.iter = iter(self.request_body)
if SANIC_VERSION >= (21, 12):
self.response = None
self.stage = Mock()
else:
self.response = b"success"
def respond(self, response):
responses.append(response)
patched_response = HTTPResponse()
return patched_response
def __aiter__(self):
return self
async def __anext__(self):
try:
return next(self.iter)
except StopIteration:
raise StopAsyncIteration
patched_request = request.Request(**kwargs)
patched_request.stream = MockAsyncStreamer([b"hello", b"foo"])
if SANIC_VERSION >= (21, 9):
await app.dispatch(
"http.lifecycle.request",
context={"request": patched_request},
inline=True,
)
await app.handle_request(
patched_request,
)
else:
await app.handle_request(
request.Request(**kwargs),
write_callback=responses.append,
stream_callback=responses.append,
)
(r,) = responses
assert r.status == 200
async def runner():
if SANIC_VERSION >= (21, 3):
if SANIC_VERSION >= (21, 9):
await app._startup()
else:
try:
app.router.reset()
app.router.finalize()
except AttributeError:
...
await asyncio.gather(*(task(i) for i in range(1000)))
if sys.version_info < (3, 7):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(runner())
else:
asyncio.run(runner())
with configure_scope() as scope:
assert not scope._tags
class TransactionTestConfig:
"""
Data class to store configurations for each performance transaction test run, including
both the inputs and relevant expected results.
"""
def __init__(
self,
integration_args,
url,
expected_status,
expected_transaction_name,
expected_source=None,
):
# type: (Iterable[Optional[Container[int]]], str, int, Optional[str], Optional[str]) -> None
"""
expected_transaction_name of None indicates we expect to not receive a transaction
"""
self.integration_args = integration_args
self.url = url
self.expected_status = expected_status
self.expected_transaction_name = expected_transaction_name
self.expected_source = expected_source
@pytest.mark.skipif(
not PERFORMANCE_SUPPORTED, reason="Performance not supported on this Sanic version"
)
@pytest.mark.parametrize(
"test_config",
[
TransactionTestConfig(
# Transaction for successful page load
integration_args=(),
url="/message",
expected_status=200,
expected_transaction_name="hi",
expected_source=TRANSACTION_SOURCE_COMPONENT,
),
TransactionTestConfig(
# Transaction still recorded when we have an internal server error
integration_args=(),
url="/500",
expected_status=500,
expected_transaction_name="fivehundred",
expected_source=TRANSACTION_SOURCE_COMPONENT,
),
TransactionTestConfig(
# By default, no transaction when we have a 404 error
integration_args=(),
url="/404",
expected_status=404,
expected_transaction_name=None,
),
TransactionTestConfig(
# With no ignored HTTP statuses, we should get transactions for 404 errors
integration_args=(None,),
url="/404",
expected_status=404,
expected_transaction_name="/404",
expected_source=TRANSACTION_SOURCE_URL,
),
TransactionTestConfig(
# Transaction can be suppressed for other HTTP statuses, too, by passing config to the integration
integration_args=({200},),
url="/message",
expected_status=200,
expected_transaction_name=None,
),
],
)
def test_transactions(test_config, sentry_init, app, capture_events):
# type: (TransactionTestConfig, Any, Any, Any) -> None
# Init the SanicIntegration with the desired arguments
sentry_init(
integrations=[SanicIntegration(*test_config.integration_args)],
traces_sample_rate=1.0,
)
events = capture_events()
# Make request to the desired URL
c = get_client(app)
with c as client:
_, response = client.get(test_config.url)
assert response.status == test_config.expected_status
# Extract the transaction events by inspecting the event types. We should at most have 1 transaction event.
transaction_events = [
e for e in events if "type" in e and e["type"] == "transaction"
]
assert len(transaction_events) <= 1
# Get the only transaction event, or set to None if there are no transaction events.
(transaction_event, *_) = [*transaction_events, None]
# We should have no transaction event if and only if we expect no transactions
assert (transaction_event is None) == (
test_config.expected_transaction_name is None
)
# If a transaction was expected, ensure it is correct
assert (
transaction_event is None
or transaction_event["transaction"] == test_config.expected_transaction_name
)
assert (
transaction_event is None
or transaction_event["transaction_info"]["source"]
== test_config.expected_source
)
sentry-python-1.39.2/tests/integrations/serverless/ 0000775 0000000 0000000 00000000000 14547447232 0022532 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/serverless/test_serverless.py 0000664 0000000 0000000 00000002022 14547447232 0026334 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk.integrations.serverless import serverless_function
def test_basic(sentry_init, capture_exceptions, monkeypatch):
sentry_init()
exceptions = capture_exceptions()
flush_calls = []
@serverless_function
def foo():
monkeypatch.setattr(
"sentry_sdk.Hub.current.flush", lambda: flush_calls.append(1)
)
1 / 0
with pytest.raises(ZeroDivisionError):
foo()
(exception,) = exceptions
assert isinstance(exception, ZeroDivisionError)
assert flush_calls == [1]
def test_flush_disabled(sentry_init, capture_exceptions, monkeypatch):
sentry_init()
exceptions = capture_exceptions()
flush_calls = []
monkeypatch.setattr("sentry_sdk.Hub.current.flush", lambda: flush_calls.append(1))
@serverless_function(flush=False)
def foo():
1 / 0
with pytest.raises(ZeroDivisionError):
foo()
(exception,) = exceptions
assert isinstance(exception, ZeroDivisionError)
assert flush_calls == []
sentry-python-1.39.2/tests/integrations/socket/ 0000775 0000000 0000000 00000000000 14547447232 0021625 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/socket/__init__.py 0000664 0000000 0000000 00000000055 14547447232 0023736 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("socket")
sentry-python-1.39.2/tests/integrations/socket/test_socket.py 0000664 0000000 0000000 00000002715 14547447232 0024533 0 ustar 00root root 0000000 0000000 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,
}
sentry-python-1.39.2/tests/integrations/spark/ 0000775 0000000 0000000 00000000000 14547447232 0021455 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/spark/__init__.py 0000664 0000000 0000000 00000000112 14547447232 0023560 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("pyspark")
pytest.importorskip("py4j")
sentry-python-1.39.2/tests/integrations/spark/test_spark.py 0000664 0000000 0000000 00000014706 14547447232 0024216 0 ustar 00root root 0000000 0000000 import pytest
import sys
from sentry_sdk.integrations.spark.spark_driver import (
_set_app_properties,
_start_sentry_listener,
SentryListener,
)
from sentry_sdk.integrations.spark.spark_worker import SparkWorkerIntegration
from pyspark import SparkContext
from py4j.protocol import Py4JJavaError
################
# DRIVER TESTS #
################
def test_set_app_properties():
spark_context = SparkContext(appName="Testing123")
_set_app_properties()
assert spark_context.getLocalProperty("sentry_app_name") == "Testing123"
# applicationId generated by sparkContext init
assert (
spark_context.getLocalProperty("sentry_application_id")
== spark_context.applicationId
)
def test_start_sentry_listener():
spark_context = SparkContext.getOrCreate()
gateway = spark_context._gateway
assert gateway._callback_server is None
_start_sentry_listener(spark_context)
assert gateway._callback_server is not None
@pytest.fixture
def sentry_listener(monkeypatch):
class MockHub:
def __init__(self):
self.args = []
self.kwargs = {}
def add_breadcrumb(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
listener = SentryListener()
mock_hub = MockHub()
monkeypatch.setattr(listener, "hub", mock_hub)
return listener, mock_hub
def test_sentry_listener_on_job_start(sentry_listener):
listener, mock_hub = sentry_listener
class MockJobStart:
def jobId(self): # noqa: N802
return "sample-job-id-start"
mock_job_start = MockJobStart()
listener.onJobStart(mock_job_start)
assert mock_hub.kwargs["level"] == "info"
assert "sample-job-id-start" in mock_hub.kwargs["message"]
@pytest.mark.parametrize(
"job_result, level", [("JobSucceeded", "info"), ("JobFailed", "warning")]
)
def test_sentry_listener_on_job_end(sentry_listener, job_result, level):
listener, mock_hub = sentry_listener
class MockJobResult:
def toString(self): # noqa: N802
return job_result
class MockJobEnd:
def jobId(self): # noqa: N802
return "sample-job-id-end"
def jobResult(self): # noqa: N802
result = MockJobResult()
return result
mock_job_end = MockJobEnd()
listener.onJobEnd(mock_job_end)
assert mock_hub.kwargs["level"] == level
assert mock_hub.kwargs["data"]["result"] == job_result
assert "sample-job-id-end" in mock_hub.kwargs["message"]
def test_sentry_listener_on_stage_submitted(sentry_listener):
listener, mock_hub = sentry_listener
class StageInfo:
def stageId(self): # noqa: N802
return "sample-stage-id-submit"
def name(self):
return "run-job"
def attemptId(self): # noqa: N802
return 14
class MockStageSubmitted:
def stageInfo(self): # noqa: N802
stageinf = StageInfo()
return stageinf
mock_stage_submitted = MockStageSubmitted()
listener.onStageSubmitted(mock_stage_submitted)
assert mock_hub.kwargs["level"] == "info"
assert "sample-stage-id-submit" in mock_hub.kwargs["message"]
assert mock_hub.kwargs["data"]["attemptId"] == 14
assert mock_hub.kwargs["data"]["name"] == "run-job"
@pytest.fixture
def get_mock_stage_completed():
def _inner(failure_reason):
class JavaException:
def __init__(self):
self._target_id = "id"
class FailureReason:
def get(self):
if failure_reason:
return "failure-reason"
else:
raise Py4JJavaError("msg", JavaException())
class StageInfo:
def stageId(self): # noqa: N802
return "sample-stage-id-submit"
def name(self):
return "run-job"
def attemptId(self): # noqa: N802
return 14
def failureReason(self): # noqa: N802
return FailureReason()
class MockStageCompleted:
def stageInfo(self): # noqa: N802
return StageInfo()
return MockStageCompleted()
return _inner
def test_sentry_listener_on_stage_completed_success(
sentry_listener, get_mock_stage_completed
):
listener, mock_hub = sentry_listener
mock_stage_completed = get_mock_stage_completed(failure_reason=False)
listener.onStageCompleted(mock_stage_completed)
assert mock_hub.kwargs["level"] == "info"
assert "sample-stage-id-submit" in mock_hub.kwargs["message"]
assert mock_hub.kwargs["data"]["attemptId"] == 14
assert mock_hub.kwargs["data"]["name"] == "run-job"
assert "reason" not in mock_hub.kwargs["data"]
def test_sentry_listener_on_stage_completed_failure(
sentry_listener, get_mock_stage_completed
):
listener, mock_hub = sentry_listener
mock_stage_completed = get_mock_stage_completed(failure_reason=True)
listener.onStageCompleted(mock_stage_completed)
assert mock_hub.kwargs["level"] == "warning"
assert "sample-stage-id-submit" in mock_hub.kwargs["message"]
assert mock_hub.kwargs["data"]["attemptId"] == 14
assert mock_hub.kwargs["data"]["name"] == "run-job"
assert mock_hub.kwargs["data"]["reason"] == "failure-reason"
################
# WORKER TESTS #
################
def test_spark_worker(monkeypatch, sentry_init, capture_events, capture_exceptions):
import pyspark.worker as original_worker
import pyspark.daemon as original_daemon
from pyspark.taskcontext import TaskContext
task_context = TaskContext._getOrCreate()
def mock_main():
task_context._stageId = 0
task_context._attemptNumber = 1
task_context._partitionId = 2
task_context._taskAttemptId = 3
try:
raise ZeroDivisionError
except ZeroDivisionError:
sys.exit(-1)
monkeypatch.setattr(original_worker, "main", mock_main)
sentry_init(integrations=[SparkWorkerIntegration()])
events = capture_events()
exceptions = capture_exceptions()
original_daemon.worker_main()
# SystemExit called, but not recorded as part of event
assert type(exceptions.pop()) == SystemExit
assert len(events[0]["exception"]["values"]) == 1
assert events[0]["exception"]["values"][0]["type"] == "ZeroDivisionError"
assert events[0]["tags"] == {
"stageId": "0",
"attemptNumber": "1",
"partitionId": "2",
"taskAttemptId": "3",
}
sentry-python-1.39.2/tests/integrations/sqlalchemy/ 0000775 0000000 0000000 00000000000 14547447232 0022477 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/sqlalchemy/__init__.py 0000664 0000000 0000000 00000000061 14547447232 0024605 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("sqlalchemy")
sentry-python-1.39.2/tests/integrations/sqlalchemy/test_sqlalchemy.py 0000664 0000000 0000000 00000025536 14547447232 0026265 0 ustar 00root root 0000000 0000000 import os
import pytest
import sys
from sqlalchemy import Column, ForeignKey, Integer, String, create_engine
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker
from sqlalchemy import text
from sentry_sdk import capture_message, start_transaction, configure_scope
from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH, SPANDATA
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
from sentry_sdk.serializer import MAX_EVENT_BYTES
from sentry_sdk.utils import json_dumps
def test_orm_queries(sentry_init, capture_events):
sentry_init(
integrations=[SqlalchemyIntegration()], _experiments={"record_sql_params": True}
)
events = capture_events()
Base = declarative_base() # noqa: N806
class Person(Base):
__tablename__ = "person"
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
class Address(Base):
__tablename__ = "address"
id = Column(Integer, primary_key=True)
street_name = Column(String(250))
street_number = Column(String(250))
post_code = Column(String(250), nullable=False)
person_id = Column(Integer, ForeignKey("person.id"))
person = relationship(Person)
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine) # noqa: N806
session = Session()
bob = Person(name="Bob")
session.add(bob)
assert session.query(Person).first() == bob
capture_message("hi")
(event,) = events
for crumb in event["breadcrumbs"]["values"]:
del crumb["timestamp"]
assert event["breadcrumbs"]["values"][-2:] == [
{
"category": "query",
"data": {"db.params": ["Bob"], "db.paramstyle": "qmark"},
"message": "INSERT INTO person (name) VALUES (?)",
"type": "default",
},
{
"category": "query",
"data": {"db.params": [1, 0], "db.paramstyle": "qmark"},
"message": "SELECT person.id AS person_id, person.name AS person_name \n"
"FROM person\n"
" LIMIT ? OFFSET ?",
"type": "default",
},
]
@pytest.mark.skipif(
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},
traces_sample_rate=1.0,
)
events = capture_events()
Base = declarative_base() # noqa: N806
class Person(Base):
__tablename__ = "person"
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
class Address(Base):
__tablename__ = "address"
id = Column(Integer, primary_key=True)
street_name = Column(String(250))
street_number = Column(String(250))
post_code = Column(String(250), nullable=False)
person_id = Column(Integer, ForeignKey("person.id"))
person = relationship(Person)
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine) # noqa: N806
session = Session()
with start_transaction(name="test_transaction", sampled=True):
with session.begin_nested():
session.query(Person).first()
for _ in range(2):
with pytest.raises(IntegrityError):
with session.begin_nested():
session.add(Person(id=1, name="bob"))
session.add(Person(id=1, name="bob"))
with session.begin_nested():
session.query(Person).first()
(event,) = events
for span in event["spans"]:
assert span["data"][SPANDATA.DB_SYSTEM] == "sqlite"
assert span["data"][SPANDATA.DB_NAME] == ":memory:"
assert SPANDATA.SERVER_ADDRESS not in span["data"]
assert SPANDATA.SERVER_PORT not in span["data"]
assert (
render_span_tree(event)
== """\
- op=null: description=null
- op="db": description="SAVEPOINT sa_savepoint_1"
- op="db": description="SELECT person.id AS person_id, person.name AS person_name \\nFROM person\\n LIMIT ? OFFSET ?"
- op="db": description="RELEASE SAVEPOINT sa_savepoint_1"
- op="db": description="SAVEPOINT sa_savepoint_2"
- op="db": description="INSERT INTO person (id, name) VALUES (?, ?)"
- op="db": description="ROLLBACK TO SAVEPOINT sa_savepoint_2"
- op="db": description="SAVEPOINT sa_savepoint_3"
- op="db": description="INSERT INTO person (id, name) VALUES (?, ?)"
- op="db": description="ROLLBACK TO SAVEPOINT sa_savepoint_3"
- op="db": description="SAVEPOINT sa_savepoint_4"
- op="db": description="SELECT person.id AS person_id, person.name AS person_name \\nFROM person\\n LIMIT ? OFFSET ?"
- op="db": description="RELEASE SAVEPOINT sa_savepoint_4"\
"""
)
def test_long_sql_query_preserved(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1,
integrations=[SqlalchemyIntegration()],
)
events = capture_events()
engine = create_engine("sqlite:///:memory:")
with start_transaction(name="test"):
with engine.connect() as con:
con.execute(text(" UNION ".join("SELECT {}".format(i) for i in range(100))))
(event,) = events
description = event["spans"][0]["description"]
assert description.startswith("SELECT 0 UNION SELECT 1")
assert description.endswith("SELECT 98 UNION SELECT 99")
def test_large_event_not_truncated(sentry_init, capture_events):
sentry_init(
traces_sample_rate=1,
integrations=[SqlalchemyIntegration()],
)
events = capture_events()
long_str = "x" * (DEFAULT_MAX_VALUE_LENGTH + 10)
with configure_scope() as scope:
@scope.add_event_processor
def processor(event, hint):
event["message"] = long_str
return event
engine = create_engine("sqlite:///:memory:")
with start_transaction(name="test"):
with engine.connect() as con:
for _ in range(1500):
con.execute(
text(" UNION ".join("SELECT {}".format(i) for i in range(100)))
)
(event,) = events
assert len(json_dumps(event)) > MAX_EVENT_BYTES
# Some spans are discarded.
assert len(event["spans"]) == 1000
# 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"]) == DEFAULT_MAX_VALUE_LENGTH
# The _meta for other truncated fields should be there as well.
assert event["_meta"]["message"] == {
"": {"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(text("SELECT 0"))
@pytest.mark.parametrize("enable_db_query_source", [None, False])
def test_query_source_disabled(sentry_init, capture_events, enable_db_query_source):
sentry_options = {
"integrations": [SqlalchemyIntegration()],
"enable_tracing": True,
}
if enable_db_query_source is not None:
sentry_options["enable_db_query_source"] = enable_db_query_source
sentry_options["db_query_source_threshold_ms"] = 0
sentry_init(**sentry_options)
events = capture_events()
with start_transaction(name="test_transaction", sampled=True):
Base = declarative_base() # noqa: N806
class Person(Base):
__tablename__ = "person"
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine) # noqa: N806
session = Session()
bob = Person(name="Bob")
session.add(bob)
assert session.query(Person).first() == bob
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and span.get("description").startswith(
"SELECT person"
):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO not in data
assert SPANDATA.CODE_NAMESPACE not in data
assert SPANDATA.CODE_FILEPATH not in data
assert SPANDATA.CODE_FUNCTION not in data
break
else:
raise AssertionError("No db span found")
def test_query_source(sentry_init, capture_events):
sentry_init(
integrations=[SqlalchemyIntegration()],
enable_tracing=True,
enable_db_query_source=True,
db_query_source_threshold_ms=0,
)
events = capture_events()
with start_transaction(name="test_transaction", sampled=True):
Base = declarative_base() # noqa: N806
class Person(Base):
__tablename__ = "person"
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
engine = create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine) # noqa: N806
session = Session()
bob = Person(name="Bob")
session.add(bob)
assert session.query(Person).first() == bob
(event,) = events
for span in event["spans"]:
if span.get("op") == "db" and span.get("description").startswith(
"SELECT person"
):
data = span.get("data", {})
assert SPANDATA.CODE_LINENO in data
assert SPANDATA.CODE_NAMESPACE in data
assert SPANDATA.CODE_FILEPATH in data
assert SPANDATA.CODE_FUNCTION in data
assert type(data.get(SPANDATA.CODE_LINENO)) == int
assert data.get(SPANDATA.CODE_LINENO) > 0
assert (
data.get(SPANDATA.CODE_NAMESPACE)
== "tests.integrations.sqlalchemy.test_sqlalchemy"
)
assert data.get(SPANDATA.CODE_FILEPATH).endswith(
"tests/integrations/sqlalchemy/test_sqlalchemy.py"
)
is_relative_path = data.get(SPANDATA.CODE_FILEPATH)[0] != os.sep
assert is_relative_path
assert data.get(SPANDATA.CODE_FUNCTION) == "test_query_source"
break
else:
raise AssertionError("No db span found")
sentry-python-1.39.2/tests/integrations/starlette/ 0000775 0000000 0000000 00000000000 14547447232 0022344 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/starlette/__init__.py 0000664 0000000 0000000 00000000060 14547447232 0024451 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("starlette")
sentry-python-1.39.2/tests/integrations/starlette/photo.jpg 0000664 0000000 0000000 00000051026 14547447232 0024203 0 ustar 00root root 0000000 0000000 JFIF H H C
C
1 x88\Ld
W-)yk\=mdPm';.6[aƠp @-'MMkGVL ElHij.T\j:#ERpݖ-LI(MX^Zi12 Nr
Kpj(} lm]j c<=L:[Ѱ|Ydy&<=h' R UmqqpNw\p2'H bNU23ZO#043i
5C~V-
^?.~7Py .xpUtX&QrIϧkqqMxyzIڹ.j\Ҁ( I EI4 Rܭ{WJe-tc?PR[O L+Bi4ʡL܈ 湯0nk:O%ѹ<ۇmQ OHUI)F:DH
6 Sc4YmJP$R)g']lYRQ\Ӟ1@9c\-5]SԺ8 w:0UK˓8 gOA`1Tm"a
gݪhۮ(5!k
oHzUO6ځQ???W7zuTގJwG+YiZ751trin=TU;:9}lZi6`rpJ㞻
]#tɇLN.qNn `KVzQ)8⾸{?g \] MAi'ژ>`84Ij^J͜>&@}0kvp]l'磕-b-w*U#,:(I7zǫ(Ί3Z} ;jW>vXϼ4JL+bZX7Xޥ@ \y$ Pp\?UOe-IL-rtqp3 {4Y?H~Du yR~JƆTC3E
zڷ[lJp@ gfG9c4rN"Mhj b"&7G?:>-t"q]A: ͆X| y& NHJn x=ЁЀh: @ }P2!jh@nNZs7 Kɺv @p: |v4ܺx45ٳ]B$6'8/k9sϝYG
s6B.QrSY ״Ͻ/!X"̽!juJis-:H7| ςL;@Sc=JU) E0 \>X,5Ɣi(J` 'MZ/}O7P1 634
^k O?o9L0fz9
Hp( 3^M9s8% @{4"z"b?O,L*VmrÍ/ §K*=47~F~Z"@ǙqzCeq_(GFX `w7Ho|[RIK+tg l w_s,GE w^ʝ WdX'~A(N K& 0 id@I 9e {!{$fjb2r0X|Xū]R^oT $#n/yGIғز$Z>5FHG,ܩ /UVGa|\čf9Iߊ Faǖ"NJe0dv3壒NÑFC-SɎϒH=y$+͚#Dq*f #ʖLM1㯷><)E6PCׇB: T,8G
"Mh-\>],9d (e` L?v_>/oӢ}7 )#bXF9W @,c և#G 2LDjiW%ɿA䱭YFο'
=^[iGX@1ECj!#9CL5xq !zHĹ8 ZN~%6p-~ Y0 t+^CĽFH/
SJ|A/̓)$ct]eHsr3 P8"NEeq <@#Td>VE߫kefJ1p r~lj,tzv
F< ww˲km*VXՙ|9ьBuؽEwzf"O=V1 Zt8uW/M좓# ×?W_9mHj[pTOt= $h?r^>JlewҢ"eH7Id{V}OieWe Ý>RuɀAq'+uT'~H|\#u/9PX!gxN#5u]=J[1A$ P6뚹]tC {I8u|8z/G 4s'
y+9LYi\TKIpc]4 l~4ƹμ:5R^_U \ǚFzېHBą#9cu5J 4Ŏ s%d^V|ThPuݞM ē \Y߅wϺ!q[udB]s2RRW:b\Yk_#w!#㖕~ꆻ? "h{d^)~ '{ݛ_ ^?~q v? + !01A2"Q3@#Baq ?CQ Ya{} FHMt 8aK \^) y`Xck>@14Ƣٯ% /1Rfjf#%Cō봙3'b%G#Lig0PYB}?xj-_?CF
Z7 -q/!l϶q= t"=v+p2LcAdlw/H|;vFCbcD {q
`" &a>U00gMO8x:Knv' \!6I_"N{ AOY>S@[ۯXe8)l hvl֡rzۡ *!-ӷ 3 [[78>T=?Y8ͽ?MvSR1/Uv@4ƋgL0,g6wZ |v3 9#c
頎N[ ߮FG % 0!12A@BQ ?ژlgheeJl:e7ɆI|8F|PPwe&II-wAgT@sߘ % >O 8;Eɖa<>O,"[#gɶ-mh6,[pt鍪 kNjFcւrgXjtVB;^^[W[}Kl1FAjgG%[d
Jf^ADl*ZW(OOIN@D&44F| 0S!%=qxѧtXh?
|X@B;EB@mQm:ga!HŬ_P D6Gi e|$橳Vqxm0ICM[GJ'5s<^EcU* Q
AyZ&
>D96ЕGL> vPརTEKJbc(U [|NquTKhTU'@V/nmbX@Hf|
xo"rց@T RFx*(v
B% ,t<cp w75UGwB.t9q^daUq<#BUgU
WO6SVP@A4crQfkk UltrqRLF%Yj(ݤU1|]iSHZbA1>[5h:;FTe|}QOƒtYE)bU@VfY^;+0Y&p94aXe^]ϟE7tqs(HvX)}U^B`/_cj;r;U*Tkm^Lha2 P< Mz5$xk=yYE#*0siTU:>'z.Q7(fcnE Uje뼽 k
z$:L4fve]o(cӴl]96>X s<|DW4G TOWX 1dh#%~.8jDIb0`4}LQry΄sq<0R%:v 7,JMs5k¿U6(⠆?*rXhfwI& ?~G\o 䳛h,
Rq`F߽ѡDa%ł% NUFY,>buLmDMC4L ncY -]ҶX)ꂝy#}$<^gP%>ՠs`n ,]LQ $d?\? X s * 6sV}+
&r 0]0\YşeE'p6'Lje# zdPQ,v1eF/9U7f7U9.,*i7U u_pktNL#Hvy, ~*20c u'JL[>Fh ?U*FqFLE&E=5s\HECY6?)bXС/f)s7'a)_~C ̌G-9{80p>4QߐJg).$<#D 58h2l,
C92cF%K͙j σUbfFa7 F+^^ <O?*1UU`~꒩E! t *osgnSL
fOm]JUANb>62Ĵ`.{>f)
Lߛl$FH-d'x>k ?Bŵk 1A:5_Kj[#PD Y{rCbYYdE=;F9h{ {cb ך(dwqGu! udq۰
qW, }F[t=Y#~5! r_*VqX"1@z=\ּWB ?éc\bBd1xaSDVMB73˚+,&}G@ۇ͓Kl=s~lLk> sruEd}k,FAIp/zE鳙o? %[7cy64yrʃAEo6]e!)B
, ԋZ)s JЄ ifj8y0(RW6~+·n[E㛤 ê;3v)> 9X [ХgF3i(ӀJwiu S
0*ҝ㺳 9>F,[JnY sM۷`".Py\GJ죚dekgёg騺MbFl)3FjK]幘K\KRǨ6.¹ 6SDt/:"UV&?upTC ڸO(UƸcfd Fi5ϲ*E
*5`&g!Nj85#D)-V˦17T&*a`ע{. "d wŒbhdSed'-TO.HQ'Q>3/
r qT}ŌPrl+Gѹ 3U
Ok/AY\@jѥ =G&B \h&hŞFj`(%BGU,YONWCv!^'NP݆t/1qvEhb.ALD e͓UZ,ʕUkX`;>@4r]x&c^=[_|7Zi:z ?
T_7=_;o 4mM!s}dE$_s)aVi&)hNma 0U1=Ҳѿҁffʪ(IbT'q!Z1Bڋob8ZSiS?&W ;ZI5"&fbOܛb))%o X ZY V@ZR9_'~ D=fz˕ YKǥgn\`G^yt]c'.F ٛb~HOٶ X7ZR7 s #Y=w߈?
V2 @xs䑗ӱ؞o0m #1P$ dy klGwfSz\ KC?a$,=n3k0z
v k>r;Iݒ 66"R: .c#r8m9 ndyr\f2 LlE< rpy ؛=fYEv{k97g-O}+sCO>1r3#뿱?EO],m,GR4ٌavKϧY/0r|DFz L HG#!@[qz O\ ynRI5ٟ\slg mیR r^H)0B2 388
w( p˙gRsʔ Dc$ٯB. \@ P
f +O t t@5}> @h#&Dᑆy0/蠈|]^ ` " q3 @K|dasHO-xZJxB AtIIHS4#)8+GcB.h"r
+;LܤQRC`Ca 5 ,?x6'
.phvNIs@oD)їCcp硼490M#N7v
a%#!QP93bKyZ)f vBP(20]5 xgoiNm =Gps\@GEr뀘1~C') pIp!HrykAA p4B҂44z\,y{R 4ܐ -
0p!؝
tdc'A$
HHÒx?rBr)IBF_ #x(
%< %~1xh E19$%.a()dp \u] i7P$y
yi|)obҐAODPacj +M ]M` ##kr=88Lf: @\ Z6ѦNF)ǥ̞F\:a掾ےhsDsnïc & !1AQaq ?ካ1ZuO!lhT%:,PB`yz$%t))=p>.pIIT*C^Ph}hh ٨Iʼnv( @LjH6dYI# |V@)@f0~X3CcZFYM=zM$Uyo:]s8~~
"1(̽1f n:?ڊ ܼ%˟Af r韥 } u'а"i1p@ `)(R}"cYA#7,OJ02eaYS1'Oq ԌeL)=y}# dOK9,D^aRyS1I yNJmd.M F~ * 4+a18PaH'L0
F=Ɣ!f^J(R`Lc b71ۜFTRN19lFJ 2!30b
9Br: |l䘃ESd0>j,0䉓J iH0GT
-C) T+ {1 G`P Vl{G e"bxoT"(Hu{ I81kΉՅNK R,u&0H @U^?jW+Ɏg,!fv;lrSOd])xy ()`u:Pp@$jyOz'C6[#A$t7YsjgeǵB8z20歕!9͚ѐL۵0<5sRoW&áe z8༾I{ǰ n,LkHcpb zL ;"{qH!5e3\,OA`R0
C-`Z͛,|O3d) TI XQh {5Ab*Cf?)"9Ӑ&Q4q-G >Ujxwv' qY3)`~/ز=8HzKN dpEVB7P5aNd0MBep5Ht,̂ f$xN8BA86đP^S3
Q D4[#;6Oi:Y0zpWqO0gk:x<ƑzXy iۂ wO@ J5D} 4|^& Yc(}CϚGɞƬB|Rg;@g`V@o@"nyrd O[#l'."T
IV+9f*J:"\:)e Ƙ b ~lōŋcz utgS;ui"ul/Zv'YV| ɞ1IdknK$α9iIaHN
b3K1?6V h Rs gL2)g1LU(eD}Ჟb!3# |k^׀pOZrij)Nn)4)=튌@ H^s u& S l20.lj"DO4N[I@ G
h1E G͋GN0OGj
j$< J&=s4 Sl&~cV(I3fa|.1 CLo*02Ň0pq8I c
>&j2=ɰljΎƹN';Y)Ew21@ D?#ĉOK6)> jle("I N[3F$ٺLrPC IS 8|Q
5#W ޔD36TD>Juf }+TX$:֪$h U
T yAW d 61jgcǵG1R&P8 -*2}Cӊ\-{ fEH9zRc((IP9eRahR~fXƂ'XVDx!A6 |=m oJMɌ481%x ^ֺ 3J函ac#c$ 7OZr ;!Ycƫ@CswbG|P`v $g#2 Oz aԥd j@!DMd 0LO )0/&GŔEp\1J c֘(T|DE#FB9W_# [>{/Q]ʰ[`\hH{W2 Y3pFv06 D?VONj ( > {?fJń?=lX=,Bs6Hlt!sIRbtesiXw Ha,NڷC Ds9(<"VQ'+6Pk_j$9K(,dERu+t^c\8D+/DJ° qPf}eRF'V)eI[$Y/(g `8!itQc}b`e`'' l6z㭂HG*l;?53JSV ÊhfX >'il]h c5`` 8L# t&f-L!20T$!" @$ |SJE\F|PDz
;@`Chet h O?Қ?M`c :1F#% X)@pZ. }nte2m2NkPH8{Q. D D&,D+Ϲ1QaK1b
ճTB j
32 dmJILB=CqR b*}T`+\b4 Ԫ#q%MTbwT@ܨz\0#NnB GzLGspG _2B.2yL, 8IxM%F 6$OXሊY-zJ=yi ܁NbM~nƭGD c`\zYf#ȱ /?'8ޠR%y*ha0k&~jX9 "K@D>uL,C<܇ x oTfA6|J%|) ]xlY| )ȹ! +<]SI qV.2@`U >!%ߥbL!7!2s{L ֜j$b/HLc"Nx @ԏjQC$!J @$ 7`4 sXː7saRp@s2 [vǀSZKRRY {Y0rY4NfȢ
dFˬKL&úDaM %q:0ī/ @]%ŏ@s+0~>=4}L|lb%yegRM$BaYE
ZD)a'ڐ džE )8KûfM3b1Su}fe`He>5 30GxxIp{
1]@Tiag"fT]R ˵T+> ^bl: 0 DL3@Asrke Pfr@e`uLTGb^9i.@ G j:RdaT ihFr֒'CNevF@TV*0&h0j't A IB˝JX`k>]dDb)- d~}ѳ⡂z9QyGQL4w=Dw!&%*`:G!x6a(&$mHh/UȐMA~{ 8c
T4;z<^J9dë \g'CP6Y'g:nA4 `h0vą>C>1E2Lw)4L
C5!c`U<4 pi
#F!ѫd0=%c&Ϋ X\λЅ 䑯|h,(G(B Eܪ(nl1%J>DfPpaj 3nVԝC":UL*X
ICLaZ0z_d;Y0<BJu[$lHvH"KHrgؖ
ks{:gpgCW'EP%33f وNP "tq!eSDy6V,GBLđHdi1Ȫ>q GMܨFBKU48?{\✤W雷 |`L|QYYl̡0L%nx^~b&,*&cɻ._xy<߫_/_ fn 7//o} sentry-python-1.39.2/tests/integrations/starlette/templates/ 0000775 0000000 0000000 00000000000 14547447232 0024342 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/starlette/templates/trace_meta.html 0000664 0000000 0000000 00000000030 14547447232 0027325 0 ustar 00root root 0000000 0000000 {{ sentry_trace_meta }}
sentry-python-1.39.2/tests/integrations/starlette/test_starlette.py 0000664 0000000 0000000 00000104355 14547447232 0025774 0 ustar 00root root 0000000 0000000 import asyncio
import base64
import functools
import json
import logging
import os
import re
import threading
import pytest
from sentry_sdk import last_event_id, capture_exception
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
from sentry_sdk.utils import parse_version
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,
)
import starlette
from starlette.authentication import (
AuthCredentials,
AuthenticationBackend,
AuthenticationError,
SimpleUser,
)
from starlette.middleware import Middleware
from starlette.middleware.authentication import AuthenticationMiddleware
from starlette.middleware.trustedhost import TrustedHostMiddleware
from starlette.testclient import TestClient
STARLETTE_VERSION = parse_version(starlette.__version__)
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"),
),
),
]
)
# 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
from sentry_sdk import Hub
from starlette.templating import Jinja2Templates
def starlette_app_factory(middleware=None, debug=True):
template_dir = os.path.join(
os.getcwd(), "tests", "integrations", "starlette", "templates"
)
templates = Jinja2Templates(directory=template_dir)
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,
}
)
async def _render_template(request):
hub = Hub.current
capture_message(hub.get_traceparent() + "\n" + hub.get_baggage())
template_context = {
"request": request,
"msg": "Hello Template World!",
}
return templates.TemplateResponse("trace_meta.html", template_context)
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),
starlette.routing.Route("/render_template", _render_template),
],
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": "SentryAsgiMiddleware._run_app.._sentry_wrapped_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": "SentryAsgiMiddleware._run_app.._sentry_wrapped_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": "SentryAsgiMiddleware._run_app.._sentry_wrapped_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]"
@pytest.mark.skipif(STARLETTE_VERSION < (0, 24), reason="Requires Starlette >= 0.24")
def test_template_tracing_meta(sentry_init, capture_events):
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[StarletteIntegration()],
)
events = capture_events()
app = starlette_app_factory()
client = TestClient(app)
response = client.get("/render_template")
assert response.status_code == 200
rendered_meta = response.text
traceparent, baggage = events[0]["message"].split("\n")
assert traceparent != ""
assert baggage != ""
match = re.match(
r'^',
rendered_meta,
)
assert match is not None
assert match.group(1) == traceparent
# Python 2 does not preserve sort order
rendered_baggage = match.group(2)
assert sorted(rendered_baggage.split(",")) == sorted(baggage.split(","))
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"tests.integrations.starlette.test_starlette.starlette_app_factory.._message_with_id",
"component",
),
(
"/message/123456",
"url",
"/message/{message_id}",
"route",
),
],
)
def test_transaction_name(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
capture_envelopes,
):
"""
Tests that the transaction name is something meaningful.
"""
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[StarletteIntegration(transaction_style=transaction_style)],
traces_sample_rate=1.0,
debug=True,
)
envelopes = capture_envelopes()
app = starlette_app_factory()
client = TestClient(app)
client.get(request_url)
(_, transaction_envelope) = envelopes
transaction_event = transaction_envelope.get_transaction_event()
assert transaction_event["transaction"] == expected_transaction_name
assert (
transaction_event["transaction_info"]["source"] == expected_transaction_source
)
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"http://testserver/message/123456",
"url",
),
(
"/message/123456",
"url",
"http://testserver/message/123456",
"url",
),
],
)
def test_transaction_name_in_traces_sampler(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
):
"""
Tests that a custom traces_sampler has a meaningful transaction name.
In this case the URL or endpoint, because we do not have the route yet.
"""
def dummy_traces_sampler(sampling_context):
assert (
sampling_context["transaction_context"]["name"] == expected_transaction_name
)
assert (
sampling_context["transaction_context"]["source"]
== expected_transaction_source
)
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[StarletteIntegration(transaction_style=transaction_style)],
traces_sampler=dummy_traces_sampler,
traces_sample_rate=1.0,
debug=True,
)
app = starlette_app_factory()
client = TestClient(app)
client.get(request_url)
@pytest.mark.parametrize(
"request_url,transaction_style,expected_transaction_name,expected_transaction_source",
[
(
"/message/123456",
"endpoint",
"starlette.middleware.trustedhost.TrustedHostMiddleware",
"component",
),
(
"/message/123456",
"url",
"http://testserver/message/123456",
"url",
),
],
)
def test_transaction_name_in_middleware(
sentry_init,
request_url,
transaction_style,
expected_transaction_name,
expected_transaction_source,
capture_envelopes,
):
"""
Tests that the transaction name is something meaningful.
"""
sentry_init(
auto_enabling_integrations=False, # Make sure that httpx integration is not added, because it adds tracing information to the starlette test clients request.
integrations=[
StarletteIntegration(transaction_style=transaction_style),
],
traces_sample_rate=1.0,
debug=True,
)
envelopes = capture_envelopes()
middleware = [
Middleware(
TrustedHostMiddleware,
allowed_hosts=["example.com", "*.example.com"],
),
]
app = starlette_app_factory(middleware=middleware)
client = TestClient(app)
client.get(request_url)
(transaction_envelope,) = envelopes
transaction_event = transaction_envelope.get_transaction_event()
assert transaction_event["contexts"]["response"]["status_code"] == 400
assert transaction_event["transaction"] == expected_transaction_name
assert (
transaction_event["transaction_info"]["source"] == expected_transaction_source
)
sentry-python-1.39.2/tests/integrations/starlite/ 0000775 0000000 0000000 00000000000 14547447232 0022164 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/starlite/__init__.py 0000664 0000000 0000000 00000000057 14547447232 0024277 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("starlite")
sentry-python-1.39.2/tests/integrations/starlite/test_starlite.py 0000664 0000000 0000000 00000022657 14547447232 0025440 0 ustar 00root root 0000000 0000000 import functools
import pytest
from sentry_sdk import capture_exception, capture_message, last_event_id
from sentry_sdk.integrations.starlite import StarliteIntegration
from typing import Any, Dict
import starlite
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": "SentryAsgiMiddleware._run_app.._sentry_wrapped_send",
"tags": {"starlite.middleware_name": "SampleMiddleware"},
},
{
"op": "middleware.starlite.send",
"description": "SentryAsgiMiddleware._run_app.._sentry_wrapped_send",
"tags": {"starlite.middleware_name": "SampleMiddleware"},
},
]
for idx, span in enumerate(transaction_event["spans"]):
assert span["op"] == expected[idx]["op"]
assert span["description"] == expected[idx]["description"]
assert span["tags"] == expected[idx]["tags"]
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": "SentryAsgiMiddleware._run_app.._sentry_wrapped_send",
"tags": {"starlite.middleware_name": "SamplePartialReceiveSendMiddleware"},
},
]
for idx, span in enumerate(transaction_event["spans"]):
assert span["op"] == expected[idx]["op"]
assert span["description"].startswith(expected[idx]["description"])
assert span["tags"] == expected[idx]["tags"]
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
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"
sentry-python-1.39.2/tests/integrations/stdlib/ 0000775 0000000 0000000 00000000000 14547447232 0021616 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/stdlib/test_httplib.py 0000664 0000000 0000000 00000024355 14547447232 0024706 0 ustar 00root root 0000000 0000000 import random
import pytest
try:
# py3
from urllib.request import urlopen
except ImportError:
# py2
from urllib import urlopen
try:
# py2
from httplib import HTTPConnection, HTTPSConnection
except ImportError:
# py3
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 = "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,
SPANDATA.HTTP_METHOD: "GET",
SPANDATA.HTTP_STATUS_CODE: 200,
"reason": "OK",
SPANDATA.HTTP_FRAGMENT: "",
SPANDATA.HTTP_QUERY: "",
}
def test_crumb_capture_hint(sentry_init, capture_events):
def before_breadcrumb(crumb, hint):
crumb["data"]["extra"] = "foo"
return crumb
sentry_init(integrations=[StdlibIntegration()], before_breadcrumb=before_breadcrumb)
events = capture_events()
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,
SPANDATA.HTTP_METHOD: "GET",
SPANDATA.HTTP_STATUS_CODE: 200,
"reason": "OK",
"extra": "foo",
SPANDATA.HTTP_FRAGMENT: "",
SPANDATA.HTTP_QUERY: "",
}
def test_empty_realurl(sentry_init):
"""
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):
"""HTTPConnection.getresponse must be called after every call to
HTTPConnection.request. However, if somebody does not abide by
this contract, we still should handle this gracefully and not
send mixed breadcrumbs.
Test whether our breadcrumbs are coherent when somebody uses HTTPConnection
wrongly.
"""
sentry_init()
events = capture_events()
conn = HTTPConnection("localhost", PORT)
# make sure we release the resource, even if the test fails
request.addfinalizer(conn.close)
conn.request("GET", "/200")
with pytest.raises(Exception): # noqa: B017
# 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", "/200")
response = conn.getresponse()
assert response._method == "GET"
capture_message("Testing!")
(event,) = events
(crumb,) = event["breadcrumbs"]["values"]
assert crumb["type"] == "http"
assert crumb["category"] == "httplib"
assert crumb["data"] == {
"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):
# 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(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-sampled=%s" % "true" if transaction.sampled else "false",
"sentry-release=foo",
"sentry-environment=production",
]
assert sorted(request_headers["baggage"].split(",")) == sorted(
expected_outgoing_baggage_items
)
@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
sentry-python-1.39.2/tests/integrations/stdlib/test_subprocess.py 0000664 0000000 0000000 00000011603 14547447232 0025420 0 ustar 00root root 0000000 0000000 import os
import platform
import subprocess
import sys
import pytest
from sentry_sdk import capture_message, start_transaction
from sentry_sdk._compat import PY2
from sentry_sdk.integrations.stdlib import StdlibIntegration
if PY2:
from collections import Mapping
else:
from collections.abc import Mapping
class ImmutableDict(Mapping):
def __init__(self, inner):
self.inner = inner
def __getitem__(self, key):
return self.inner[key]
def __iter__(self):
return iter(self.inner)
def __len__(self):
return len(self.inner)
@pytest.mark.parametrize("positional_args", [True, False])
@pytest.mark.parametrize(
"iterator",
[
pytest.param(
True,
marks=pytest.mark.skipif(
platform.python_implementation() == "PyPy",
reason="https://bitbucket.org/pypy/pypy/issues/3050/subprocesspopen-only-accepts-sequences",
),
),
False,
],
ids=("as_iterator", "as_list"),
)
@pytest.mark.parametrize("env_mapping", [None, os.environ, ImmutableDict(os.environ)])
@pytest.mark.parametrize("with_cwd", [True, False])
def test_subprocess_basic(
sentry_init,
capture_events,
monkeypatch,
positional_args,
iterator,
env_mapping,
with_cwd,
):
monkeypatch.setenv("FOO", "bar")
old_environ = dict(os.environ)
sentry_init(integrations=[StdlibIntegration()], traces_sample_rate=1.0)
events = capture_events()
with start_transaction(name="foo") as transaction:
args = [
sys.executable,
"-c",
"import os; "
"import sentry_sdk; "
"from sentry_sdk.integrations.stdlib import get_subprocess_traceparent_headers; "
"sentry_sdk.init(); "
"assert os.environ['FOO'] == 'bar'; "
"print(dict(get_subprocess_traceparent_headers()))",
]
if iterator:
args = iter(args)
if positional_args:
a = (
args,
0, # bufsize
None, # executable
None, # stdin
subprocess.PIPE, # stdout
None, # stderr
None, # preexec_fn
False, # close_fds
False, # shell
os.getcwd() if with_cwd else None, # cwd
)
if env_mapping is not None:
a += (env_mapping,)
popen = subprocess.Popen(*a)
else:
kw = {"args": args, "stdout": subprocess.PIPE}
if with_cwd:
kw["cwd"] = os.getcwd()
if env_mapping is not None:
kw["env"] = env_mapping
popen = subprocess.Popen(**kw)
output, unused_err = popen.communicate()
retcode = popen.poll()
assert not retcode
assert os.environ == old_environ
assert transaction.trace_id in str(output)
capture_message("hi")
(
transaction_event,
message_event,
) = events
assert message_event["message"] == "hi"
data = {"subprocess.cwd": os.getcwd()} if with_cwd else {}
(crumb,) = message_event["breadcrumbs"]["values"]
assert crumb == {
"category": "subprocess",
"data": data,
"message": crumb["message"],
"timestamp": crumb["timestamp"],
"type": "subprocess",
}
if not iterator:
assert crumb["message"].startswith(sys.executable + " ")
assert transaction_event["type"] == "transaction"
(
subprocess_init_span,
subprocess_communicate_span,
subprocess_wait_span,
) = transaction_event["spans"]
assert (
subprocess_init_span["op"],
subprocess_communicate_span["op"],
subprocess_wait_span["op"],
) == ("subprocess", "subprocess.communicate", "subprocess.wait")
# span hierarchy
assert (
subprocess_wait_span["parent_span_id"] == subprocess_communicate_span["span_id"]
)
assert (
subprocess_communicate_span["parent_span_id"]
== subprocess_init_span["parent_span_id"]
== transaction_event["contexts"]["trace"]["span_id"]
)
# common data
assert (
subprocess_init_span["tags"]["subprocess.pid"]
== subprocess_wait_span["tags"]["subprocess.pid"]
== subprocess_communicate_span["tags"]["subprocess.pid"]
)
# data of init span
assert subprocess_init_span.get("data", {}) == data
if iterator:
assert "iterator" in subprocess_init_span["description"]
assert subprocess_init_span["description"].startswith("<")
else:
assert sys.executable + " -c" in subprocess_init_span["description"]
def test_subprocess_invalid_args(sentry_init):
sentry_init(integrations=[StdlibIntegration()])
with pytest.raises(TypeError) as excinfo:
subprocess.Popen(1)
assert "'int' object is not iterable" in str(excinfo.value)
sentry-python-1.39.2/tests/integrations/strawberry/ 0000775 0000000 0000000 00000000000 14547447232 0022541 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/strawberry/__init__.py 0000664 0000000 0000000 00000000000 14547447232 0024640 0 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/strawberry/test_strawberry_py3.py 0000664 0000000 0000000 00000045153 14547447232 0027161 0 ustar 00root root 0000000 0000000 import pytest
strawberry = pytest.importorskip("strawberry")
pytest.importorskip("fastapi")
pytest.importorskip("flask")
from unittest import mock
from fastapi import FastAPI
from fastapi.testclient import TestClient
from flask import Flask
from strawberry.extensions.tracing import (
SentryTracingExtension,
SentryTracingExtensionSync,
)
from strawberry.fastapi import GraphQLRouter
from strawberry.flask.views import GraphQLView
from sentry_sdk.consts import OP
from sentry_sdk.integrations.fastapi import FastApiIntegration
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.starlette import StarletteIntegration
from sentry_sdk.integrations.strawberry import (
StrawberryIntegration,
SentryAsyncExtension,
SentrySyncExtension,
)
parameterize_strawberry_test = pytest.mark.parametrize(
"client_factory,async_execution,framework_integrations",
(
(
"async_app_client_factory",
True,
[FastApiIntegration(), StarletteIntegration()],
),
("sync_app_client_factory", False, [FlaskIntegration()]),
),
)
@strawberry.type
class Query:
@strawberry.field
def hello(self) -> str:
return "Hello World"
@strawberry.field
def error(self) -> int:
return 1 / 0
@strawberry.type
class Mutation:
@strawberry.mutation
def change(self, attribute: str) -> str:
return attribute
@pytest.fixture
def async_app_client_factory():
def create_app(schema):
async_app = FastAPI()
async_app.include_router(GraphQLRouter(schema), prefix="/graphql")
return TestClient(async_app)
return create_app
@pytest.fixture
def sync_app_client_factory():
def create_app(schema):
sync_app = Flask(__name__)
sync_app.add_url_rule(
"/graphql",
view_func=GraphQLView.as_view("graphql_view", schema=schema),
)
return sync_app.test_client()
return create_app
def test_async_execution_uses_async_extension(sentry_init):
sentry_init(integrations=[StrawberryIntegration(async_execution=True)])
with mock.patch(
"sentry_sdk.integrations.strawberry._get_installed_modules",
return_value={"flask": "2.3.3"},
):
# actual installed modules should not matter, the explicit option takes
# precedence
schema = strawberry.Schema(Query)
assert SentryAsyncExtension in schema.extensions
def test_sync_execution_uses_sync_extension(sentry_init):
sentry_init(integrations=[StrawberryIntegration(async_execution=False)])
with mock.patch(
"sentry_sdk.integrations.strawberry._get_installed_modules",
return_value={"fastapi": "0.103.1", "starlette": "0.27.0"},
):
# actual installed modules should not matter, the explicit option takes
# precedence
schema = strawberry.Schema(Query)
assert SentrySyncExtension in schema.extensions
def test_infer_execution_type_from_installed_packages_async(sentry_init):
sentry_init(integrations=[StrawberryIntegration()])
with mock.patch(
"sentry_sdk.integrations.strawberry._get_installed_modules",
return_value={"fastapi": "0.103.1", "starlette": "0.27.0"},
):
schema = strawberry.Schema(Query)
assert SentryAsyncExtension in schema.extensions
def test_infer_execution_type_from_installed_packages_sync(sentry_init):
sentry_init(integrations=[StrawberryIntegration()])
with mock.patch(
"sentry_sdk.integrations.strawberry._get_installed_modules",
return_value={"flask": "2.3.3"},
):
schema = strawberry.Schema(Query)
assert SentrySyncExtension in schema.extensions
def test_replace_existing_sentry_async_extension(sentry_init):
sentry_init(integrations=[StrawberryIntegration()])
schema = strawberry.Schema(Query, extensions=[SentryTracingExtension])
assert SentryTracingExtension not in schema.extensions
assert SentrySyncExtension not in schema.extensions
assert SentryAsyncExtension in schema.extensions
def test_replace_existing_sentry_sync_extension(sentry_init):
sentry_init(integrations=[StrawberryIntegration()])
schema = strawberry.Schema(Query, extensions=[SentryTracingExtensionSync])
assert SentryTracingExtensionSync not in schema.extensions
assert SentryAsyncExtension not in schema.extensions
assert SentrySyncExtension in schema.extensions
@parameterize_strawberry_test
def test_capture_request_if_available_and_send_pii_is_on(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
send_default_pii=True,
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "query ErrorQuery { error }"
client.post("/graphql", json={"query": query, "operationName": "ErrorQuery"})
assert len(events) == 1
(error_event,) = events
assert error_event["exception"]["values"][0]["mechanism"]["type"] == "strawberry"
assert error_event["request"]["api_target"] == "graphql"
assert error_event["request"]["data"] == {
"query": query,
"operationName": "ErrorQuery",
}
assert error_event["contexts"]["response"] == {
"data": {
"data": None,
"errors": [
{
"message": "division by zero",
"locations": [{"line": 1, "column": 20}],
"path": ["error"],
}
],
}
}
assert len(error_event["breadcrumbs"]["values"]) == 1
assert error_event["breadcrumbs"]["values"][0]["category"] == "graphql.operation"
assert error_event["breadcrumbs"]["values"][0]["data"] == {
"operation_name": "ErrorQuery",
"operation_type": "query",
}
@parameterize_strawberry_test
def test_do_not_capture_request_if_send_pii_is_off(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "query ErrorQuery { error }"
client.post("/graphql", json={"query": query, "operationName": "ErrorQuery"})
assert len(events) == 1
(error_event,) = events
assert error_event["exception"]["values"][0]["mechanism"]["type"] == "strawberry"
assert "data" not in error_event["request"]
assert "response" not in error_event["contexts"]
assert len(error_event["breadcrumbs"]["values"]) == 1
assert error_event["breadcrumbs"]["values"][0]["category"] == "graphql.operation"
assert error_event["breadcrumbs"]["values"][0]["data"] == {
"operation_name": "ErrorQuery",
"operation_type": "query",
}
@parameterize_strawberry_test
def test_breadcrumb_no_operation_name(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "{ error }"
client.post("/graphql", json={"query": query})
assert len(events) == 1
(error_event,) = events
assert len(error_event["breadcrumbs"]["values"]) == 1
assert error_event["breadcrumbs"]["values"][0]["category"] == "graphql.operation"
assert error_event["breadcrumbs"]["values"][0]["data"] == {
"operation_name": None,
"operation_type": "query",
}
@parameterize_strawberry_test
def test_capture_transaction_on_error(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
send_default_pii=True,
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
traces_sample_rate=1,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "query ErrorQuery { error }"
client.post("/graphql", json={"query": query, "operationName": "ErrorQuery"})
assert len(events) == 2
(_, transaction_event) = events
if async_execution:
assert transaction_event["transaction"] == "/graphql"
else:
assert transaction_event["transaction"] == "graphql_view"
assert transaction_event["spans"]
query_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_QUERY
]
assert len(query_spans) == 1, "exactly one query span expected"
query_span = query_spans[0]
assert query_span["description"] == "query ErrorQuery"
assert query_span["data"]["graphql.operation.type"] == "query"
assert query_span["data"]["graphql.operation.name"] == "ErrorQuery"
assert query_span["data"]["graphql.document"] == query
assert query_span["data"]["graphql.resource_name"]
parse_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_PARSE
]
assert len(parse_spans) == 1, "exactly one parse span expected"
parse_span = parse_spans[0]
assert parse_span["parent_span_id"] == query_span["span_id"]
assert parse_span["description"] == "parsing"
validate_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_VALIDATE
]
assert len(validate_spans) == 1, "exactly one validate span expected"
validate_span = validate_spans[0]
assert validate_span["parent_span_id"] == query_span["span_id"]
assert validate_span["description"] == "validation"
resolve_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_RESOLVE
]
assert len(resolve_spans) == 1, "exactly one resolve span expected"
resolve_span = resolve_spans[0]
assert resolve_span["parent_span_id"] == query_span["span_id"]
assert resolve_span["description"] == "resolving Query.error"
assert resolve_span["data"] == {
"graphql.field_name": "error",
"graphql.parent_type": "Query",
"graphql.field_path": "Query.error",
"graphql.path": "error",
}
@parameterize_strawberry_test
def test_capture_transaction_on_success(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
traces_sample_rate=1,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "query GreetingQuery { hello }"
client.post("/graphql", json={"query": query, "operationName": "GreetingQuery"})
assert len(events) == 1
(transaction_event,) = events
if async_execution:
assert transaction_event["transaction"] == "/graphql"
else:
assert transaction_event["transaction"] == "graphql_view"
assert transaction_event["spans"]
query_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_QUERY
]
assert len(query_spans) == 1, "exactly one query span expected"
query_span = query_spans[0]
assert query_span["description"] == "query GreetingQuery"
assert query_span["data"]["graphql.operation.type"] == "query"
assert query_span["data"]["graphql.operation.name"] == "GreetingQuery"
assert query_span["data"]["graphql.document"] == query
assert query_span["data"]["graphql.resource_name"]
parse_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_PARSE
]
assert len(parse_spans) == 1, "exactly one parse span expected"
parse_span = parse_spans[0]
assert parse_span["parent_span_id"] == query_span["span_id"]
assert parse_span["description"] == "parsing"
validate_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_VALIDATE
]
assert len(validate_spans) == 1, "exactly one validate span expected"
validate_span = validate_spans[0]
assert validate_span["parent_span_id"] == query_span["span_id"]
assert validate_span["description"] == "validation"
resolve_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_RESOLVE
]
assert len(resolve_spans) == 1, "exactly one resolve span expected"
resolve_span = resolve_spans[0]
assert resolve_span["parent_span_id"] == query_span["span_id"]
assert resolve_span["description"] == "resolving Query.hello"
assert resolve_span["data"] == {
"graphql.field_name": "hello",
"graphql.parent_type": "Query",
"graphql.field_path": "Query.hello",
"graphql.path": "hello",
}
@parameterize_strawberry_test
def test_transaction_no_operation_name(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
traces_sample_rate=1,
)
events = capture_events()
schema = strawberry.Schema(Query)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = "{ hello }"
client.post("/graphql", json={"query": query})
assert len(events) == 1
(transaction_event,) = events
if async_execution:
assert transaction_event["transaction"] == "/graphql"
else:
assert transaction_event["transaction"] == "graphql_view"
assert transaction_event["spans"]
query_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_QUERY
]
assert len(query_spans) == 1, "exactly one query span expected"
query_span = query_spans[0]
assert query_span["description"] == "query"
assert query_span["data"]["graphql.operation.type"] == "query"
assert query_span["data"]["graphql.operation.name"] is None
assert query_span["data"]["graphql.document"] == query
assert query_span["data"]["graphql.resource_name"]
parse_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_PARSE
]
assert len(parse_spans) == 1, "exactly one parse span expected"
parse_span = parse_spans[0]
assert parse_span["parent_span_id"] == query_span["span_id"]
assert parse_span["description"] == "parsing"
validate_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_VALIDATE
]
assert len(validate_spans) == 1, "exactly one validate span expected"
validate_span = validate_spans[0]
assert validate_span["parent_span_id"] == query_span["span_id"]
assert validate_span["description"] == "validation"
resolve_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_RESOLVE
]
assert len(resolve_spans) == 1, "exactly one resolve span expected"
resolve_span = resolve_spans[0]
assert resolve_span["parent_span_id"] == query_span["span_id"]
assert resolve_span["description"] == "resolving Query.hello"
assert resolve_span["data"] == {
"graphql.field_name": "hello",
"graphql.parent_type": "Query",
"graphql.field_path": "Query.hello",
"graphql.path": "hello",
}
@parameterize_strawberry_test
def test_transaction_mutation(
request,
sentry_init,
capture_events,
client_factory,
async_execution,
framework_integrations,
):
sentry_init(
integrations=[
StrawberryIntegration(async_execution=async_execution),
]
+ framework_integrations,
traces_sample_rate=1,
)
events = capture_events()
schema = strawberry.Schema(Query, mutation=Mutation)
client_factory = request.getfixturevalue(client_factory)
client = client_factory(schema)
query = 'mutation Change { change(attribute: "something") }'
client.post("/graphql", json={"query": query})
assert len(events) == 1
(transaction_event,) = events
if async_execution:
assert transaction_event["transaction"] == "/graphql"
else:
assert transaction_event["transaction"] == "graphql_view"
assert transaction_event["spans"]
query_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_MUTATION
]
assert len(query_spans) == 1, "exactly one mutation span expected"
query_span = query_spans[0]
assert query_span["description"] == "mutation"
assert query_span["data"]["graphql.operation.type"] == "mutation"
assert query_span["data"]["graphql.operation.name"] is None
assert query_span["data"]["graphql.document"] == query
assert query_span["data"]["graphql.resource_name"]
parse_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_PARSE
]
assert len(parse_spans) == 1, "exactly one parse span expected"
parse_span = parse_spans[0]
assert parse_span["parent_span_id"] == query_span["span_id"]
assert parse_span["description"] == "parsing"
validate_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_VALIDATE
]
assert len(validate_spans) == 1, "exactly one validate span expected"
validate_span = validate_spans[0]
assert validate_span["parent_span_id"] == query_span["span_id"]
assert validate_span["description"] == "validation"
resolve_spans = [
span for span in transaction_event["spans"] if span["op"] == OP.GRAPHQL_RESOLVE
]
assert len(resolve_spans) == 1, "exactly one resolve span expected"
resolve_span = resolve_spans[0]
assert resolve_span["parent_span_id"] == query_span["span_id"]
assert resolve_span["description"] == "resolving Mutation.change"
assert resolve_span["data"] == {
"graphql.field_name": "change",
"graphql.parent_type": "Mutation",
"graphql.field_path": "Mutation.change",
"graphql.path": "change",
}
sentry-python-1.39.2/tests/integrations/test_gnu_backtrace.py 0000664 0000000 0000000 00000025201 14547447232 0024536 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk import capture_exception
from sentry_sdk.integrations.gnu_backtrace import GnuBacktraceIntegration
LINES = r"""
0. clickhouse-server(StackTrace::StackTrace()+0x16) [0x99d31a6]
1. clickhouse-server(DB::Exception::Exception(std::__cxx11::basic_string, std::allocator > const&, int)+0x22) [0x372c822]
10. clickhouse-server(DB::ActionsVisitor::visit(std::shared_ptr const&)+0x1a12) [0x6ae45d2]
10. clickhouse-server(DB::InterpreterSelectQuery::executeImpl(DB::InterpreterSelectQuery::Pipeline&, std::shared_ptr const&, bool)+0x11af) [0x75c68ff]
10. clickhouse-server(ThreadPoolImpl::worker(std::_List_iterator)+0x1ab) [0x6f90c1b]
11. clickhouse-server() [0xae06ddf]
11. clickhouse-server(DB::ExpressionAnalyzer::getRootActions(std::shared_ptr const&, bool, std::shared_ptr&, bool)+0xdb) [0x6a0a63b]
11. clickhouse-server(DB::InterpreterSelectQuery::InterpreterSelectQuery(std::shared_ptr const&, DB::Context const&, std::shared_ptr const&, std::shared_ptr const&, std::vector, std::allocator >, std::allocator, std::allocator > > > const&, DB::QueryProcessingStage::Enum, unsigned long, bool)+0x5e6) [0x75c7516]
12. /lib/x86_64-linux-gnu/libpthread.so.0(+0x8184) [0x7f3bbc568184]
12. clickhouse-server(DB::ExpressionAnalyzer::getConstActions()+0xc9) [0x6a0b059]
12. clickhouse-server(DB::InterpreterSelectQuery::InterpreterSelectQuery(std::shared_ptr const&, DB::Context const&, std::vector, std::allocator >, std::allocator, std::allocator > > > const&, DB::QueryProcessingStage::Enum, unsigned long, bool)+0x56) [0x75c8276]
13. /lib/x86_64-linux-gnu/libc.so.6(clone+0x6d) [0x7f3bbbb8303d]
13. clickhouse-server(DB::InterpreterSelectWithUnionQuery::InterpreterSelectWithUnionQuery(std::shared_ptr const&, DB::Context const&, std::vector, std::allocator >, std::allocator, std::allocator > > > const&, DB::QueryProcessingStage::Enum, unsigned long, bool)+0x7e7) [0x75d4067]
13. clickhouse-server(DB::evaluateConstantExpression(std::shared_ptr const&, DB::Context const&)+0x3ed) [0x656bfdd]
14. clickhouse-server(DB::InterpreterFactory::get(std::shared_ptr&, DB::Context&, DB::QueryProcessingStage::Enum)+0x3a8) [0x75b0298]
14. clickhouse-server(DB::makeExplicitSet(DB::ASTFunction const*, DB::Block const&, bool, DB::Context const&, DB::SizeLimits const&, std::unordered_map, DB::PreparedSetKey::Hash, std::equal_to, std::allocator > > >&)+0x382) [0x6adf692]
15. clickhouse-server() [0x7664c79]
15. clickhouse-server(DB::ActionsVisitor::makeSet(DB::ASTFunction const*, DB::Block const&)+0x2a7) [0x6ae2227]
16. clickhouse-server(DB::ActionsVisitor::visit(std::shared_ptr const&)+0x1973) [0x6ae4533]
16. clickhouse-server(DB::executeQuery(std::__cxx11::basic_string, std::allocator > const&, DB::Context&, bool, DB::QueryProcessingStage::Enum)+0x8a) [0x76669fa]
17. clickhouse-server(DB::ActionsVisitor::visit(std::shared_ptr const&)+0x1324) [0x6ae3ee4]
17. clickhouse-server(DB::TCPHandler::runImpl()+0x4b9) [0x30973c9]
18. clickhouse-server(DB::ExpressionAnalyzer::getRootActions(std::shared_ptr const&, bool, std::shared_ptr&, bool)+0xdb) [0x6a0a63b]
18. clickhouse-server(DB::TCPHandler::run()+0x2b) [0x30985ab]
19. clickhouse-server(DB::ExpressionAnalyzer::appendGroupBy(DB::ExpressionActionsChain&, bool)+0x100) [0x6a0b4f0]
19. clickhouse-server(Poco::Net::TCPServerConnection::start()+0xf) [0x9b53e4f]
2. clickhouse-server(DB::FunctionTuple::getReturnTypeImpl(std::vector, std::allocator > > const&) const+0x122) [0x3a2a0f2]
2. clickhouse-server(DB::readException(DB::Exception&, DB::ReadBuffer&, std::__cxx11::basic_string, std::allocator > const&)+0x21f) [0x6fb253f]
2. clickhouse-server(void DB::readDateTimeTextFallback(long&, DB::ReadBuffer&, DateLUTImpl const&)+0x318) [0x99ffed8]
20. clickhouse-server(DB::InterpreterSelectQuery::analyzeExpressions(DB::QueryProcessingStage::Enum, bool)+0x364) [0x6437fa4]
20. clickhouse-server(Poco::Net::TCPServerDispatcher::run()+0x16a) [0x9b5422a]
21. clickhouse-server(DB::InterpreterSelectQuery::executeImpl(DB::InterpreterSelectQuery::Pipeline&, std::shared_ptr const&, bool)+0x36d) [0x643c28d]
21. clickhouse-server(Poco::PooledThread::run()+0x77) [0x9c70f37]
22. clickhouse-server(DB::InterpreterSelectQuery::executeWithMultipleStreams()+0x50) [0x643ecd0]
22. clickhouse-server(Poco::ThreadImpl::runnableEntry(void*)+0x38) [0x9c6caa8]
23. clickhouse-server() [0xa3c68cf]
23. clickhouse-server(DB::InterpreterSelectWithUnionQuery::executeWithMultipleStreams()+0x6c) [0x644805c]
24. /lib/x86_64-linux-gnu/libpthread.so.0(+0x8184) [0x7fe839d2d184]
24. clickhouse-server(DB::InterpreterSelectWithUnionQuery::execute()+0x38) [0x6448658]
25. /lib/x86_64-linux-gnu/libc.so.6(clone+0x6d) [0x7fe83934803d]
25. clickhouse-server() [0x65744ef]
26. clickhouse-server(DB::executeQuery(std::__cxx11::basic_string, std::allocator > const&, DB::Context&, bool, DB::QueryProcessingStage::Enum, bool)+0x81) [0x6576141]
27. clickhouse-server(DB::TCPHandler::runImpl()+0x752) [0x3739f82]
28. clickhouse-server(DB::TCPHandler::run()+0x2b) [0x373a5cb]
29. clickhouse-server(Poco::Net::TCPServerConnection::start()+0xf) [0x708e63f]
3. clickhouse-server(DB::Connection::receiveException()+0x81) [0x67d3ad1]
3. clickhouse-server(DB::DefaultFunctionBuilder::getReturnTypeImpl(std::vector > const&) const+0x223) [0x38ac3b3]
3. clickhouse-server(DB::FunctionComparison::executeDateOrDateTimeOrEnumOrUUIDWithConstString(DB::Block&, unsigned long, DB::IColumn const*, DB::IColumn const*, std::shared_ptr const&, std::shared_ptr const&, bool, unsigned long)+0xbb3) [0x411dee3]
30. clickhouse-server(Poco::Net::TCPServerDispatcher::run()+0xe9) [0x708ed79]
31. clickhouse-server(Poco::PooledThread::run()+0x81) [0x7142011]
4. clickhouse-server(DB::Connection::receivePacket()+0x767) [0x67d9cd7]
4. clickhouse-server(DB::FunctionBuilderImpl::getReturnTypeWithoutLowCardinality(std::vector > const&) const+0x75) [0x6869635]
4. clickhouse-server(DB::FunctionComparison::executeImpl(DB::Block&, std::vector > const&, unsigned long, unsigned long)+0x576) [0x41ab006]
5. clickhouse-server(DB::FunctionBuilderImpl::getReturnType(std::vector > const&) const+0x350) [0x6869f10]
5. clickhouse-server(DB::MultiplexedConnections::receivePacket()+0x7e) [0x67e7ede]
5. clickhouse-server(DB::PreparedFunctionImpl::execute(DB::Block&, std::vector > const&, unsigned long, unsigned long)+0x3e2) [0x7933492]
6. clickhouse-server(DB::ExpressionAction::execute(DB::Block&, std::unordered_map, std::allocator >, unsigned long, std::hash, std::allocator > >, std::equal_to, std::allocator > >, std::allocator, std::allocator > const, unsigned long> > >&) const+0x61a) [0x7ae093a]
6. clickhouse-server(DB::FunctionBuilderImpl::build(std::vector > const&) const+0x3c) [0x38accfc]
6. clickhouse-server(DB::RemoteBlockInputStream::readImpl()+0x87) [0x631da97]
7. clickhouse-server(DB::ExpressionActions::addImpl(DB::ExpressionAction, std::vector, std::allocator >, std::allocator, std::allocator > > >&)+0x552) [0x6a00052]
7. clickhouse-server(DB::ExpressionActions::execute(DB::Block&) const+0xe6) [0x7ae1e06]
7. clickhouse-server(DB::IBlockInputStream::read()+0x178) [0x63075e8]
8. clickhouse-server(DB::ExpressionActions::add(DB::ExpressionAction const&, std::vector, std::allocator >, std::allocator, std::allocator > > >&)+0x42) [0x6a00422]
8. clickhouse-server(DB::FilterBlockInputStream::FilterBlockInputStream(std::shared_ptr const&, std::shared_ptr const&, std::__cxx11::basic_string, std::allocator > const&, bool)+0x711) [0x79970d1]
8. clickhouse-server(DB::ParallelInputsProcessor::thread(std::shared_ptr, unsigned long)+0x2f1) [0x64467c1]
9. clickhouse-server() [0x75bd5a3]
9. clickhouse-server(DB::ScopeStack::addAction(DB::ExpressionAction const&)+0xd2) [0x6ae04d2]
9. clickhouse-server(ThreadFromGlobalPool::ThreadFromGlobalPool::process()::{lambda()#1}>(DB::ParallelInputsProcessor::process()::{lambda()#1}&&)::{lambda()#1}::operator()() const+0x6d) [0x644722d]
"""
@pytest.mark.parametrize("input", LINES.strip().splitlines())
def test_basic(sentry_init, capture_events, input):
sentry_init(integrations=[GnuBacktraceIntegration()])
events = capture_events()
try:
raise ValueError(input)
except ValueError:
capture_exception()
(event,) = events
(exception,) = event["exception"]["values"]
assert (
exception["value"]
== ""
)
(frame,) = exception["stacktrace"]["frames"][1:]
if frame.get("function") is None:
assert "clickhouse-server()" in input or "pthread" in input
else:
assert ")" not in frame["function"] and "(" not in frame["function"]
assert frame["function"] in input
sentry-python-1.39.2/tests/integrations/threading/ 0000775 0000000 0000000 00000000000 14547447232 0022302 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/threading/test_threading.py 0000664 0000000 0000000 00000013132 14547447232 0025660 0 ustar 00root root 0000000 0000000 import gc
import sys
from threading import Thread
try:
from concurrent import futures
except ImportError:
futures = None
import pytest
import sentry_sdk
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()], []])
def test_handles_exceptions(sentry_init, capture_events, integrations):
sentry_init(default_integrations=False, integrations=integrations)
events = capture_events()
def crash():
1 / 0
t = Thread(target=crash)
t.start()
t.join()
if integrations:
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "threading"
assert not exception["mechanism"]["handled"]
else:
assert not events
@pytest.mark.forked
@pytest.mark.parametrize("propagate_hub", (True, False))
def test_propagates_hub(sentry_init, capture_events, propagate_hub):
sentry_init(
default_integrations=False,
integrations=[ThreadingIntegration(propagate_hub=propagate_hub)],
)
events = capture_events()
def stage1():
with configure_scope() as scope:
scope.set_tag("stage1", "true")
t = Thread(target=stage2)
t.start()
t.join()
def stage2():
1 / 0
t = Thread(target=stage1)
t.start()
t.join()
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "threading"
assert not exception["mechanism"]["handled"]
if propagate_hub:
assert event["tags"]["stage1"] == "true"
else:
assert "stage1" not in event.get("tags", {})
@pytest.mark.skipif(
futures is None,
reason="ThreadPool was added in 3.2",
)
@pytest.mark.parametrize("propagate_hub", (True, False))
def test_propagates_threadpool_hub(sentry_init, capture_events, propagate_hub):
sentry_init(
traces_sample_rate=1.0,
integrations=[ThreadingIntegration(propagate_hub=propagate_hub)],
)
events = capture_events()
def double(number):
with sentry_sdk.start_span(op="task", description=str(number)):
return number * 2
with sentry_sdk.start_transaction(name="test_handles_threadpool"):
with futures.ThreadPoolExecutor(max_workers=1) as executor:
tasks = [executor.submit(double, number) for number in [1, 2, 3, 4]]
for future in futures.as_completed(tasks):
print("Getting future value!", future.result())
sentry_sdk.flush()
if propagate_hub:
assert len(events) == 1
(event,) = events
assert event["spans"][0]["trace_id"] == event["spans"][1]["trace_id"]
assert event["spans"][1]["trace_id"] == event["spans"][2]["trace_id"]
assert event["spans"][2]["trace_id"] == event["spans"][3]["trace_id"]
assert event["spans"][3]["trace_id"] == event["spans"][0]["trace_id"]
else:
(event,) = events
assert len(event["spans"]) == 0
def test_circular_references(sentry_init, request):
sentry_init(default_integrations=False, integrations=[ThreadingIntegration()])
gc.collect()
gc.disable()
request.addfinalizer(gc.enable)
class MyThread(Thread):
def run(self):
pass
t = MyThread()
t.start()
t.join()
del t
assert not gc.collect()
@pytest.mark.forked
def test_double_patching(sentry_init, capture_events):
sentry_init(default_integrations=False, integrations=[ThreadingIntegration()])
events = capture_events()
# XXX: Workaround for race condition in the py library's magic import
# system (py is a dependency of pytest)
capture_message("hi")
del events[:]
class MyThread(Thread):
def run(self):
1 / 0
ts = []
for _ in range(10):
t = MyThread()
t.start()
ts.append(t)
for t in ts:
t.join()
assert len(events) == 10
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"
sentry-python-1.39.2/tests/integrations/tornado/ 0000775 0000000 0000000 00000000000 14547447232 0022003 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/tornado/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024115 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("tornado")
sentry-python-1.39.2/tests/integrations/tornado/test_tornado.py 0000664 0000000 0000000 00000032044 14547447232 0025065 0 ustar 00root root 0000000 0000000 import json
import pytest
from sentry_sdk import configure_scope, start_transaction, capture_message
from sentry_sdk.integrations.tornado import TornadoIntegration
from tornado.web import RequestHandler, Application, HTTPError
from tornado.testing import AsyncHTTPTestCase
@pytest.fixture
def tornado_testcase(request):
# Take the unittest class provided by tornado and manually call its setUp
# and tearDown.
#
# The pytest plugins for tornado seem too complicated to use, as they for
# some reason assume I want to write my tests in async code.
def inner(app):
class TestBogus(AsyncHTTPTestCase):
def get_app(self):
return app
def bogustest(self):
# We need to pass a valid test method name to the ctor, so this
# is the method. It does nothing.
pass
self = TestBogus("bogustest")
self.setUp()
request.addfinalizer(self.tearDown)
return self
return inner
class CrashingHandler(RequestHandler):
def get(self):
with configure_scope() as scope:
scope.set_tag("foo", "42")
1 / 0
def post(self):
with configure_scope() as scope:
scope.set_tag("foo", "43")
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:
scope.set_tag("foo", "42")
return b"hello"
async def post(self):
with configure_scope() as scope:
scope.set_tag("foo", "43")
return b"hello"
def test_basic(tornado_testcase, sentry_init, capture_events):
sentry_init(integrations=[TornadoIntegration()], send_default_pii=True)
events = capture_events()
client = tornado_testcase(Application([(r"/hi", CrashingHandler)]))
response = client.fetch(
"/hi?foo=bar", headers={"Cookie": "name=value; name2=value2; name3=value3"}
)
assert response.code == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert exception["mechanism"]["type"] == "tornado"
request = event["request"]
host = request["headers"]["Host"]
assert event["request"] == {
"env": {"REMOTE_ADDR": "127.0.0.1"},
"headers": {
"Accept-Encoding": "gzip",
"Connection": "close",
"Cookie": "name=value; name2=value2; name3=value3",
**request["headers"],
},
"cookies": {"name": "value", "name2": "value2", "name3": "value3"},
"method": "GET",
"query_string": "foo=bar",
"url": "http://{host}/hi".format(host=host),
}
assert event["tags"] == {"foo": "42"}
assert (
event["transaction"]
== "tests.integrations.tornado.test_tornado.CrashingHandler.get"
)
assert event["transaction_info"] == {"source": "component"}
with configure_scope() as scope:
assert not scope._tags
@pytest.mark.parametrize(
"handler,code",
[
(CrashingHandler, 500),
(HelloHandler, 200),
],
)
def test_transactions(tornado_testcase, sentry_init, capture_events, handler, code):
sentry_init(integrations=[TornadoIntegration()], traces_sample_rate=1.0, debug=True)
events = capture_events()
client = tornado_testcase(Application([(r"/hi", handler)]))
with start_transaction(name="client") as span:
pass
response = client.fetch(
"/hi", method="POST", body=b"heyoo", headers=dict(span.iter_headers())
)
assert response.code == code
if code == 200:
client_tx, server_tx = events
server_error = None
else:
client_tx, server_error, server_tx = events
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"
assert (
server_error["transaction"]
== "tests.integrations.tornado.test_tornado.CrashingHandler.post"
)
assert server_error["transaction_info"] == {"source": "component"}
if code == 200:
assert (
server_tx["transaction"]
== "tests.integrations.tornado.test_tornado.HelloHandler.post"
)
else:
assert (
server_tx["transaction"]
== "tests.integrations.tornado.test_tornado.CrashingHandler.post"
)
assert server_tx["transaction_info"] == {"source": "component"}
assert server_tx["type"] == "transaction"
request = server_tx["request"]
host = request["headers"]["Host"]
assert server_tx["request"] == {
"env": {"REMOTE_ADDR": "127.0.0.1"},
"headers": {
"Accept-Encoding": "gzip",
"Connection": "close",
**request["headers"],
},
"method": "POST",
"query_string": "",
"data": {"heyoo": [""]},
"url": "http://{host}/hi".format(host=host),
}
assert (
client_tx["contexts"]["trace"]["trace_id"]
== server_tx["contexts"]["trace"]["trace_id"]
)
if server_error is not None:
assert (
server_error["contexts"]["trace"]["trace_id"]
== server_tx["contexts"]["trace"]["trace_id"]
)
def test_400_not_logged(tornado_testcase, sentry_init, capture_events):
sentry_init(integrations=[TornadoIntegration()])
events = capture_events()
class CrashingHandler(RequestHandler):
def get(self):
raise HTTPError(400, "Oops")
client = tornado_testcase(Application([(r"/", CrashingHandler)]))
response = client.fetch("/")
assert response.code == 400
assert not events
def test_user_auth(tornado_testcase, sentry_init, capture_events):
sentry_init(integrations=[TornadoIntegration()], send_default_pii=True)
events = capture_events()
class UserHandler(RequestHandler):
def get(self):
1 / 0
def get_current_user(self):
return 42
class NoUserHandler(RequestHandler):
def get(self):
1 / 0
client = tornado_testcase(
Application([(r"/auth", UserHandler), (r"/noauth", NoUserHandler)])
)
# has user
response = client.fetch("/auth")
assert response.code == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert event["user"] == {"is_authenticated": True}
events.clear()
# has no user
response = client.fetch("/noauth")
assert response.code == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
assert "user" not in event
def test_formdata(tornado_testcase, sentry_init, capture_events):
sentry_init(integrations=[TornadoIntegration()], send_default_pii=True)
events = capture_events()
class FormdataHandler(RequestHandler):
def post(self):
raise ValueError(json.dumps(sorted(self.request.body_arguments)))
client = tornado_testcase(Application([(r"/form", FormdataHandler)]))
response = client.fetch(
"/form?queryarg=1",
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body=b"field1=value1&field2=value2",
)
assert response.code == 500
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["value"] == '["field1", "field2"]'
assert event["request"]["data"] == {"field1": ["value1"], "field2": ["value2"]}
def test_json(tornado_testcase, sentry_init, capture_events):
sentry_init(integrations=[TornadoIntegration()], send_default_pii=True)
events = capture_events()
class FormdataHandler(RequestHandler):
def post(self):
raise ValueError(json.dumps(sorted(self.request.body_arguments)))
client = tornado_testcase(Application([(r"/form", FormdataHandler)]))
response = client.fetch(
"/form?queryarg=1",
method="POST",
headers={"Content-Type": "application/json"},
body=b"""
{"foo": {"bar": 42}}
""",
)
assert response.code == 500
(event,) = events
(exception,) = event["exception"]["values"]
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"
)
sentry-python-1.39.2/tests/integrations/trytond/ 0000775 0000000 0000000 00000000000 14547447232 0022040 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/trytond/__init__.py 0000664 0000000 0000000 00000000056 14547447232 0024152 0 ustar 00root root 0000000 0000000 import pytest
pytest.importorskip("trytond")
sentry-python-1.39.2/tests/integrations/trytond/test_trytond.py 0000664 0000000 0000000 00000007000 14547447232 0025151 0 ustar 00root root 0000000 0000000 import json
import unittest.mock
import pytest
import trytond
from trytond.exceptions import TrytonException as TrytondBaseException
from trytond.exceptions import UserError as TrytondUserError
from trytond.exceptions import UserWarning as TrytondUserWarning
from trytond.exceptions import LoginException
from trytond.wsgi import app as trytond_app
from werkzeug.test import Client
from sentry_sdk import last_event_id
from sentry_sdk.integrations.trytond import TrytondWSGIIntegration
@pytest.fixture(scope="function")
def app(sentry_init):
yield trytond_app
@pytest.fixture
def get_client(app):
def inner():
return Client(app)
return inner
@pytest.mark.parametrize(
"exception", [Exception("foo"), type("FooException", (Exception,), {})("bar")]
)
def test_exceptions_captured(
sentry_init, app, capture_exceptions, get_client, exception
):
sentry_init(integrations=[TrytondWSGIIntegration()])
exceptions = capture_exceptions()
unittest.mock.sentinel.exception = exception
@app.route("/exception")
def _(request):
raise unittest.mock.sentinel.exception
client = get_client()
_ = client.get("/exception")
(e,) = exceptions
assert e is exception
@pytest.mark.parametrize(
"exception",
[
TrytondUserError("title"),
TrytondUserWarning("title", "details"),
LoginException("title", "details"),
],
)
def test_trytonderrors_not_captured(
sentry_init, app, capture_exceptions, get_client, exception
):
sentry_init(integrations=[TrytondWSGIIntegration()])
exceptions = capture_exceptions()
unittest.mock.sentinel.exception = exception
@app.route("/usererror")
def _(request):
raise unittest.mock.sentinel.exception
client = get_client()
_ = client.get("/usererror")
assert not exceptions
@pytest.mark.skipif(
trytond.__version__.split(".") < ["5", "4"], reason="At least Trytond-5.4 required"
)
def test_rpc_error_page(sentry_init, app, capture_events, get_client):
"""Test that, after initializing the Trytond-SentrySDK integration
a custom error handler can be registered to the Trytond WSGI app so as to
inform the event identifiers to the Tryton RPC client"""
sentry_init(integrations=[TrytondWSGIIntegration()])
events = capture_events()
@app.route("/rpcerror", methods=["POST"])
def _(request):
raise Exception("foo")
@app.error_handler
def _(app, request, e):
if isinstance(e, TrytondBaseException):
return
else:
event_id = last_event_id()
data = TrytondUserError(str(event_id), str(e))
return app.make_response(request, data)
client = get_client()
# This would look like a natural Tryton RPC call
_data = dict(
id=42, # request sequence
method="class.method", # rpc call
params=[
[1234], # ids
["bar", "baz"], # values
dict( # context
client="12345678-9abc-def0-1234-56789abc",
groups=[1],
language="ca",
language_direction="ltr",
),
],
)
response = client.post(
"/rpcerror", content_type="application/json", data=json.dumps(_data)
)
(event,) = events
(content, status, headers) = response
data = json.loads(next(content))
assert status == "200 OK"
assert headers.get("Content-Type") == "application/json"
assert data == dict(id=42, error=["UserError", [event["event_id"], "foo", None]])
sentry-python-1.39.2/tests/integrations/wsgi/ 0000775 0000000 0000000 00000000000 14547447232 0021306 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/integrations/wsgi/test_wsgi.py 0000664 0000000 0000000 00000031665 14547447232 0023703 0 ustar 00root root 0000000 0000000 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
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
@pytest.fixture
def crashing_app():
def app(environ, start_response):
1 / 0
return app
class IterableApp(object):
def __init__(self, iterable):
self.iterable = iterable
def __call__(self, environ, start_response):
return self.iterable
class ExitingIterable(object):
def __init__(self, exc_func):
self._exc_func = exc_func
def __iter__(self):
return self
def __next__(self):
raise self._exc_func()
def next(self):
return type(self).__next__(self)
def test_basic(sentry_init, crashing_app, capture_events):
sentry_init(send_default_pii=True)
app = SentryWsgiMiddleware(crashing_app)
client = Client(app)
events = capture_events()
with pytest.raises(ZeroDivisionError):
client.get("/")
(event,) = events
assert event["transaction"] == "generic WSGI request"
assert event["request"] == {
"env": {"SERVER_NAME": "localhost", "SERVER_PORT": "80"},
"headers": {"Host": "localhost"},
"method": "GET",
"query_string": "",
"url": "http://localhost/",
}
@pytest.fixture(params=[0, None])
def test_systemexit_zero_is_ignored(sentry_init, capture_events, request):
zero_code = request.param
sentry_init(send_default_pii=True)
iterable = ExitingIterable(lambda: SystemExit(zero_code))
app = SentryWsgiMiddleware(IterableApp(iterable))
client = Client(app)
events = capture_events()
with pytest.raises(SystemExit):
client.get("/")
assert len(events) == 0
@pytest.fixture(params=["", "foo", 1, 2])
def test_systemexit_nonzero_is_captured(sentry_init, capture_events, request):
nonzero_code = request.param
sentry_init(send_default_pii=True)
iterable = ExitingIterable(lambda: SystemExit(nonzero_code))
app = SentryWsgiMiddleware(IterableApp(iterable))
client = Client(app)
events = capture_events()
with pytest.raises(SystemExit):
client.get("/")
(event,) = events
assert "exception" in event
exc = event["exception"]["values"][-1]
assert exc["type"] == "SystemExit"
assert exc["value"] == nonzero_code
assert event["level"] == "error"
def test_keyboard_interrupt_is_captured(sentry_init, capture_events):
sentry_init(send_default_pii=True)
iterable = ExitingIterable(lambda: KeyboardInterrupt())
app = SentryWsgiMiddleware(IterableApp(iterable))
client = Client(app)
events = capture_events()
with pytest.raises(KeyboardInterrupt):
client.get("/")
(event,) = events
assert "exception" in event
exc = event["exception"]["values"][-1]
assert exc["type"] == "KeyboardInterrupt"
assert exc["value"] == ""
assert event["level"] == "error"
def test_transaction_with_error(
sentry_init, crashing_app, capture_events, DictionaryContaining # noqa:N803
):
def dogpark(environ, start_response):
raise ValueError("Fetch aborted. The ball was not returned.")
sentry_init(send_default_pii=True, traces_sample_rate=1.0)
app = SentryWsgiMiddleware(dogpark)
client = Client(app)
events = capture_events()
with pytest.raises(ValueError):
client.get("http://dogs.are.great/sit/stay/rollover/")
error_event, envelope = events
assert error_event["transaction"] == "generic WSGI request"
assert error_event["contexts"]["trace"]["op"] == "http.server"
assert error_event["exception"]["values"][0]["type"] == "ValueError"
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."
)
assert envelope["type"] == "transaction"
# event trace context is a subset of envelope trace context
assert envelope["contexts"]["trace"] == DictionaryContaining(
error_event["contexts"]["trace"]
)
assert envelope["contexts"]["trace"]["status"] == "internal_error"
assert envelope["transaction"] == error_event["transaction"]
assert envelope["request"] == error_event["request"]
def test_transaction_no_error(
sentry_init, capture_events, DictionaryContaining # noqa:N803
):
def dogpark(environ, start_response):
start_response("200 OK", [])
return ["Go get the ball! Good dog!"]
sentry_init(send_default_pii=True, traces_sample_rate=1.0)
app = SentryWsgiMiddleware(dogpark)
client = Client(app)
events = capture_events()
client.get("/dogs/are/great/")
envelope = events[0]
assert envelope["type"] == "transaction"
assert envelope["transaction"] == "generic WSGI request"
assert envelope["contexts"]["trace"]["op"] == "http.server"
assert envelope["request"] == DictionaryContaining(
{"method": "GET", "url": "http://localhost/dogs/are/great/"}
)
def test_has_trace_if_performance_enabled(
sentry_init,
capture_events,
):
def dogpark(environ, start_response):
capture_message("Attempting to fetch the ball")
raise ValueError("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(ValueError):
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 ValueError("Fetch aborted. The ball was not returned.")
sentry_init()
app = SentryWsgiMiddleware(dogpark)
client = Client(app)
events = capture_events()
with pytest.raises(ValueError):
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 ValueError("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(ValueError):
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 ValueError("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(ValueError):
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, # noqa:N803
):
def app(environ, start_response):
start_response("200 OK", [])
return ["Go get the ball! Good dog!"]
traces_sampler = mock.Mock(return_value=True)
sentry_init(send_default_pii=True, traces_sampler=traces_sampler)
app = SentryWsgiMiddleware(app)
client = Client(app)
client.get("/dogs/are/great/")
traces_sampler.assert_any_call(
DictionaryContaining(
{
"wsgi_environ": DictionaryContaining(
{
"PATH_INFO": "/dogs/are/great/",
"REQUEST_METHOD": "GET",
},
),
}
)
)
def test_session_mode_defaults_to_request_mode_in_wsgi_handler(
capture_envelopes, sentry_init
):
"""
Test that ensures that even though the default `session_mode` for
auto_session_tracking is `application`, that flips to `request` when we are
in the WSGI handler
"""
def app(environ, start_response):
start_response("200 OK", [])
return ["Go get the ball! Good dog!"]
traces_sampler = mock.Mock(return_value=True)
sentry_init(send_default_pii=True, traces_sampler=traces_sampler)
app = SentryWsgiMiddleware(app)
envelopes = capture_envelopes()
client = Client(app)
client.get("/dogs/are/great/")
sentry_sdk.flush()
sess = envelopes[1]
assert len(sess.items) == 1
sess_event = sess.items[0].payload.json
aggregates = sess_event["aggregates"]
assert len(aggregates) == 1
assert aggregates[0]["exited"] == 1
def test_auto_session_tracking_with_aggregates(sentry_init, capture_envelopes):
"""
Test for correct session aggregates in auto session tracking.
"""
def sample_app(environ, start_response):
if environ["REQUEST_URI"] != "/dogs/are/great/":
1 / 0
start_response("200 OK", [])
return ["Go get the ball! Good dog!"]
traces_sampler = mock.Mock(return_value=True)
sentry_init(send_default_pii=True, traces_sampler=traces_sampler)
app = SentryWsgiMiddleware(sample_app)
envelopes = capture_envelopes()
assert len(envelopes) == 0
client = Client(app)
client.get("/dogs/are/great/")
client.get("/dogs/are/great/")
try:
client.get("/trigger/an/error/")
except ZeroDivisionError:
pass
sentry_sdk.flush()
count_item_types = Counter()
for envelope in envelopes:
count_item_types[envelope.items[0].type] += 1
assert count_item_types["transaction"] == 3
assert count_item_types["event"] == 1
assert count_item_types["sessions"] == 1
assert len(envelopes) == 5
session_aggregates = envelopes[-1].items[0].payload.json["aggregates"]
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
sentry-python-1.39.2/tests/test_api.py 0000664 0000000 0000000 00000007141 14547447232 0020014 0 ustar 00root root 0000000 0000000 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,sentry-sampled={}".format(
transaction.trace_id, "true" if transaction.sampled else "false"
)
# 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"
}
sentry-python-1.39.2/tests/test_basics.py 0000664 0000000 0000000 00000056133 14547447232 0020514 0 ustar 00root root 0000000 0000000 import logging
import os
import sys
import time
import pytest
from tests.conftest import patch_start_tracing_child
from sentry_sdk import (
Client,
push_scope,
configure_scope,
capture_event,
capture_exception,
capture_message,
start_transaction,
add_breadcrumb,
last_event_id,
Hub,
)
from sentry_sdk._compat import reraise, PY2
from sentry_sdk.integrations import (
_AUTO_ENABLING_INTEGRATIONS,
Integration,
setup_integrations,
)
from sentry_sdk.integrations.logging import LoggingIntegration
from sentry_sdk.integrations.redis import RedisIntegration
from sentry_sdk.scope import ( # noqa: F401
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 _redis_installed(): # type: () -> bool
"""
Determines whether Redis is installed.
"""
try:
import redis # noqa: F401
except ImportError:
return False
return True
class NoOpIntegration(Integration):
"""
A simple no-op integration for testing purposes.
"""
identifier = "noop"
@staticmethod
def setup_once(): # type: () -> None
pass
def __eq__(self, __value): # type: (object) -> bool
"""
All instances of NoOpIntegration should be considered equal to each other.
"""
return type(__value) == type(self)
def test_processors(sentry_init, capture_events):
sentry_init()
events = capture_events()
with configure_scope() as scope:
def error_processor(event, exc_info):
event["exception"]["values"][0]["value"] += " whatever"
return event
scope.add_error_processor(error_processor, ValueError)
try:
raise ValueError("aha!")
except Exception:
capture_exception()
(event,) = events
assert event["exception"]["values"][0]["value"] == "aha! whatever"
def test_auto_enabling_integrations_catches_import_error(sentry_init, caplog):
caplog.set_level(logging.DEBUG)
redis_index = _AUTO_ENABLING_INTEGRATIONS.index(
"sentry_sdk.integrations.redis.RedisIntegration"
) # 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 does not raise a DidNotEnable
# exception on import; rather, it raises the exception upon enabling.
if _AUTO_ENABLING_INTEGRATIONS[redis_index] == 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):
sentry_init()
events = capture_events()
try:
raise ValueError("aha!")
except Exception:
event_id = capture_exception()
int(event_id, 16)
assert len(event_id) == 32
(event,) = events
assert event["event_id"] == event_id
assert last_event_id() == event_id
assert Hub.current.last_event_id() == event_id
new_event_id = Hub.current.capture_event({"type": "transaction"})
assert new_event_id is not None
assert new_event_id != event_id
assert Hub.current.last_event_id() == event_id
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 = []
def record_lost_event(reason, data_category=None, item=None):
reports.append((reason, data_category))
def before_send(event, hint):
assert isinstance(hint["exc_info"][1], ValueError)
if not drop_events:
event["extra"] = {"foo": "bar"}
return event
def before_breadcrumb(crumb, hint):
assert hint == {"foo": 42}
if not drop_breadcrumbs:
crumb["data"] = {"foo": "bar"}
return crumb
sentry_init(before_send=before_send, before_breadcrumb=before_breadcrumb)
events = capture_events()
monkeypatch.setattr(
Hub.current.client.transport, "record_lost_event", record_lost_event
)
def do_this():
add_breadcrumb(message="Hello", hint={"foo": 42})
try:
raise ValueError("aha!")
except Exception:
capture_exception()
do_this()
drop_breadcrumbs = True
do_this()
assert not reports
drop_events = True
do_this()
assert reports == [("before_send", "error")]
normal, no_crumbs = events
assert normal["exception"]["values"][0]["type"] == "ValueError"
(crumb,) = normal["breadcrumbs"]["values"]
assert "timestamp" in crumb
assert crumb["message"] == "Hello"
assert crumb["data"] == {"foo": "bar"}
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}
def before_breadcrumb(crumb, hint):
assert crumb["foo"] == 42
assert hint == assert_hint
sentry_init(before_breadcrumb=before_breadcrumb)
add_breadcrumb(foo=42, hint=dict(bar=42))
add_breadcrumb(dict(foo=42), dict(bar=42))
add_breadcrumb(dict(foo=42), hint=dict(bar=42))
add_breadcrumb(crumb=dict(foo=42), hint=dict(bar=42))
assert_hint.clear()
add_breadcrumb(foo=42)
add_breadcrumb(crumb=dict(foo=42))
def test_push_scope(sentry_init, capture_events):
sentry_init()
events = capture_events()
with push_scope() as scope:
scope.level = "warning"
try:
1 / 0
except Exception as e:
capture_exception(e)
(event,) = events
assert event["level"] == "warning"
assert "exception" in event
def test_push_scope_null_client(sentry_init, capture_events):
sentry_init()
events = capture_events()
Hub.current.bind_client(None)
with push_scope() as scope:
scope.level = "warning"
try:
1 / 0
except Exception as e:
capture_exception(e)
assert len(events) == 0
@pytest.mark.parametrize("null_client", (True, False))
def test_push_scope_callback(sentry_init, null_client, capture_events):
sentry_init()
if null_client:
Hub.current.bind_client(None)
outer_scope = Hub.current.scope
calls = []
@push_scope
def _(scope):
assert scope is Hub.current.scope
assert scope is not outer_scope
calls.append(1)
# push_scope always needs to execute the callback regardless of
# client state, because that actually runs usercode in it, not
# just scope config code
assert calls == [1]
# Assert scope gets popped correctly
assert Hub.current.scope is outer_scope
def test_breadcrumbs(sentry_init, capture_events):
sentry_init(max_breadcrumbs=10)
events = capture_events()
for i in range(20):
add_breadcrumb(
category="auth", message="Authenticated user %s" % i, level="info"
)
capture_exception(ValueError())
(event,) = events
assert len(event["breadcrumbs"]["values"]) == 10
assert "user 10" in event["breadcrumbs"]["values"][0]["message"]
assert "user 19" in event["breadcrumbs"]["values"][-1]["message"]
del events[:]
for i in range(2):
add_breadcrumb(
category="auth", message="Authenticated user %s" % i, level="info"
)
with configure_scope() as scope:
scope.clear()
capture_exception(ValueError())
(event,) = events
assert len(event["breadcrumbs"]["values"]) == 0
def test_attachments(sentry_init, capture_envelopes):
sentry_init()
envelopes = capture_envelopes()
this_file = os.path.abspath(__file__.rstrip("c"))
with configure_scope() as scope:
scope.add_attachment(bytes=b"Hello World!", filename="message.txt")
scope.add_attachment(path=this_file)
capture_exception(ValueError())
(envelope,) = envelopes
assert len(envelope.items) == 3
assert envelope.get_event()["exception"] is not None
attachments = [x for x in envelope.items if x.type == "attachment"]
(message, pyfile) = attachments
assert message.headers["filename"] == "message.txt"
assert message.headers["type"] == "attachment"
assert message.headers["content_type"] == "text/plain"
assert message.payload.bytes == message.payload.get_bytes() == b"Hello World!"
assert pyfile.headers["filename"] == os.path.basename(this_file)
assert pyfile.headers["type"] == "attachment"
assert pyfile.headers["content_type"].startswith("text/")
assert pyfile.payload.bytes is None
with open(this_file, "rb") as f:
assert pyfile.payload.get_bytes() == f.read()
def test_integration_scoping(sentry_init, capture_events):
logger = logging.getLogger("test_basics")
# This client uses the logging integration
logging_integration = LoggingIntegration(event_level=logging.WARNING)
sentry_init(default_integrations=False, integrations=[logging_integration])
events = capture_events()
logger.warning("This is a warning")
assert len(events) == 1
# This client does not
sentry_init(default_integrations=False)
events = capture_events()
logger.warning("This is not a warning")
assert not events
def test_client_initialized_within_scope(sentry_init, caplog):
caplog.set_level(logging.WARNING)
sentry_init(debug=True)
with push_scope():
Hub.current.bind_client(Client())
(record,) = (x for x in caplog.records if x.levelname == "WARNING")
assert record.msg.startswith("init() called inside of pushed scope.")
def test_scope_leaks_cleaned_up(sentry_init, caplog):
caplog.set_level(logging.WARNING)
sentry_init(debug=True)
old_stack = list(Hub.current._stack)
with push_scope():
push_scope()
assert Hub.current._stack == old_stack
(record,) = (x for x in caplog.records if x.levelname == "WARNING")
assert record.message.startswith("Leaked 1 scopes:")
def test_scope_popped_too_soon(sentry_init, caplog):
caplog.set_level(logging.ERROR)
sentry_init(debug=True)
old_stack = list(Hub.current._stack)
with push_scope():
Hub.current.pop_scope_unsafe()
assert Hub.current._stack == old_stack
(record,) = (x for x in caplog.records if x.levelname == "ERROR")
assert record.message == ("Scope popped too soon. Popped 1 scopes too many.")
def test_scope_event_processor_order(sentry_init, capture_events):
def before_send(event, hint):
event["message"] += "baz"
return event
sentry_init(debug=True, before_send=before_send)
events = capture_events()
with push_scope() as scope:
@scope.add_event_processor
def foo(event, hint):
event["message"] += "foo"
return event
with push_scope() as scope:
@scope.add_event_processor
def bar(event, hint):
event["message"] += "bar"
return event
capture_message("hi")
(event,) = events
assert event["message"] == "hifoobarbaz"
def test_capture_event_with_scope_kwargs(sentry_init, capture_events):
sentry_init(debug=True)
events = capture_events()
capture_event({}, level="info", extras={"foo": "bar"})
(event,) = events
assert event["level"] == "info"
assert event["extra"]["foo"] == "bar"
def test_dedupe_event_processor_drop_records_client_report(
sentry_init, capture_events, capture_client_reports
):
"""
DedupeIntegration internally has an event_processor that filters duplicate exceptions.
We want a duplicate exception to be captured only once and the drop being recorded as
a client report.
"""
sentry_init()
events = capture_events()
reports = capture_client_reports()
try:
raise ValueError("aha!")
except Exception:
try:
capture_exception()
reraise(*sys.exc_info())
except Exception:
capture_exception()
(event,) = events
(report,) = reports
assert event["level"] == "error"
assert "exception" in event
assert report == ("event_processor", "error")
def test_event_processor_drop_records_client_report(
sentry_init, capture_events, capture_client_reports
):
sentry_init(traces_sample_rate=1.0)
events = capture_events()
reports = capture_client_reports()
global global_event_processors
@add_global_event_processor
def foo(event, hint):
return None
capture_message("dropped")
with start_transaction(name="dropped"):
pass
assert len(events) == 0
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"
@pytest.mark.skipif(_redis_installed(), reason="skipping because redis is installed")
def test_redis_disabled_when_not_installed(sentry_init):
sentry_init()
assert Hub.current.get_integration(RedisIntegration) is None
def test_multiple_setup_integrations_calls():
first_call_return = setup_integrations([NoOpIntegration()], with_defaults=False)
assert first_call_return == {NoOpIntegration.identifier: NoOpIntegration()}
second_call_return = setup_integrations([NoOpIntegration()], with_defaults=False)
assert second_call_return == {NoOpIntegration.identifier: NoOpIntegration()}
class TracingTestClass:
@staticmethod
def static(arg):
return arg
@classmethod
def class_(cls, arg):
return cls, arg
def test_staticmethod_tracing(sentry_init):
test_staticmethod_name = "tests.test_basics.TracingTestClass.static"
if not PY2:
# Skip this check on Python 2 since __qualname__ is available in Python 3 only. Skipping is okay,
# since the assertion would be expected to fail in Python 3 if there is any problem.
assert (
".".join(
[
TracingTestClass.static.__module__,
TracingTestClass.static.__qualname__,
]
)
== test_staticmethod_name
), "The test static method was moved or renamed. Please update the name accordingly"
sentry_init(functions_to_trace=[{"qualified_name": test_staticmethod_name}])
for instance_or_class in (TracingTestClass, TracingTestClass()):
with patch_start_tracing_child() as fake_start_child:
assert instance_or_class.static(1) == 1
assert fake_start_child.call_count == 1
def test_classmethod_tracing(sentry_init):
test_classmethod_name = "tests.test_basics.TracingTestClass.class_"
if not PY2:
# Skip this check on Python 2 since __qualname__ is available in Python 3 only. Skipping is okay,
# since the assertion would be expected to fail in Python 3 if there is any problem.
assert (
".".join(
[
TracingTestClass.class_.__module__,
TracingTestClass.class_.__qualname__,
]
)
== test_classmethod_name
), "The test class method was moved or renamed. Please update the name accordingly"
sentry_init(functions_to_trace=[{"qualified_name": test_classmethod_name}])
for instance_or_class in (TracingTestClass, TracingTestClass()):
with patch_start_tracing_child() as fake_start_child:
assert instance_or_class.class_(1) == (TracingTestClass, 1)
assert fake_start_child.call_count == 1
sentry-python-1.39.2/tests/test_client.py 0000664 0000000 0000000 00000114435 14547447232 0020526 0 ustar 00root root 0000000 0000000 # coding: utf-8
import os
import json
import pytest
import subprocess
import sys
import time
from textwrap import dedent
from sentry_sdk import (
Hub,
Client,
add_breadcrumb,
configure_scope,
capture_message,
capture_exception,
capture_event,
start_transaction,
set_tag,
)
from sentry_sdk.integrations.executing import ExecutingIntegration
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, DEFAULT_MAX_VALUE_LENGTH
from sentry_sdk._types import TYPE_CHECKING
if TYPE_CHECKING:
from collections.abc import Callable
from typing import Any, Optional, Union
from sentry_sdk._types import Event
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
from collections import Mapping
else:
# New in 3.3
# https://docs.python.org/3/library/collections.abc.html
from collections.abc import Mapping
class EventCapturedError(Exception):
pass
class _TestTransport(Transport):
def capture_event(self, event):
raise EventCapturedError(event)
def test_transport_option(monkeypatch):
if "SENTRY_DSN" in os.environ:
monkeypatch.delenv("SENTRY_DSN")
dsn = "https://foo@sentry.io/123"
dsn2 = "https://bar@sentry.io/124"
assert str(Client(dsn=dsn).dsn) == dsn
assert Client().dsn is None
monkeypatch.setenv("SENTRY_DSN", dsn)
transport = Transport({"dsn": dsn2})
assert text_type(transport.parsed_dsn) == dsn2
assert str(Client(transport=transport).dsn) == dsn
@pytest.mark.parametrize(
"testcase",
[
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": "https://localhost/123",
"arg_https_proxy": None,
"expected_proxy_scheme": "https",
},
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": "https://localhost/123",
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": "https://localhost/123",
"expected_proxy_scheme": "https",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": None,
},
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": None,
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "https",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": None,
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": "",
"arg_https_proxy": "",
"expected_proxy_scheme": None,
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "https",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": None,
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": None,
"arg_https_proxy": "",
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": "",
"arg_https_proxy": None,
"expected_proxy_scheme": "https",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": None,
"arg_https_proxy": "",
"expected_proxy_scheme": None,
},
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": "https://localhost/123",
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
# NO_PROXY testcases
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": "http://localhost/123",
"env_https_proxy": None,
"env_no_proxy": "sentry.io,example.com",
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": None,
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": "https://localhost/123",
"env_no_proxy": "example.com,sentry.io",
"arg_http_proxy": None,
"arg_https_proxy": None,
"expected_proxy_scheme": None,
},
{
"dsn": "http://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"env_no_proxy": "sentry.io,example.com",
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": None,
"expected_proxy_scheme": "http",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"env_no_proxy": "sentry.io,example.com",
"arg_http_proxy": None,
"arg_https_proxy": "https://localhost/123",
"expected_proxy_scheme": "https",
},
{
"dsn": "https://foo@sentry.io/123",
"env_http_proxy": None,
"env_https_proxy": None,
"env_no_proxy": "sentry.io,example.com",
"arg_http_proxy": None,
"arg_https_proxy": "https://localhost/123",
"expected_proxy_scheme": "https",
"arg_proxy_headers": {"Test-Header": "foo-bar"},
},
],
)
def test_proxy(monkeypatch, testcase):
if testcase["env_http_proxy"] is not None:
monkeypatch.setenv("HTTP_PROXY", testcase["env_http_proxy"])
if testcase["env_https_proxy"] is not None:
monkeypatch.setenv("HTTPS_PROXY", testcase["env_https_proxy"])
if testcase.get("env_no_proxy") is not None:
monkeypatch.setenv("NO_PROXY", testcase["env_no_proxy"])
kwargs = {}
if testcase["arg_http_proxy"] is not None:
kwargs["http_proxy"] = testcase["arg_http_proxy"]
if testcase["arg_https_proxy"] is not None:
kwargs["https_proxy"] = testcase["arg_https_proxy"]
if testcase.get("arg_proxy_headers") is not None:
kwargs["proxy_headers"] = testcase["arg_proxy_headers"]
client = Client(testcase["dsn"], **kwargs)
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"]
@pytest.mark.parametrize(
"testcase",
[
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": "http://localhost/123",
"arg_https_proxy": None,
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": "socks4a://localhost/123",
"arg_https_proxy": None,
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": "socks4://localhost/123",
"arg_https_proxy": None,
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": "socks5h://localhost/123",
"arg_https_proxy": None,
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": "socks5://localhost/123",
"arg_https_proxy": None,
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": None,
"arg_https_proxy": "socks4a://localhost/123",
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": None,
"arg_https_proxy": "socks4://localhost/123",
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": None,
"arg_https_proxy": "socks5h://localhost/123",
"expected_proxy_class": "",
},
{
"dsn": "https://foo@sentry.io/123",
"arg_http_proxy": None,
"arg_https_proxy": "socks5://localhost/123",
"expected_proxy_class": "",
},
],
)
def test_socks_proxy(testcase):
kwargs = {}
if testcase["arg_http_proxy"] is not None:
kwargs["http_proxy"] = testcase["arg_http_proxy"]
if testcase["arg_https_proxy"] is not None:
kwargs["https_proxy"] = testcase["arg_https_proxy"]
client = Client(testcase["dsn"], **kwargs)
assert str(type(client.transport._pool)) == testcase["expected_proxy_class"]
def test_simple_transport(sentry_init):
events = []
sentry_init(transport=events.append)
capture_message("Hello World!")
assert events[0]["message"] == "Hello World!"
def test_ignore_errors(sentry_init, capture_events):
class MyDivisionError(ZeroDivisionError):
pass
def raise_it(exc_info):
reraise(*exc_info)
sentry_init(ignore_errors=[ZeroDivisionError], transport=_TestTransport())
Hub.current._capture_internal_exception = raise_it
def e(exc):
try:
raise exc
except Exception:
capture_exception()
e(ZeroDivisionError())
e(MyDivisionError())
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_request_bodies_deprecation(sentry_init):
with mock.patch.object(logger, "warning", mock.Mock()) as fake_warning:
sentry_init(request_bodies="small")
client = Hub.current.client
assert "request_bodies" not in client.options
assert "max_request_body_size" in client.options
assert client.options["max_request_body_size"] == "small"
fake_warning.assert_called_once_with(
"Deprecated: The option 'request_bodies' was renamed to 'max_request_body_size'. Please use 'max_request_body_size'. The option 'request_bodies' will be removed in the future."
)
def test_include_local_variables_enabled(sentry_init, capture_events):
sentry_init(include_local_variables=True)
events = capture_events()
try:
1 / 0
except Exception:
capture_exception()
(event,) = events
assert all(
frame["vars"]
for frame in event["exception"]["values"][0]["stacktrace"]["frames"]
)
def test_include_local_variables_disabled(sentry_init, capture_events):
sentry_init(include_local_variables=False)
events = capture_events()
try:
1 / 0
except Exception:
capture_exception()
(event,) = events
assert all(
"vars" not in frame
for frame in event["exception"]["values"][0]["stacktrace"]["frames"]
)
def test_include_source_context_enabled(sentry_init, capture_events):
sentry_init(include_source_context=True)
events = capture_events()
try:
1 / 0
except Exception:
capture_exception()
(event,) = events
frame = event["exception"]["values"][0]["stacktrace"]["frames"][0]
assert "post_context" in frame
assert "pre_context" in frame
assert "context_line" in frame
def test_include_source_context_disabled(sentry_init, capture_events):
sentry_init(include_source_context=False)
events = capture_events()
try:
1 / 0
except Exception:
capture_exception()
(event,) = events
frame = event["exception"]["values"][0]["stacktrace"]["frames"][0]
assert "post_context" not in frame
assert "pre_context" not in frame
assert "context_line" not in frame
@pytest.mark.parametrize("integrations", [[], [ExecutingIntegration()]])
def test_function_names(sentry_init, capture_events, integrations):
sentry_init(integrations=integrations)
events = capture_events()
def foo():
try:
bar()
except Exception:
capture_exception()
def bar():
1 / 0
foo()
(event,) = events
(thread,) = event["exception"]["values"]
functions = [x["function"] for x in thread["stacktrace"]["frames"]]
if integrations:
assert functions == [
"test_function_names..foo",
"test_function_names..bar",
]
else:
assert functions == ["foo", "bar"]
def test_attach_stacktrace_enabled(sentry_init, capture_events):
sentry_init(attach_stacktrace=True)
events = capture_events()
def foo():
bar()
def bar():
capture_message("HI")
foo()
(event,) = events
(thread,) = event["threads"]["values"]
functions = [x["function"] for x in thread["stacktrace"]["frames"]]
assert functions[-2:] == ["foo", "bar"]
def test_attach_stacktrace_enabled_no_locals(sentry_init, capture_events):
sentry_init(attach_stacktrace=True, include_local_variables=False)
events = capture_events()
def foo():
bar()
def bar():
capture_message("HI")
foo()
(event,) = events
(thread,) = event["threads"]["values"]
local_vars = [x.get("vars") for x in thread["stacktrace"]["frames"]]
assert local_vars[-2:] == [None, None]
def test_attach_stacktrace_in_app(sentry_init, capture_events):
sentry_init(attach_stacktrace=True, in_app_exclude=["_pytest"])
events = capture_events()
capture_message("hi")
(event,) = events
(thread,) = event["threads"]["values"]
frames = thread["stacktrace"]["frames"]
pytest_frames = [f for f in frames if f["module"].startswith("_pytest")]
assert pytest_frames
assert all(f["in_app"] is False for f in pytest_frames)
def test_attach_stacktrace_disabled(sentry_init, capture_events):
sentry_init(attach_stacktrace=False)
events = capture_events()
capture_message("HI")
(event,) = events
assert "threads" not in event
def test_capture_event_works(sentry_init):
sentry_init(transport=_TestTransport())
pytest.raises(EventCapturedError, lambda: capture_event({}))
pytest.raises(EventCapturedError, lambda: capture_event({}))
@pytest.mark.parametrize("num_messages", [10, 20])
def test_atexit(tmpdir, monkeypatch, num_messages):
app = tmpdir.join("app.py")
app.write(
dedent(
"""
import time
from sentry_sdk import init, transport, capture_message
def send_event(self, event):
time.sleep(0.1)
print(event["message"])
transport.HttpTransport._send_event = send_event
init("http://foobar@localhost/123", shutdown_timeout={num_messages})
for _ in range({num_messages}):
capture_message("HI")
""".format(
num_messages=num_messages
)
)
)
start = time.time()
output = subprocess.check_output([sys.executable, str(app)])
end = time.time()
# Each message takes at least 0.1 seconds to process
assert int(end - start) >= num_messages / 10
assert output.count(b"HI") == num_messages
def test_configure_scope_available(sentry_init, request, monkeypatch):
# Test that scope is configured if client is configured
sentry_init()
with configure_scope() as scope:
assert scope is Hub.current.scope
scope.set_tag("foo", "bar")
calls = []
def callback(scope):
calls.append(scope)
scope.set_tag("foo", "bar")
assert configure_scope(callback) is None
assert len(calls) == 1
assert calls[0] is Hub.current.scope
@pytest.mark.tests_internal_exceptions
def test_client_debug_option_enabled(sentry_init, caplog):
sentry_init(debug=True)
Hub.current._capture_internal_exception((ValueError, ValueError("OK"), None))
assert "OK" in caplog.text
@pytest.mark.tests_internal_exceptions
@pytest.mark.parametrize("with_client", (True, False))
def test_client_debug_option_disabled(with_client, sentry_init, caplog):
if with_client:
sentry_init()
Hub.current._capture_internal_exception((ValueError, ValueError("OK"), None))
assert "OK" not in caplog.text
def test_scope_initialized_before_client(sentry_init, capture_events):
"""
This is a consequence of how configure_scope() works. We must
make `configure_scope()` a noop if no client is configured. Even
if the user later configures a client: We don't know that.
"""
with configure_scope() as scope:
scope.set_tag("foo", 42)
sentry_init()
events = capture_events()
capture_message("hi")
(event,) = events
assert "tags" not in event
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
def test_nan(sentry_init, capture_events):
sentry_init()
events = capture_events()
try:
# should_repr_strings=False
set_tag("mynan", float("nan"))
# should_repr_strings=True
nan = float("nan") # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
frames = event["exception"]["values"][0]["stacktrace"]["frames"]
(frame,) = frames
assert frame["vars"]["nan"] == "nan"
assert event["tags"]["mynan"] == "nan"
def test_cyclic_frame_vars(sentry_init, capture_events):
sentry_init()
events = capture_events()
try:
a = {}
a["a"] = a
1 / 0
except Exception:
capture_exception()
(event,) = events
assert event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"] == {
"a": ""
}
def test_cyclic_data(sentry_init, capture_events):
sentry_init()
events = capture_events()
with configure_scope() as scope:
data = {}
data["is_cyclic"] = data
other_data = ""
data["not_cyclic"] = other_data
data["not_cyclic2"] = other_data
scope.set_extra("foo", data)
capture_message("hi")
(event,) = events
data = event["extra"]["foo"]
assert data == {"not_cyclic2": "", "not_cyclic": "", "is_cyclic": ""}
def test_databag_depth_stripping(sentry_init, capture_events, benchmark):
sentry_init()
events = capture_events()
value = ["a"]
for _ in range(100000):
value = [value]
@benchmark
def inner():
del events[:]
try:
a = value # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert len(json.dumps(event)) < 10000
def test_databag_string_stripping(sentry_init, capture_events, benchmark):
sentry_init()
events = capture_events()
@benchmark
def inner():
del events[:]
try:
a = "A" * 1000000 # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert len(json.dumps(event)) < 10000
def test_databag_breadth_stripping(sentry_init, capture_events, benchmark):
sentry_init()
events = capture_events()
@benchmark
def inner():
del events[:]
try:
a = ["a"] * 1000000 # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert (
len(event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"])
== MAX_DATABAG_BREADTH
)
assert len(json.dumps(event)) < 10000
@pytest.mark.skipif(not HAS_CHAINED_EXCEPTIONS, reason="Only works on 3.3+")
def test_chained_exceptions(sentry_init, capture_events):
sentry_init()
events = capture_events()
try:
try:
raise ValueError()
except Exception:
1 / 0
except Exception:
capture_exception()
(event,) = events
e1, e2 = event["exception"]["values"]
# This is the order all other SDKs send chained exceptions in. Including
# Raven-Python.
assert e1["type"] == "ValueError"
assert e2["type"] == "ZeroDivisionError"
@pytest.mark.tests_internal_exceptions
def test_broken_mapping(sentry_init, capture_events):
sentry_init()
events = capture_events()
class C(Mapping):
def broken(self, *args, **kwargs):
raise Exception("broken")
__getitem__ = broken
__setitem__ = broken
__delitem__ = broken
__iter__ = broken
__len__ = broken
def __repr__(self):
return "broken"
try:
a = C() # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert (
event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"]
== ""
)
def test_mapping_sends_exception(sentry_init, capture_events):
sentry_init()
events = capture_events()
class C(Mapping):
def __iter__(self):
try:
1 / 0
except ZeroDivisionError:
capture_exception()
yield "hi"
def __len__(self):
"""List length"""
return 1
def __getitem__(self, ii):
"""Get a list item"""
if ii == "hi":
return "hi"
raise KeyError()
try:
a = C() # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"] == {
"hi": "'hi'"
}
def test_object_sends_exception(sentry_init, capture_events):
sentry_init()
events = capture_events()
class C(object):
def __repr__(self):
try:
1 / 0
except ZeroDivisionError:
capture_exception()
return "hi, i am a repr"
try:
a = C() # noqa
1 / 0
except Exception:
capture_exception()
(event,) = events
assert (
event["exception"]["values"][0]["stacktrace"]["frames"][0]["vars"]["a"]
== "hi, i am a repr"
)
def test_errno_errors(sentry_init, capture_events):
sentry_init()
events = capture_events()
class FooError(Exception):
errno = 69
capture_exception(FooError())
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["mechanism"]["meta"]["errno"]["number"] == 69
def test_non_string_variables(sentry_init, capture_events):
"""There is some extremely terrible code in the wild that
inserts non-strings as variable names into `locals()`."""
sentry_init()
events = capture_events()
try:
locals()[42] = True
1 / 0
except ZeroDivisionError:
capture_exception()
(event,) = events
(exception,) = event["exception"]["values"]
assert exception["type"] == "ZeroDivisionError"
(frame,) = exception["stacktrace"]["frames"]
assert frame["vars"]["42"] == "True"
def test_dict_changed_during_iteration(sentry_init, capture_events):
"""
Some versions of Bottle modify the WSGI environment inside of this __repr__
impl: https://github.com/bottlepy/bottle/blob/0.12.16/bottle.py#L1386
See https://github.com/getsentry/sentry-python/pull/298 for discussion
"""
sentry_init(send_default_pii=True)
events = capture_events()
class TooSmartClass(object):
def __init__(self, environ):
self.environ = environ
def __repr__(self):
if "my_representation" in self.environ:
return self.environ["my_representation"]
self.environ["my_representation"] = ""
return self.environ["my_representation"]
try:
environ = {}
environ["a"] = TooSmartClass(environ)
1 / 0
except ZeroDivisionError:
capture_exception()
(event,) = events
(exception,) = event["exception"]["values"]
(frame,) = exception["stacktrace"]["frames"]
assert frame["vars"]["environ"] == {"a": ""}
@pytest.mark.parametrize(
"dsn",
[
"http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2",
"http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2",
],
)
def test_init_string_types(dsn, sentry_init):
# Allow unicode strings on Python 3 and both on Python 2 (due to
# unicode_literals)
#
# Supporting bytes on Python 3 is not really wrong but probably would be
# extra code
sentry_init(dsn)
assert (
Hub.current.client.dsn
== "http://894b7d594095440f8dfea9b300e6f572@localhost:8000/2"
)
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.
"""
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=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
event = events.pop()
assert event["event_id"] == event_id
assert "type" not in event
with start_transaction(name="foo"):
pass
# Assert transactions get passed in via capture_envelope
assert not events
assert not envelopes
assert not envelopes
assert not events
@pytest.mark.parametrize(
"sdk_options, expected_breadcrumbs",
[({}, DEFAULT_MAX_BREADCRUMBS), ({"max_breadcrumbs": 50}, 50)],
)
def test_max_breadcrumbs_option(
sentry_init, capture_events, sdk_options, expected_breadcrumbs
):
sentry_init(sdk_options)
events = capture_events()
for _ in range(1231):
add_breadcrumb({"type": "sourdough"})
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)
@pytest.mark.parametrize(
"sdk_options, expected_data_length",
[
({}, DEFAULT_MAX_VALUE_LENGTH),
({"max_value_length": 1800}, 1800),
],
)
def test_max_value_length_option(
sentry_init, capture_events, sdk_options, expected_data_length
):
sentry_init(sdk_options)
events = capture_events()
capture_message("a" * 2000)
assert len(events[0]["message"]) == expected_data_length
@pytest.mark.parametrize(
"client_option,env_var_value,debug_output_expected",
[
(None, "", False),
(None, "t", True),
(None, "1", True),
(None, "True", True),
(None, "true", True),
(None, "f", False),
(None, "0", False),
(None, "False", False),
(None, "false", False),
(None, "xxx", False),
(True, "", True),
(True, "t", True),
(True, "1", True),
(True, "True", True),
(True, "true", True),
(True, "f", True),
(True, "0", True),
(True, "False", True),
(True, "false", True),
(True, "xxx", True),
(False, "", False),
(False, "t", False),
(False, "1", False),
(False, "True", False),
(False, "true", False),
(False, "f", False),
(False, "0", False),
(False, "False", False),
(False, "false", False),
(False, "xxx", False),
],
)
@pytest.mark.tests_internal_exceptions
def test_debug_option(
sentry_init,
monkeypatch,
caplog,
client_option,
env_var_value,
debug_output_expected,
):
monkeypatch.setenv("SENTRY_DEBUG", env_var_value)
if client_option is None:
sentry_init()
else:
sentry_init(debug=client_option)
Hub.current._capture_internal_exception(
(ValueError, ValueError("something is wrong"), None)
)
if debug_output_expected:
assert "something is wrong" in caplog.text
else:
assert "something is wrong" not in caplog.text
class IssuesSamplerTestConfig:
def __init__(
self,
expected_events,
sampler_function=None,
sample_rate=None,
exception_to_raise=Exception,
):
# type: (int, Optional[Callable[[Event], Union[float, bool]]], Optional[float], type[Exception]) -> None
self.sampler_function_mock = (
None
if sampler_function is None
else mock.MagicMock(side_effect=sampler_function)
)
self.expected_events = expected_events
self.sample_rate = sample_rate
self.exception_to_raise = exception_to_raise
def init_sdk(self, sentry_init):
# type: (Callable[[*Any], None]) -> None
sentry_init(
error_sampler=self.sampler_function_mock, sample_rate=self.sample_rate
)
def raise_exception(self):
# type: () -> None
raise self.exception_to_raise()
@mock.patch("sentry_sdk.client.random.random", return_value=0.618)
@pytest.mark.parametrize(
"test_config",
(
# Baseline test with error_sampler only, both floats and bools
IssuesSamplerTestConfig(sampler_function=lambda *_: 1.0, expected_events=1),
IssuesSamplerTestConfig(sampler_function=lambda *_: 0.7, expected_events=1),
IssuesSamplerTestConfig(sampler_function=lambda *_: 0.6, expected_events=0),
IssuesSamplerTestConfig(sampler_function=lambda *_: 0.0, expected_events=0),
IssuesSamplerTestConfig(sampler_function=lambda *_: True, expected_events=1),
IssuesSamplerTestConfig(sampler_function=lambda *_: False, expected_events=0),
# Baseline test with sample_rate only
IssuesSamplerTestConfig(sample_rate=1.0, expected_events=1),
IssuesSamplerTestConfig(sample_rate=0.7, expected_events=1),
IssuesSamplerTestConfig(sample_rate=0.6, expected_events=0),
IssuesSamplerTestConfig(sample_rate=0.0, expected_events=0),
# error_sampler takes precedence over sample_rate
IssuesSamplerTestConfig(
sampler_function=lambda *_: 1.0, sample_rate=0.0, expected_events=1
),
IssuesSamplerTestConfig(
sampler_function=lambda *_: 0.0, sample_rate=1.0, expected_events=0
),
# Different sample rates based on exception, retrieved both from event and hint
IssuesSamplerTestConfig(
sampler_function=lambda event, _: {
"ZeroDivisionError": 1.0,
"AttributeError": 0.0,
}[event["exception"]["values"][0]["type"]],
exception_to_raise=ZeroDivisionError,
expected_events=1,
),
IssuesSamplerTestConfig(
sampler_function=lambda event, _: {
"ZeroDivisionError": 1.0,
"AttributeError": 0.0,
}[event["exception"]["values"][0]["type"]],
exception_to_raise=AttributeError,
expected_events=0,
),
IssuesSamplerTestConfig(
sampler_function=lambda _, hint: {
ZeroDivisionError: 1.0,
AttributeError: 0.0,
}[hint["exc_info"][0]],
exception_to_raise=ZeroDivisionError,
expected_events=1,
),
IssuesSamplerTestConfig(
sampler_function=lambda _, hint: {
ZeroDivisionError: 1.0,
AttributeError: 0.0,
}[hint["exc_info"][0]],
exception_to_raise=AttributeError,
expected_events=0,
),
# If sampler returns invalid value, we should still send the event
IssuesSamplerTestConfig(
sampler_function=lambda *_: "This is an invalid return value for the sampler",
expected_events=1,
),
),
)
def test_error_sampler(_, sentry_init, capture_events, test_config):
test_config.init_sdk(sentry_init)
events = capture_events()
try:
test_config.raise_exception()
except Exception:
capture_exception()
assert len(events) == test_config.expected_events
if test_config.sampler_function_mock is not None:
assert test_config.sampler_function_mock.call_count == 1
# Ensure two arguments (the event and hint) were passed to the sampler function
assert len(test_config.sampler_function_mock.call_args[0]) == 2
sentry-python-1.39.2/tests/test_conftest.py 0000664 0000000 0000000 00000006531 14547447232 0021072 0 ustar 00root root 0000000 0000000 import pytest
@pytest.mark.parametrize(
"test_string, expected_result",
[
# type matches
("dogs are great!", True), # full containment - beginning
("go, dogs, go!", True), # full containment - middle
("I like dogs", True), # full containment - end
("dogs", True), # equality
("", False), # reverse containment
("dog", False), # reverse containment
("good dog!", False), # partial overlap
("cats", False), # no overlap
# type mismatches
(1231, False),
(11.21, False),
([], False),
({}, False),
(True, False),
],
)
def test_string_containing(
test_string, expected_result, StringContaining # noqa: N803
):
assert (test_string == StringContaining("dogs")) is expected_result
@pytest.mark.parametrize(
"test_dict, expected_result",
[
# type matches
({"dogs": "yes", "cats": "maybe", "spiders": "nope"}, True), # full containment
({"dogs": "yes", "cats": "maybe"}, True), # equality
({}, False), # reverse containment
({"dogs": "yes"}, False), # reverse containment
({"dogs": "yes", "birds": "only outside"}, False), # partial overlap
({"coyotes": "from afar"}, False), # no overlap
# type mismatches
('{"dogs": "yes", "cats": "maybe"}', False),
(1231, False),
(11.21, False),
([], False),
(True, False),
],
)
def test_dictionary_containing(
test_dict, expected_result, DictionaryContaining # noqa: N803
):
assert (
test_dict == DictionaryContaining({"dogs": "yes", "cats": "maybe"})
) is expected_result
class Animal(object): # noqa: B903
def __init__(self, name=None, age=None, description=None):
self.name = name
self.age = age
self.description = description
class Dog(Animal):
pass
class Cat(Animal):
pass
@pytest.mark.parametrize(
"test_obj, type_and_attrs_result, type_only_result, attrs_only_result",
[
# type matches
(Dog("Maisey", 7, "silly"), True, True, True), # full attr containment
(Dog("Maisey", 7), True, True, True), # type and attr equality
(Dog(), False, True, False), # reverse attr containment
(Dog("Maisey"), False, True, False), # reverse attr containment
(Dog("Charlie", 7, "goofy"), False, True, False), # partial attr overlap
(Dog("Bodhi", 6, "floppy"), False, True, False), # no attr overlap
# type mismatches
(Cat("Maisey", 7), False, False, True), # attr equality
(Cat("Piper", 1, "doglike"), False, False, False),
("Good girl, Maisey", False, False, False),
({"name": "Maisey", "age": 7}, False, False, False),
(1231, False, False, False),
(11.21, False, False, False),
([], False, False, False),
(True, False, False, False),
],
)
def test_object_described_by(
test_obj,
type_and_attrs_result,
type_only_result,
attrs_only_result,
ObjectDescribedBy, # noqa: N803
):
assert (
test_obj == ObjectDescribedBy(type=Dog, attrs={"name": "Maisey", "age": 7})
) is type_and_attrs_result
assert (test_obj == ObjectDescribedBy(type=Dog)) is type_only_result
assert (
test_obj == ObjectDescribedBy(attrs={"name": "Maisey", "age": 7})
) is attrs_only_result
sentry-python-1.39.2/tests/test_crons.py 0000664 0000000 0000000 00000017673 14547447232 0020402 0 ustar 00root root 0000000 0000000 import pytest
import uuid
import sentry_sdk
from sentry_sdk.crons import capture_checkin
from sentry_sdk import Hub, configure_scope, set_level
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 _hello_world_contextmanager(name):
with sentry_sdk.monitor(monitor_slug="abc123"):
return "Hello, {}".format(name)
def _break_world_contextmanager(name):
with sentry_sdk.monitor(monitor_slug="def456"):
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(ZeroDivisionError):
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_contextmanager(sentry_init):
sentry_init()
with mock.patch(
"sentry_sdk.crons.decorator.capture_checkin"
) as fake_capture_checking:
result = _hello_world_contextmanager("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_contextmanager_error(sentry_init):
sentry_init()
with mock.patch(
"sentry_sdk.crons.decorator.capture_checkin"
) as fake_capture_checking:
with pytest.raises(ZeroDivisionError):
result = _break_world_contextmanager("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_sample_rate_doesnt_affect_crons(sentry_init, capture_envelopes):
sentry_init(sample_rate=0)
envelopes = capture_envelopes()
capture_checkin(check_in_id="112233")
assert len(envelopes) == 1
check_in = envelopes[0].items[0].payload.json
assert check_in["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"
def test_scope_data_in_checkin(sentry_init, capture_envelopes):
sentry_init()
envelopes = capture_envelopes()
valid_keys = [
# Mandatory event keys
"type",
"event_id",
"timestamp",
"platform",
# Optional event keys
"release",
"environment",
# Mandatory check-in specific keys
"check_in_id",
"monitor_slug",
"status",
# Optional check-in specific keys
"duration",
"monitor_config",
"contexts", # an event processor adds this
# TODO: These fields need to be checked if valid for checkin:
"_meta",
"tags",
"extra", # an event processor adds this
"modules",
"server_name",
"sdk",
]
hub = Hub.current
with configure_scope() as scope:
# Add some data to the scope
set_level("warning")
hub.add_breadcrumb(message="test breadcrumb")
scope.set_tag("test_tag", "test_value")
scope.set_extra("test_extra", "test_value")
scope.set_context("test_context", {"test_key": "test_value"})
capture_checkin(
monitor_slug="abc123",
check_in_id="112233",
status="ok",
duration=123,
)
(envelope,) = envelopes
check_in_event = envelope.items[0].payload.json
invalid_keys = []
for key in check_in_event.keys():
if key not in valid_keys:
invalid_keys.append(key)
assert len(invalid_keys) == 0, "Unexpected keys found in checkin: {}".format(
invalid_keys
)
sentry-python-1.39.2/tests/test_envelope.py 0000664 0000000 0000000 00000017711 14547447232 0021064 0 ustar 00root root 0000000 0000000 from sentry_sdk.envelope import Envelope
from sentry_sdk.session import Session
from sentry_sdk import capture_event
import sentry_sdk.client
def generate_transaction_item():
return {
"event_id": "15210411201320122115110420122013",
"type": "transaction",
"transaction": "/interactions/other-dogs/new-dog",
"start_timestamp": 1353568872.11122131,
"timestamp": 1356942672.09040815,
"contexts": {
"trace": {
"trace_id": "12312012123120121231201212312012",
"span_id": "0415201309082013",
"parent_span_id": None,
"description": "",
"op": "greeting.sniff",
"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": [
{
"description": "",
"op": "greeting.sniff",
"parent_span_id": None,
"span_id": "0415201309082013",
"start_timestamp": 1353568872.11122131,
"timestamp": 1356942672.09040815,
"trace_id": "12312012123120121231201212312012",
}
],
}
def test_add_and_get_basic_event():
envelope = Envelope()
expected = {"message": "Hello, World!"}
envelope.add_event(expected)
assert envelope.get_event() == {"message": "Hello, World!"}
def test_add_and_get_transaction_event():
envelope = Envelope()
transaction_item = generate_transaction_item()
transaction_item.update({"event_id": "a" * 32})
envelope.add_transaction(transaction_item)
# typically it should not be possible to be able to add a second transaction;
# but we do it anyways
another_transaction_item = generate_transaction_item()
envelope.add_transaction(another_transaction_item)
# should only fetch the first inserted transaction event
assert envelope.get_transaction_event() == transaction_item
def test_add_and_get_session():
envelope = Envelope()
expected = Session()
envelope.add_session(expected)
for item in envelope:
if item.type == "session":
assert item.payload.json == expected.to_json()
def test_envelope_headers(sentry_init, capture_envelopes, monkeypatch):
monkeypatch.setattr(
sentry_sdk.client,
"format_timestamp",
lambda x: "2012-11-21T12:31:12.415908Z",
)
sentry_init(
dsn="https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
traces_sample_rate=1.0,
)
envelopes = capture_envelopes()
capture_event(generate_transaction_item())
assert len(envelopes) == 1
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():
"""
Tests that it successfully parses envelopes with
the item size specified in the header
"""
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'
)
envelope_raw_eof_terminated = envelope_raw[:-1]
for envelope in (envelope_raw, envelope_raw_eof_terminated):
actual = Envelope.deserialize(envelope)
items = [item for item in actual]
assert len(items) == 4
assert items[0].type == "type1"
assert items[0].get_bytes() == b"1234"
assert items[1].type == "type2"
assert items[1].get_bytes() == b"abcd"
assert items[2].type == "type3"
assert items[2].get_bytes() == b""
assert items[3].type == "type4"
assert items[3].get_bytes() == b"ab12"
assert actual.headers["event_id"] == "9ec79c33ec9942ab8353589fcb2e04dc"
def test_envelope_with_implicitly_sized_items():
"""
Tests that it successfully parses envelopes with
the item size not specified in the header
"""
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'
)
envelope_raw_eof_terminated = envelope_raw[:-1]
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]
assert len(items) == 4
assert items[0].type == "type1"
assert items[0].get_bytes() == b"1234"
assert items[1].type == "type2"
assert items[1].get_bytes() == b"abcd"
assert items[2].type == "type3"
assert items[2].get_bytes() == b""
assert items[3].type == "type4"
assert items[3].get_bytes() == b"ab12"
def test_envelope_with_two_attachments():
"""
Test that items are correctly parsed in an envelope with to size specified items
"""
two_attachments = (
b'{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc","dsn":"https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42"}\n'
+ b'{"type":"attachment","length":10,"content_type":"text/plain","filename":"hello.txt"}\n'
+ b"\xef\xbb\xbfHello\r\n\n"
+ b'{"type":"event","length":41,"content_type":"application/json","filename":"application.log"}\n'
+ b'{"message":"hello world","level":"error"}\n'
)
two_attachments_eof_terminated = two_attachments[
:-1
] # last \n is optional, without it should still be a valid envelope
for envelope_raw in (two_attachments, two_attachments_eof_terminated):
actual = Envelope.deserialize(envelope_raw)
items = [item for item in actual]
assert len(items) == 2
assert items[0].get_bytes() == b"\xef\xbb\xbfHello\r\n"
assert items[1].payload.json == {"message": "hello world", "level": "error"}
def test_envelope_with_empty_attachments():
"""
Test that items are correctly parsed in an envelope with two 0 length items (with size specified in the header
"""
two_empty_attachments = (
b'{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n'
+ b'{"type":"attachment","length":0}\n\n'
+ b'{"type":"attachment","length":0}\n\n'
)
two_empty_attachments_eof_terminated = two_empty_attachments[
:-1
] # last \n is optional, without it should still be a valid envelope
for envelope_raw in (two_empty_attachments, two_empty_attachments_eof_terminated):
actual = Envelope.deserialize(envelope_raw)
items = [item for item in actual]
assert len(items) == 2
assert items[0].get_bytes() == b""
assert items[1].get_bytes() == b""
def test_envelope_without_headers():
"""
Test that an envelope without headers is parsed successfully
"""
envelope_without_headers = (
b"{}\n" + b'{"type":"session"}\n' + b'{"started": "2020-02-07T14:16:00Z"}'
)
actual = Envelope.deserialize(envelope_without_headers)
items = [item for item in actual]
assert len(items) == 1
assert items[0].payload.get_bytes() == b'{"started": "2020-02-07T14:16:00Z"}'
sentry-python-1.39.2/tests/test_exceptiongroup.py 0000664 0000000 0000000 00000020602 14547447232 0022313 0 ustar 00root root 0000000 0000000 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,
"max_value_length": 1024,
},
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,
"max_value_length": 1024,
},
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["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,
"max_value_length": 1024,
},
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,
"max_value_length": 1024,
},
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,
"max_value_length": 1024,
},
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
sentry-python-1.39.2/tests/test_lru_cache.py 0000664 0000000 0000000 00000001420 14547447232 0021162 0 ustar 00root root 0000000 0000000 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
sentry-python-1.39.2/tests/test_metrics.py 0000664 0000000 0000000 00000067372 14547447232 0020725 0 ustar 00root root 0000000 0000000 # coding: utf-8
import sys
import time
import linecache
from sentry_sdk import Hub, metrics, push_scope, start_transaction
from sentry_sdk.tracing import TRANSACTION_SOURCE_ROUTE
from sentry_sdk.envelope import parse_json
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
def parse_metrics(bytes):
rv = []
for line in bytes.splitlines():
pieces = line.decode("utf-8").split("|")
payload = pieces[0].split(":")
name = payload[0]
values = payload[1:]
ty = pieces[1]
ts = None
tags = {}
for piece in pieces[2:]:
if piece[0] == "#":
for pair in piece[1:].split(","):
k, v = pair.split(":", 1)
old = tags.get(k)
if old is not None:
if isinstance(old, list):
old.append(v)
else:
tags[k] = [old, v]
else:
tags[k] = v
elif piece[0] == "T":
ts = int(piece[1:])
else:
raise ValueError("unknown piece %r" % (piece,))
rv.append((ts, name, ty, values, tags))
rv.sort(key=lambda x: (x[0], x[1], tuple(sorted(tags.items()))))
return rv
def test_incr(sentry_init, capture_envelopes):
sentry_init(
release="fun-release",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.incr("foobar", 1.0, tags={"foo": "bar", "blub": "blah"}, timestamp=ts)
metrics.incr("foobar", 2.0, tags={"foo": "bar", "blub": "blah"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "foobar@none"
assert m[0][2] == "c"
assert m[0][3] == ["3.0"]
assert m[0][4] == {
"blub": "blah",
"foo": "bar",
"release": "fun-release",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
assert parse_json(meta_item.payload.get_bytes()) == {
"timestamp": mock.ANY,
"mapping": {
"c:foobar@none": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
]
},
}
def test_timing(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
ts = time.time()
envelopes = capture_envelopes()
with metrics.timing("whatever", tags={"blub": "blah"}, timestamp=ts):
time.sleep(0.1)
Hub.current.flush()
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "whatever@second"
assert m[0][2] == "d"
assert len(m[0][3]) == 1
assert float(m[0][3][0]) >= 0.1
assert m[0][4] == {
"blub": "blah",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
json = parse_json(meta_item.payload.get_bytes())
assert json == {
"timestamp": mock.ANY,
"mapping": {
"d:whatever@second": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
]
},
}
loc = json["mapping"]["d:whatever@second"][0]
line = linecache.getline(loc["abs_path"], loc["lineno"])
assert (
line.strip()
== 'with metrics.timing("whatever", tags={"blub": "blah"}, timestamp=ts):'
)
def test_timing_decorator(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
envelopes = capture_envelopes()
@metrics.timing("whatever-1", tags={"x": "y"})
def amazing():
time.sleep(0.1)
return 42
@metrics.timing("whatever-2", tags={"x": "y"}, unit="nanosecond")
def amazing_nano():
time.sleep(0.01)
return 23
assert amazing() == 42
assert amazing_nano() == 23
Hub.current.flush()
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 2
assert m[0][1] == "whatever-1@second"
assert m[0][2] == "d"
assert len(m[0][3]) == 1
assert float(m[0][3][0]) >= 0.1
assert m[0][4] == {
"x": "y",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[1][1] == "whatever-2@nanosecond"
assert m[1][2] == "d"
assert len(m[1][3]) == 1
assert float(m[1][3][0]) >= 10000000.0
assert m[1][4] == {
"x": "y",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
json = parse_json(meta_item.payload.get_bytes())
assert json == {
"timestamp": mock.ANY,
"mapping": {
"d:whatever-1@second": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
],
"d:whatever-2@nanosecond": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
],
},
}
# XXX: this is not the best location. It would probably be better to
# report the location in the function, however that is quite a bit
# tricker to do since we report from outside the function so we really
# only see the callsite.
loc = json["mapping"]["d:whatever-1@second"][0]
line = linecache.getline(loc["abs_path"], loc["lineno"])
assert line.strip() == "assert amazing() == 42"
def test_timing_basic(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.timing("timing", 1.0, tags={"a": "b"}, timestamp=ts)
metrics.timing("timing", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.timing("timing", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.timing("timing", 3.0, tags={"a": "b"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "timing@second"
assert m[0][2] == "d"
assert len(m[0][3]) == 4
assert sorted(map(float, m[0][3])) == [1.0, 2.0, 2.0, 3.0]
assert m[0][4] == {
"a": "b",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
assert parse_json(meta_item.payload.get_bytes()) == {
"timestamp": mock.ANY,
"mapping": {
"d:timing@second": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
]
},
}
def test_distribution(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.distribution("dist", 1.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 3.0, tags={"a": "b"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "dist@none"
assert m[0][2] == "d"
assert len(m[0][3]) == 4
assert sorted(map(float, m[0][3])) == [1.0, 2.0, 2.0, 3.0]
assert m[0][4] == {
"a": "b",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
json = parse_json(meta_item.payload.get_bytes())
assert json == {
"timestamp": mock.ANY,
"mapping": {
"d:dist@none": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
]
},
}
loc = json["mapping"]["d:dist@none"][0]
line = linecache.getline(loc["abs_path"], loc["lineno"])
assert (
line.strip()
== 'metrics.distribution("dist", 1.0, tags={"a": "b"}, timestamp=ts)'
)
def test_set(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True, "metric_code_locations": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.set("my-set", "peter", tags={"magic": "puff"}, timestamp=ts)
metrics.set("my-set", "paul", tags={"magic": "puff"}, timestamp=ts)
metrics.set("my-set", "mary", tags={"magic": "puff"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
statsd_item, meta_item = envelope.items
assert statsd_item.headers["type"] == "statsd"
m = parse_metrics(statsd_item.payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "my-set@none"
assert m[0][2] == "s"
assert len(m[0][3]) == 3
assert sorted(map(int, m[0][3])) == [354582103, 2513273657, 3329318813]
assert m[0][4] == {
"magic": "puff",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert meta_item.headers["type"] == "metric_meta"
assert parse_json(meta_item.payload.get_bytes()) == {
"timestamp": mock.ANY,
"mapping": {
"s:my-set@none": [
{
"type": "location",
"filename": "tests/test_metrics.py",
"abs_path": __file__,
"function": sys._getframe().f_code.co_name,
"module": __name__,
"lineno": mock.ANY,
"pre_context": mock.ANY,
"context_line": mock.ANY,
"post_context": mock.ANY,
}
]
},
}
def test_gauge(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.gauge("my-gauge", 10.0, tags={"x": "y"}, timestamp=ts)
metrics.gauge("my-gauge", 20.0, tags={"x": "y"}, timestamp=ts)
metrics.gauge("my-gauge", 30.0, tags={"x": "y"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "my-gauge@none"
assert m[0][2] == "g"
assert len(m[0][3]) == 5
assert list(map(float, m[0][3])) == [30.0, 10.0, 30.0, 60.0, 3.0]
assert m[0][4] == {
"x": "y",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
def test_multiple(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
ts = time.time()
envelopes = capture_envelopes()
metrics.gauge("my-gauge", 10.0, tags={"x": "y"}, timestamp=ts)
metrics.gauge("my-gauge", 20.0, tags={"x": "y"}, timestamp=ts)
metrics.gauge("my-gauge", 30.0, tags={"x": "y"}, timestamp=ts)
for _ in range(10):
metrics.incr("counter-1", 1.0, timestamp=ts)
metrics.incr("counter-2", 1.0, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 3
assert m[0][1] == "counter-1@none"
assert m[0][2] == "c"
assert list(map(float, m[0][3])) == [10.0]
assert m[0][4] == {
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[1][1] == "counter-2@none"
assert m[1][2] == "c"
assert list(map(float, m[1][3])) == [1.0]
assert m[1][4] == {
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[2][1] == "my-gauge@none"
assert m[2][2] == "g"
assert len(m[2][3]) == 5
assert list(map(float, m[2][3])) == [30.0, 10.0, 30.0, 60.0, 3.0]
assert m[2][4] == {
"x": "y",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
def test_transaction_name(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
ts = time.time()
envelopes = capture_envelopes()
with push_scope() as scope:
scope.set_transaction_name("/user/{user_id}", source="route")
metrics.distribution("dist", 1.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 2.0, tags={"a": "b"}, timestamp=ts)
metrics.distribution("dist", 3.0, tags={"a": "b"}, timestamp=ts)
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "dist@none"
assert m[0][2] == "d"
assert len(m[0][3]) == 4
assert sorted(map(float, m[0][3])) == [1.0, 2.0, 2.0, 3.0]
assert m[0][4] == {
"a": "b",
"transaction": "/user/{user_id}",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
def test_metric_summaries(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
enable_tracing=True,
_experiments={"enable_metrics": True, "metrics_summary_sample_rate": 1.0},
)
ts = time.time()
envelopes = capture_envelopes()
with start_transaction(
op="stuff", name="/foo", source=TRANSACTION_SOURCE_ROUTE
) as transaction:
metrics.incr("root-counter", timestamp=ts)
with metrics.timing("my-timer-metric", tags={"a": "b"}, timestamp=ts):
for x in range(10):
metrics.distribution("my-dist", float(x), timestamp=ts)
Hub.current.flush()
(transaction, envelope) = envelopes
# Metrics Emission
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 3
assert m[0][1] == "my-dist@none"
assert m[0][2] == "d"
assert len(m[0][3]) == 10
assert sorted(m[0][3]) == list(map(str, map(float, range(10))))
assert m[0][4] == {
"transaction": "/foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[1][1] == "my-timer-metric@second"
assert m[1][2] == "d"
assert len(m[1][3]) == 1
assert m[1][4] == {
"a": "b",
"transaction": "/foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[2][1] == "root-counter@none"
assert m[2][2] == "c"
assert m[2][3] == ["1.0"]
assert m[2][4] == {
"transaction": "/foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
# Measurement Attachment
t = transaction.items[0].get_transaction_event()
assert t["_metrics_summary"] == {
"c:root-counter@none": [
{
"count": 1,
"min": 1.0,
"max": 1.0,
"sum": 1.0,
"tags": {
"transaction": "/foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
},
}
]
}
assert t["spans"][0]["_metrics_summary"]["d:my-dist@none"] == [
{
"count": 10,
"min": 0.0,
"max": 9.0,
"sum": 45.0,
"tags": {
"environment": "not-fun-env",
"release": "fun-release@1.0.0",
"transaction": "/foo",
},
}
]
assert t["spans"][0]["tags"] == {"a": "b"}
(timer,) = t["spans"][0]["_metrics_summary"]["d:my-timer-metric@second"]
assert timer["count"] == 1
assert timer["max"] == timer["min"] == timer["sum"]
assert timer["sum"] > 0
assert timer["tags"] == {
"a": "b",
"environment": "not-fun-env",
"release": "fun-release@1.0.0",
"transaction": "/foo",
}
def test_metrics_summary_disabled(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
enable_tracing=True,
_experiments={"enable_metrics": True},
)
ts = time.time()
envelopes = capture_envelopes()
with start_transaction(
op="stuff", name="/foo", source=TRANSACTION_SOURCE_ROUTE
) as transaction:
with metrics.timing("my-timer-metric", tags={"a": "b"}, timestamp=ts):
pass
Hub.current.flush()
(transaction, envelope) = envelopes
# Metrics Emission
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "my-timer-metric@second"
assert m[0][2] == "d"
assert len(m[0][3]) == 1
assert m[0][4] == {
"a": "b",
"transaction": "/foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
# Measurement Attachment
t = transaction.items[0].get_transaction_event()
assert "_metrics_summary" not in t
assert "_metrics_summary" not in t["spans"][0]
def test_metrics_summary_filtered(sentry_init, capture_envelopes):
def should_summarize_metric(key, tags):
return key == "foo"
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
enable_tracing=True,
_experiments={
"enable_metrics": True,
"metrics_summary_sample_rate": 1.0,
"should_summarize_metric": should_summarize_metric,
},
)
ts = time.time()
envelopes = capture_envelopes()
with start_transaction(
op="stuff", name="/foo", source=TRANSACTION_SOURCE_ROUTE
) as transaction:
metrics.timing("foo", value=3.0, tags={"a": "b"}, timestamp=ts)
metrics.timing("foo", value=2.0, tags={"b": "c"}, timestamp=ts)
metrics.timing("bar", value=1.0, tags={"a": "b"}, timestamp=ts)
Hub.current.flush()
(transaction, envelope) = envelopes
# Metrics Emission
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 3
assert m[0][1] == "bar@second"
assert m[1][1] == "foo@second"
assert m[2][1] == "foo@second"
# Measurement Attachment
t = transaction.items[0].get_transaction_event()["_metrics_summary"]
assert len(t["d:foo@second"]) == 2
assert {
"tags": {
"a": "b",
"environment": "not-fun-env",
"release": "fun-release@1.0.0",
"transaction": "/foo",
},
"min": 3.0,
"max": 3.0,
"count": 1,
"sum": 3.0,
} in t["d:foo@second"]
assert {
"tags": {
"b": "c",
"environment": "not-fun-env",
"release": "fun-release@1.0.0",
"transaction": "/foo",
},
"min": 2.0,
"max": 2.0,
"count": 1,
"sum": 2.0,
} in t["d:foo@second"]
def test_tag_normalization(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
ts = time.time()
envelopes = capture_envelopes()
# fmt: off
metrics.distribution("a", 1.0, tags={"foo-bar": "%$foo"}, timestamp=ts)
metrics.distribution("b", 1.0, tags={"foo$$$bar": "blah{}"}, timestamp=ts)
metrics.distribution("c", 1.0, tags={u"foö-bar": u"snöwmän"}, timestamp=ts)
# fmt: on
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 3
assert m[0][4] == {
"foo-bar": "_$foo",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
assert m[1][4] == {
"foo_bar": "blah{}",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
# fmt: off
assert m[2][4] == {
"fo_-bar": u"snöwmän",
"release": "fun-release@1.0.0",
"environment": "not-fun-env",
}
# fmt: on
def test_before_emit_metric(sentry_init, capture_envelopes):
def before_emit(key, tags):
if key == "removed-metric":
return False
tags["extra"] = "foo"
del tags["release"]
# this better be a noop!
metrics.incr("shitty-recursion")
return True
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={
"enable_metrics": True,
"before_emit_metric": before_emit,
},
)
envelopes = capture_envelopes()
metrics.incr("removed-metric", 1.0)
metrics.incr("actual-metric", 1.0)
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "actual-metric@none"
assert m[0][3] == ["1.0"]
assert m[0][4] == {
"extra": "foo",
"environment": "not-fun-env",
}
def test_aggregator_flush(sentry_init, capture_envelopes):
sentry_init(
release="fun-release@1.0.0",
environment="not-fun-env",
_experiments={
"enable_metrics": True,
},
)
envelopes = capture_envelopes()
metrics.incr("a-metric", 1.0)
Hub.current.flush()
assert len(envelopes) == 1
assert Hub.current.client.metrics_aggregator.buckets == {}
def test_tag_serialization(sentry_init, capture_envelopes):
sentry_init(
release="fun-release",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
envelopes = capture_envelopes()
metrics.incr(
"counter",
tags={
"no-value": None,
"an-int": 42,
"a-float": 23.0,
"a-string": "blah",
"more-than-one": [1, "zwei", "3.0", None],
},
)
Hub.current.flush()
(envelope,) = envelopes
assert len(envelope.items) == 1
assert envelope.items[0].headers["type"] == "statsd"
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][4] == {
"an-int": "42",
"a-float": "23.0",
"a-string": "blah",
"more-than-one": ["1", "3.0", "zwei"],
"release": "fun-release",
"environment": "not-fun-env",
}
def test_flush_recursion_protection(sentry_init, capture_envelopes, monkeypatch):
sentry_init(
release="fun-release",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
envelopes = capture_envelopes()
test_client = Hub.current.client
real_capture_envelope = test_client.transport.capture_envelope
def bad_capture_envelope(*args, **kwargs):
metrics.incr("bad-metric")
return real_capture_envelope(*args, **kwargs)
monkeypatch.setattr(test_client.transport, "capture_envelope", bad_capture_envelope)
metrics.incr("counter")
# flush twice to see the inner metric
Hub.current.flush()
Hub.current.flush()
(envelope,) = envelopes
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "counter@none"
def test_flush_recursion_protection_background_flush(
sentry_init, capture_envelopes, monkeypatch
):
monkeypatch.setattr(metrics.MetricsAggregator, "FLUSHER_SLEEP_TIME", 0.1)
sentry_init(
release="fun-release",
environment="not-fun-env",
_experiments={"enable_metrics": True},
)
envelopes = capture_envelopes()
test_client = Hub.current.client
real_capture_envelope = test_client.transport.capture_envelope
def bad_capture_envelope(*args, **kwargs):
metrics.incr("bad-metric")
return real_capture_envelope(*args, **kwargs)
monkeypatch.setattr(test_client.transport, "capture_envelope", bad_capture_envelope)
metrics.incr("counter")
# flush via sleep and flag
Hub.current.client.metrics_aggregator._force_flush = True
time.sleep(0.5)
(envelope,) = envelopes
m = parse_metrics(envelope.items[0].payload.get_bytes())
assert len(m) == 1
assert m[0][1] == "counter@none"
sentry-python-1.39.2/tests/test_monitor.py 0000664 0000000 0000000 00000005216 14547447232 0020733 0 ustar 00root root 0000000 0000000 import random
from sentry_sdk import Hub, start_transaction
from sentry_sdk.transport import Transport
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
class HealthyTestTransport(Transport):
def _send_event(self, event):
pass
def _send_envelope(self, envelope):
pass
def is_healthy(self):
return True
class UnhealthyTestTransport(HealthyTestTransport):
def is_healthy(self):
return False
def test_no_monitor_if_disabled(sentry_init):
sentry_init(
transport=HealthyTestTransport(),
enable_backpressure_handling=False,
)
assert Hub.current.client.monitor is None
def test_monitor_if_enabled(sentry_init):
sentry_init(transport=HealthyTestTransport())
monitor = Hub.current.client.monitor
assert monitor is not None
assert monitor._thread is None
assert monitor.is_healthy() is True
assert monitor.downsample_factor == 0
assert monitor._thread is not None
assert monitor._thread.name == "sentry.monitor"
def test_monitor_unhealthy(sentry_init):
sentry_init(transport=UnhealthyTestTransport())
monitor = Hub.current.client.monitor
monitor.interval = 0.1
assert monitor.is_healthy() is True
for i in range(15):
monitor.run()
assert monitor.is_healthy() is False
assert monitor.downsample_factor == (i + 1 if i < 10 else 10)
def test_transaction_uses_downsampled_rate(
sentry_init, capture_client_reports, monkeypatch
):
sentry_init(
traces_sample_rate=1.0,
transport=UnhealthyTestTransport(),
)
reports = capture_client_reports()
monitor = Hub.current.client.monitor
monitor.interval = 0.1
# make sure rng doesn't sample
monkeypatch.setattr(random, "random", lambda: 0.9)
assert monitor.is_healthy() is True
monitor.run()
assert monitor.is_healthy() is False
assert monitor.downsample_factor == 1
with start_transaction(name="foobar") as transaction:
assert transaction.sampled is False
assert transaction.sample_rate == 0.5
assert reports == [("backpressure", "transaction")]
def test_monitor_no_thread_on_shutdown_no_errors(sentry_init):
sentry_init(transport=HealthyTestTransport())
# make it seem like the interpreter is shutting down
with mock.patch(
"threading.Thread.start",
side_effect=RuntimeError("can't create new thread at interpreter shutdown"),
):
monitor = Hub.current.client.monitor
assert monitor is not None
assert monitor._thread is None
monitor.run()
assert monitor._thread is None
sentry-python-1.39.2/tests/test_profiler.py 0000664 0000000 0000000 00000062523 14547447232 0021072 0 ustar 00root root 0000000 0000000 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,
capture_client_reports,
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()
reports = capture_client_reports()
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
if profiles_sample_rate is None or profiles_sample_rate == 0:
assert reports == []
elif profile_count:
assert reports == []
else:
assert reports == [("sample_rate", "profile")]
@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,
capture_client_reports,
teardown_profiling,
profiles_sampler,
profile_count,
mode,
):
sentry_init(
traces_sample_rate=1.0,
profiles_sampler=profiles_sampler,
)
envelopes = capture_envelopes()
reports = capture_client_reports()
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
if profile_count:
assert reports == []
else:
assert reports == [("sample_rate", "profile")]
@requires_python_version(3, 3)
def test_minimum_unique_samples_required(
sentry_init,
capture_envelopes,
capture_client_reports,
teardown_profiling,
):
sentry_init(
traces_sample_rate=1.0,
_experiments={"profiles_sample_rate": 1.0},
)
envelopes = capture_envelopes()
reports = capture_client_reports()
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
assert reports == [("insufficient_data", "profile")]
@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,
cwd=os.getcwd(),
)
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)
cwd = os.getcwd()
_, _, frames1 = extract_stack(frame, cache, cwd=cwd)
_, _, frames2 = extract_stack(frame, cache, cwd=cwd)
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,
pytest.mark.skip(
reason="cannot find this thread via threading.enumerate()"
),
],
id="gevent scheduler",
),
],
)
def test_thread_scheduler_no_thread_on_shutdown(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
# mock RuntimeError as if the 3.12 intepreter was shutting down
with mock.patch(
"threading.Thread.start",
side_effect=RuntimeError("can't create new thread at interpreter shutdown"),
):
scheduler.ensure_running()
assert scheduler.running is False
# still no thread
assert len(get_scheduler_threads(scheduler)) == 0
scheduler.teardown()
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),
cwd=os.getcwd(),
),
),
]
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,
cwd=os.getcwd(),
),
extract_stack(
get_frame(),
LRUCache(max_size=1),
max_stack_depth=2,
cwd=os.getcwd(),
),
]
@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 different 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"]
sentry-python-1.39.2/tests/test_scope.py 0000664 0000000 0000000 00000007732 14547447232 0020362 0 ustar 00root root 0000000 0000000 import copy
import os
import pytest
from sentry_sdk import capture_exception
from sentry_sdk.scope import Scope
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
def test_copying():
s1 = Scope()
s1.fingerprint = {}
s1.set_tag("foo", "bar")
s2 = copy.copy(s1)
assert "foo" in s2._tags
s1.set_tag("bam", "baz")
assert "bam" in s1._tags
assert "bam" not in s2._tags
assert s1._fingerprint is s2._fingerprint
def test_merging(sentry_init, capture_events):
sentry_init()
s = Scope()
s.set_user({"id": "42"})
events = capture_events()
capture_exception(NameError(), scope=s)
(event,) = events
assert event["user"] == {"id": "42"}
def test_common_args():
s = Scope()
s.update_from_kwargs(
user={"id": 23},
level="warning",
extras={"k": "v"},
contexts={"os": {"name": "Blafasel"}},
tags={"x": "y"},
fingerprint=["foo"],
)
s2 = Scope()
s2.set_extra("foo", "bar")
s2.set_tag("a", "b")
s2.set_context("device", {"a": "b"})
s2.update_from_scope(s)
assert s._user == {"id": 23}
assert s._level == "warning"
assert s._extras == {"k": "v"}
assert s._contexts == {"os": {"name": "Blafasel"}}
assert s._tags == {"x": "y"}
assert s._fingerprint == ["foo"]
assert s._user == s2._user
assert s._level == s2._level
assert s._fingerprint == s2._fingerprint
assert s2._extras == {"k": "v", "foo": "bar"}
assert s2._tags == {"a": "b", "x": "y"}
assert s2._contexts == {"os": {"name": "Blafasel"}, "device": {"a": "b"}}
BAGGAGE_VALUE = (
"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;"
)
SENTRY_TRACE_VALUE = "771a43a4192642f0b136d5159a501700-1234567890abcdef-1"
@pytest.mark.parametrize(
"env,excepted_value",
[
(
{
"SENTRY_TRACE": SENTRY_TRACE_VALUE,
},
{
"sentry-trace": SENTRY_TRACE_VALUE,
},
),
(
{
"SENTRY_BAGGAGE": BAGGAGE_VALUE,
},
{
"baggage": BAGGAGE_VALUE,
},
),
(
{
"SENTRY_TRACE": SENTRY_TRACE_VALUE,
"SENTRY_BAGGAGE": BAGGAGE_VALUE,
},
{
"sentry-trace": SENTRY_TRACE_VALUE,
"baggage": BAGGAGE_VALUE,
},
),
(
{
"SENTRY_USE_ENVIRONMENT": "",
"SENTRY_TRACE": SENTRY_TRACE_VALUE,
"SENTRY_BAGGAGE": BAGGAGE_VALUE,
},
{
"sentry-trace": SENTRY_TRACE_VALUE,
"baggage": BAGGAGE_VALUE,
},
),
(
{
"SENTRY_USE_ENVIRONMENT": "True",
"SENTRY_TRACE": SENTRY_TRACE_VALUE,
"SENTRY_BAGGAGE": BAGGAGE_VALUE,
},
{
"sentry-trace": SENTRY_TRACE_VALUE,
"baggage": BAGGAGE_VALUE,
},
),
(
{
"SENTRY_USE_ENVIRONMENT": "no",
"SENTRY_TRACE": SENTRY_TRACE_VALUE,
"SENTRY_BAGGAGE": BAGGAGE_VALUE,
},
None,
),
(
{
"SENTRY_USE_ENVIRONMENT": "True",
"MY_OTHER_VALUE": "asdf",
"SENTRY_RELEASE": "1.0.0",
},
None,
),
],
)
def test_load_trace_data_from_env(env, excepted_value):
new_env = os.environ.copy()
new_env.update(env)
with mock.patch.dict(os.environ, new_env):
s = Scope()
incoming_trace_data = s._load_trace_data_from_env()
assert incoming_trace_data == excepted_value
sentry-python-1.39.2/tests/test_scrubber.py 0000664 0000000 0000000 00000011352 14547447232 0021051 0 ustar 00root root 0000000 0000000 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"
sentry-python-1.39.2/tests/test_serializer.py 0000664 0000000 0000000 00000011320 14547447232 0021406 0 ustar 00root root 0000000 0000000 import re
import sys
import pytest
from sentry_sdk.serializer import MAX_DATABAG_BREADTH, MAX_DATABAG_DEPTH, serialize
try:
from hypothesis import given
import hypothesis.strategies as st
except ImportError:
pass
else:
def test_bytes_serialization_decode_many(message_normalizer):
@given(binary=st.binary(min_size=1))
def inner(binary):
result = message_normalizer(binary, should_repr_strings=False)
assert result == binary.decode("utf-8", "replace")
inner()
def test_bytes_serialization_repr_many(message_normalizer):
@given(binary=st.binary(min_size=1))
def inner(binary):
result = message_normalizer(binary, should_repr_strings=True)
assert result == repr(binary)
inner()
@pytest.fixture
def message_normalizer(validate_event_schema):
def inner(message, **kwargs):
event = serialize({"logentry": {"message": message}}, **kwargs)
validate_event_schema(event)
return event["logentry"]["message"]
return inner
@pytest.fixture
def extra_normalizer(validate_event_schema):
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")
def test_bytes_serialization_repr(message_normalizer):
binary = b"abc123\x80\xf0\x9f\x8d\x95"
result = message_normalizer(binary, should_repr_strings=True)
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]
def test_serialize_custom_mapping(extra_normalizer):
class CustomReprDict(dict):
def __sentry_repr__(self):
return "custom!"
result = extra_normalizer(CustomReprDict(one=1, two=2))
assert result == "custom!"
def test_custom_mapping_doesnt_mess_with_mock(extra_normalizer):
"""
Adding the __sentry_repr__ magic method check in the serializer
shouldn't mess with how mock works. This broke some stuff when we added
sentry_repr without the dunders.
"""
mock = pytest.importorskip("unittest.mock")
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_max_request_body_size_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, max_request_body_size="always")
assert result == data
def test_max_value_length_default(body_normalizer):
data = {"key": "a" * 2000}
result = body_normalizer(data)
assert len(result["key"]) == 1024 # fallback max length
def test_max_value_length(body_normalizer):
data = {"key": "a" * 2000}
max_value_length = 1800
result = body_normalizer(data, max_value_length=max_value_length)
assert len(result["key"]) == max_value_length
sentry-python-1.39.2/tests/test_sessions.py 0000664 0000000 0000000 00000010130 14547447232 0021101 0 ustar 00root root 0000000 0000000 import sentry_sdk
from sentry_sdk import Hub
from sentry_sdk.sessions import auto_session_tracking
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
def sorted_aggregates(item):
aggregates = item["aggregates"]
aggregates.sort(key=lambda item: (item["started"], item.get("did", "")))
return aggregates
def test_basic(sentry_init, capture_envelopes):
sentry_init(release="fun-release", environment="not-fun-env")
envelopes = capture_envelopes()
hub = Hub.current
hub.start_session()
try:
with hub.configure_scope() as scope:
scope.set_user({"id": "42"})
raise Exception("all is wrong")
except Exception:
hub.capture_exception()
hub.end_session()
hub.flush()
assert len(envelopes) == 2
assert envelopes[0].get_event() is not None
sess = envelopes[1]
assert len(sess.items) == 1
sess_event = sess.items[0].payload.json
assert sess_event["attrs"] == {
"release": "fun-release",
"environment": "not-fun-env",
}
assert sess_event["did"] == "42"
assert sess_event["init"]
assert sess_event["status"] == "exited"
assert sess_event["errors"] == 1
def test_aggregates(sentry_init, capture_envelopes):
sentry_init(
release="fun-release",
environment="not-fun-env",
)
envelopes = capture_envelopes()
hub = Hub.current
with auto_session_tracking(session_mode="request"):
with sentry_sdk.push_scope():
try:
with sentry_sdk.configure_scope() as scope:
scope.set_user({"id": "42"})
raise Exception("all is wrong")
except Exception:
sentry_sdk.capture_exception()
with auto_session_tracking(session_mode="request"):
pass
hub.start_session(session_mode="request")
hub.end_session()
sentry_sdk.flush()
assert len(envelopes) == 2
assert envelopes[0].get_event() is not None
sess = envelopes[1]
assert len(sess.items) == 1
sess_event = sess.items[0].payload.json
assert sess_event["attrs"] == {
"release": "fun-release",
"environment": "not-fun-env",
}
aggregates = sorted_aggregates(sess_event)
assert len(aggregates) == 1
assert aggregates[0]["exited"] == 2
assert aggregates[0]["errored"] == 1
def test_aggregates_explicitly_disabled_session_tracking_request_mode(
sentry_init, capture_envelopes
):
sentry_init(
release="fun-release", environment="not-fun-env", auto_session_tracking=False
)
envelopes = capture_envelopes()
hub = Hub.current
with auto_session_tracking(session_mode="request"):
with sentry_sdk.push_scope():
try:
raise Exception("all is wrong")
except Exception:
sentry_sdk.capture_exception()
with auto_session_tracking(session_mode="request"):
pass
hub.start_session(session_mode="request")
hub.end_session()
sentry_sdk.flush()
sess = envelopes[1]
assert len(sess.items) == 1
sess_event = sess.items[0].payload.json
aggregates = sorted_aggregates(sess_event)
assert len(aggregates) == 1
assert aggregates[0]["exited"] == 1
assert "errored" not in aggregates[0]
def test_no_thread_on_shutdown_no_errors(sentry_init):
sentry_init(
release="fun-release",
environment="not-fun-env",
)
hub = Hub.current
# make it seem like the interpreter is shutting down
with mock.patch(
"threading.Thread.start",
side_effect=RuntimeError("can't create new thread at interpreter shutdown"),
):
with auto_session_tracking(session_mode="request"):
with sentry_sdk.push_scope():
try:
raise Exception("all is wrong")
except Exception:
sentry_sdk.capture_exception()
with auto_session_tracking(session_mode="request"):
pass
hub.start_session(session_mode="request")
hub.end_session()
sentry_sdk.flush()
sentry-python-1.39.2/tests/test_spotlight.py 0000664 0000000 0000000 00000002722 14547447232 0021260 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk import Hub, capture_exception
@pytest.fixture
def capture_spotlight_envelopes(monkeypatch):
def inner():
envelopes = []
test_spotlight = Hub.current.client.spotlight
old_capture_envelope = test_spotlight.capture_envelope
def append_envelope(envelope):
envelopes.append(envelope)
return old_capture_envelope(envelope)
monkeypatch.setattr(test_spotlight, "capture_envelope", append_envelope)
return envelopes
return inner
def test_spotlight_off_by_default(sentry_init):
sentry_init()
assert Hub.current.client.spotlight is None
def test_spotlight_default_url(sentry_init):
sentry_init(spotlight=True)
spotlight = Hub.current.client.spotlight
assert spotlight is not None
assert spotlight.url == "http://localhost:8969/stream"
def test_spotlight_custom_url(sentry_init):
sentry_init(spotlight="http://foobar@test.com/132")
spotlight = Hub.current.client.spotlight
assert spotlight is not None
assert spotlight.url == "http://foobar@test.com/132"
def test_spotlight_envelope(sentry_init, capture_spotlight_envelopes):
sentry_init(spotlight=True)
envelopes = capture_spotlight_envelopes()
try:
raise ValueError("aha!")
except Exception:
capture_exception()
(envelope,) = envelopes
payload = envelope.items[0].payload.json
assert payload["exception"]["values"][0]["value"] == "aha!"
sentry-python-1.39.2/tests/test_transport.py 0000664 0000000 0000000 00000027701 14547447232 0021303 0 ustar 00root root 0000000 0000000 # coding: utf-8
import logging
import pickle
import gzip
import io
from datetime import datetime, timedelta
import pytest
from collections import namedtuple
from werkzeug.wrappers import Request, Response
from pytest_localserver.http import WSGIServer
from sentry_sdk import Hub, Client, add_breadcrumb, capture_message, Scope
from sentry_sdk._compat import datetime_utcnow
from sentry_sdk.transport import _parse_rate_limits
from sentry_sdk.envelope import Envelope, parse_json
from sentry_sdk.integrations.logging import LoggingIntegration
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
CapturedData = namedtuple("CapturedData", ["path", "event", "envelope", "compressed"])
class CapturingServer(WSGIServer):
def __init__(self, host="127.0.0.1", port=0, ssl_context=None):
WSGIServer.__init__(self, host, port, self, ssl_context=ssl_context)
self.code = 204
self.headers = {}
self.captured = []
def respond_with(self, code=200, headers=None):
self.code = code
if headers:
self.headers = headers
def clear_captured(self):
del self.captured[:]
def __call__(self, environ, start_response):
"""
This is the WSGI application.
"""
request = Request(environ)
event = envelope = None
if request.headers.get("content-encoding") == "gzip":
rdr = gzip.GzipFile(fileobj=io.BytesIO(request.data))
compressed = True
else:
rdr = io.BytesIO(request.data)
compressed = False
if request.mimetype == "application/json":
event = parse_json(rdr.read())
else:
envelope = Envelope.deserialize_from(rdr)
self.captured.append(
CapturedData(
path=request.path,
event=event,
envelope=envelope,
compressed=compressed,
)
)
response = Response(status=self.code)
response.headers.extend(self.headers)
return response(environ, start_response)
@pytest.fixture
def capturing_server(request):
server = CapturingServer()
server.start()
request.addfinalizer(server.stop)
return server
@pytest.fixture
def make_client(request, capturing_server):
def inner(**kwargs):
return Client(
"http://foobar@{}/132".format(capturing_server.url[len("http://") :]),
**kwargs
)
return inner
@pytest.mark.forked
@pytest.mark.parametrize("debug", (True, False))
@pytest.mark.parametrize("client_flush_method", ["close", "flush"])
@pytest.mark.parametrize("use_pickle", (True, False))
@pytest.mark.parametrize("compressionlevel", (0, 9))
def test_transport_works(
capturing_server,
request,
capsys,
caplog,
debug,
make_client,
client_flush_method,
use_pickle,
compressionlevel,
maybe_monkeypatched_threading,
):
caplog.set_level(logging.DEBUG)
client = make_client(
debug=debug,
_experiments={
"transport_zlib_compression_level": compressionlevel,
},
)
if use_pickle:
client = pickle.loads(pickle.dumps(client))
Hub.current.bind_client(client)
request.addfinalizer(lambda: Hub.current.bind_client(None))
add_breadcrumb(level="info", message="i like bread", timestamp=datetime_utcnow())
capture_message("löl")
getattr(client, client_flush_method)()
out, err = capsys.readouterr()
assert not err and not out
assert capturing_server.captured
assert capturing_server.captured[0].compressed == (compressionlevel > 0)
assert any("Sending event" in record.msg for record in caplog.records) == debug
@pytest.mark.parametrize(
"num_pools,expected_num_pools",
(
(None, 2),
(2, 2),
(10, 10),
),
)
def test_transport_num_pools(make_client, num_pools, expected_num_pools):
_experiments = {}
if num_pools is not None:
_experiments["transport_num_pools"] = num_pools
client = make_client(_experiments=_experiments)
options = client.transport._get_pool_options([])
assert options["num_pools"] == expected_num_pools
def test_transport_infinite_loop(capturing_server, request, make_client):
client = make_client(
debug=True,
# Make sure we cannot create events from our own logging
integrations=[LoggingIntegration(event_level=logging.DEBUG)],
)
with Hub(client):
capture_message("hi")
client.flush()
assert len(capturing_server.captured) == 1
def test_transport_no_thread_on_shutdown_no_errors(capturing_server, make_client):
client = make_client()
# make it seem like the interpreter is shutting down
with mock.patch(
"threading.Thread.start",
side_effect=RuntimeError("can't create new thread at interpreter shutdown"),
):
with Hub(client):
capture_message("hi")
# nothing exploded but also no events can be sent anymore
assert len(capturing_server.captured) == 0
NOW = datetime(2014, 6, 2)
@pytest.mark.parametrize(
"input,expected",
[
# Invalid rate limits
("", {}),
("invalid", {}),
(",,,", {}),
(
"42::organization, invalid, 4711:foobar;transaction;security:project",
{
None: NOW + timedelta(seconds=42),
"transaction": NOW + timedelta(seconds=4711),
"security": NOW + timedelta(seconds=4711),
# Unknown data categories
"foobar": NOW + timedelta(seconds=4711),
},
),
(
"4711:foobar;;transaction:organization",
{
"transaction": NOW + timedelta(seconds=4711),
# Unknown data categories
"foobar": NOW + timedelta(seconds=4711),
"": NOW + timedelta(seconds=4711),
},
),
],
)
def test_parse_rate_limits(input, expected):
assert dict(_parse_rate_limits(input, now=NOW)) == expected
def test_simple_rate_limits(capturing_server, capsys, caplog, make_client):
client = make_client()
capturing_server.respond_with(code=429, headers={"Retry-After": "4"})
client.capture_event({"type": "transaction"})
client.flush()
assert len(capturing_server.captured) == 1
assert capturing_server.captured[0].path == "/api/132/envelope/"
capturing_server.clear_captured()
assert set(client.transport._disabled_until) == set([None])
client.capture_event({"type": "transaction"})
client.capture_event({"type": "event"})
client.flush()
assert not capturing_server.captured
@pytest.mark.parametrize("response_code", [200, 429])
def test_data_category_limits(
capturing_server, capsys, caplog, response_code, make_client, monkeypatch
):
client = make_client(send_client_reports=False)
captured_outcomes = []
def record_lost_event(reason, data_category=None, item=None):
if data_category is None:
data_category = item.data_category
return captured_outcomes.append((reason, data_category))
monkeypatch.setattr(client.transport, "record_lost_event", record_lost_event)
capturing_server.respond_with(
code=response_code,
headers={"X-Sentry-Rate-Limits": "4711:transaction:organization"},
)
client.capture_event({"type": "transaction"})
client.flush()
assert len(capturing_server.captured) == 1
assert capturing_server.captured[0].path == "/api/132/envelope/"
capturing_server.clear_captured()
assert set(client.transport._disabled_until) == set(["transaction"])
client.capture_event({"type": "transaction"})
client.capture_event({"type": "transaction"})
client.flush()
assert not capturing_server.captured
client.capture_event({"type": "event"})
client.flush()
assert len(capturing_server.captured) == 1
assert capturing_server.captured[0].path == "/api/132/store/"
assert captured_outcomes == [
("ratelimit_backoff", "transaction"),
("ratelimit_backoff", "transaction"),
]
@pytest.mark.parametrize("response_code", [200, 429])
def test_data_category_limits_reporting(
capturing_server, capsys, caplog, response_code, make_client, monkeypatch
):
client = make_client(send_client_reports=True)
capturing_server.respond_with(
code=response_code,
headers={
"X-Sentry-Rate-Limits": "4711:transaction:organization, 4711:attachment:organization"
},
)
outcomes_enabled = False
real_fetch = client.transport._fetch_pending_client_report
def intercepting_fetch(*args, **kwargs):
if outcomes_enabled:
return real_fetch(*args, **kwargs)
monkeypatch.setattr(
client.transport, "_fetch_pending_client_report", intercepting_fetch
)
# get rid of threading making things hard to track
monkeypatch.setattr(client.transport._worker, "submit", lambda x: x() or True)
client.capture_event({"type": "transaction"})
client.flush()
assert len(capturing_server.captured) == 1
assert capturing_server.captured[0].path == "/api/132/envelope/"
capturing_server.clear_captured()
assert set(client.transport._disabled_until) == set(["attachment", "transaction"])
client.capture_event({"type": "transaction"})
client.capture_event({"type": "transaction"})
capturing_server.clear_captured()
# flush out the events but don't flush the client reports
client.flush()
client.transport._last_client_report_sent = 0
outcomes_enabled = True
scope = Scope()
scope.add_attachment(bytes=b"Hello World", filename="hello.txt")
client.capture_event({"type": "error"}, scope=scope)
client.flush()
# this goes out with an extra envelope because it's flushed after the last item
# that is normally in the queue. This is quite funny in a way because it means
# that the envelope that caused its own over quota report (an error with an
# attachment) will include its outcome since it's pending.
assert len(capturing_server.captured) == 1
envelope = capturing_server.captured[0].envelope
assert envelope.items[0].type == "event"
assert envelope.items[1].type == "client_report"
report = parse_json(envelope.items[1].get_bytes())
assert sorted(report["discarded_events"], key=lambda x: x["quantity"]) == [
{"category": "transaction", "reason": "ratelimit_backoff", "quantity": 2},
{"category": "attachment", "reason": "ratelimit_backoff", "quantity": 11},
]
capturing_server.clear_captured()
# here we sent a normal event
client.capture_event({"type": "transaction"})
client.capture_event({"type": "error", "release": "foo"})
client.flush()
assert len(capturing_server.captured) == 2
event = capturing_server.captured[0].event
assert event["type"] == "error"
assert event["release"] == "foo"
envelope = capturing_server.captured[1].envelope
assert envelope.items[0].type == "client_report"
report = parse_json(envelope.items[0].get_bytes())
assert report["discarded_events"] == [
{"category": "transaction", "reason": "ratelimit_backoff", "quantity": 1},
]
@pytest.mark.parametrize("response_code", [200, 429])
def test_complex_limits_without_data_category(
capturing_server, capsys, caplog, response_code, make_client
):
client = make_client()
capturing_server.respond_with(
code=response_code,
headers={"X-Sentry-Rate-Limits": "4711::organization"},
)
client.capture_event({"type": "transaction"})
client.flush()
assert len(capturing_server.captured) == 1
assert capturing_server.captured[0].path == "/api/132/envelope/"
capturing_server.clear_captured()
assert set(client.transport._disabled_until) == set([None])
client.capture_event({"type": "transaction"})
client.capture_event({"type": "transaction"})
client.capture_event({"type": "event"})
client.flush()
assert len(capturing_server.captured) == 0
sentry-python-1.39.2/tests/test_utils.py 0000664 0000000 0000000 00000043470 14547447232 0020410 0 ustar 00root root 0000000 0000000 import pytest
import re
import sys
from sentry_sdk.utils import (
Components,
Dsn,
get_default_release,
get_error_message,
get_git_revision,
is_valid_sample_rate,
logger,
match_regex_list,
parse_url,
parse_version,
safe_str,
sanitize_url,
serialize_frame,
is_sentry_url,
_get_installed_modules,
)
import sentry_sdk
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
try:
# Python 3
FileNotFoundError
except NameError:
# Python 2
FileNotFoundError = IOError
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()
@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
@pytest.fixture
def mock_hub_with_dsn_netloc():
"""
Returns a mocked hub with a DSN netloc of "abcd1234.ingest.sentry.io".
"""
mock_hub = mock.Mock(spec=sentry_sdk.Hub)
mock_hub.client = mock.Mock(spec=sentry_sdk.Client)
mock_hub.client.transport = mock.Mock(spec=sentry_sdk.Transport)
mock_hub.client.transport.parsed_dsn = mock.Mock(spec=Dsn)
mock_hub.client.transport.parsed_dsn.netloc = "abcd1234.ingest.sentry.io"
return mock_hub
@pytest.mark.parametrize(
["test_url", "is_sentry_url_expected"],
[
["https://asdf@abcd1234.ingest.sentry.io/123456789", True],
["https://asdf@abcd1234.ingest.notsentry.io/123456789", False],
],
)
def test_is_sentry_url_true(test_url, is_sentry_url_expected, mock_hub_with_dsn_netloc):
ret_val = is_sentry_url(mock_hub_with_dsn_netloc, test_url)
assert ret_val == is_sentry_url_expected
def test_is_sentry_url_no_client():
hub = mock.Mock()
hub.client = None
test_url = "https://asdf@abcd1234.ingest.sentry.io/123456789"
ret_val = is_sentry_url(hub, test_url)
assert not ret_val
@pytest.mark.parametrize(
"error,expected_result",
[
["", lambda x: safe_str(x)],
["some-string", lambda _: "some-string"],
],
)
def test_get_error_message(error, expected_result):
with pytest.raises(BaseException) as exc_value:
exc_value.message = error
raise Exception
assert get_error_message(exc_value) == expected_result(exc_value)
with pytest.raises(BaseException) as exc_value:
exc_value.detail = error
raise Exception
assert get_error_message(exc_value) == expected_result(exc_value)
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()
if dist.metadata["Name"] is not None
and version(dist.metadata["Name"]) is not None
}
assert installed_distributions == importlib_distributions
elif 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
else:
pytest.fail("Neither importlib nor pkg_resources is available")
def test_installed_modules_caching():
mock_generate_installed_modules = mock.Mock()
mock_generate_installed_modules.return_value = {"package": "1.0.0"}
with mock.patch("sentry_sdk.utils._installed_modules", None):
with mock.patch(
"sentry_sdk.utils._generate_installed_modules",
mock_generate_installed_modules,
):
_get_installed_modules()
assert mock_generate_installed_modules.called
mock_generate_installed_modules.reset_mock()
_get_installed_modules()
mock_generate_installed_modules.assert_not_called()
def test_devnull_inaccessible():
with mock.patch("sentry_sdk.utils.open", side_effect=OSError("oh no")):
revision = get_git_revision()
assert revision is None
def test_devnull_not_found():
with mock.patch("sentry_sdk.utils.open", side_effect=FileNotFoundError("oh no")):
revision = get_git_revision()
assert revision is None
def test_default_release():
release = get_default_release()
assert release is not None
def test_default_release_empty_string():
with mock.patch("sentry_sdk.utils.get_git_revision", return_value=""):
release = get_default_release()
assert release is None
sentry-python-1.39.2/tests/tracing/ 0000775 0000000 0000000 00000000000 14547447232 0017256 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/tracing/test_baggage.py 0000664 0000000 0000000 00000005213 14547447232 0022245 0 ustar 00root root 0000000 0000000 # 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
sentry-python-1.39.2/tests/tracing/test_decorator_async_py3.py 0000664 0000000 0000000 00000003434 14547447232 0024645 0 ustar 00root root 0000000 0000000 from unittest import mock
import pytest
import sys
from tests.conftest import patch_start_tracing_child
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)
async def my_async_example_function():
return "return_of_async_function"
@pytest.mark.asyncio
async def test_trace_decorator_async_py3():
with patch_start_tracing_child() as fake_start_child:
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_async_py3.my_async_example_function",
)
assert result2 == "return_of_async_function"
@pytest.mark.asyncio
async def test_trace_decorator_async_py3_no_trx():
with patch_start_tracing_child(fake_transaction_is_none=True):
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_async_py3.my_async_example_function",
)
assert result2 == "return_of_async_function"
sentry-python-1.39.2/tests/tracing/test_decorator_sync.py 0000664 0000000 0000000 00000003201 14547447232 0023701 0 ustar 00root root 0000000 0000000 from sentry_sdk._compat import PY2
if PY2:
from sentry_sdk.tracing_utils_py2 import start_child_span_decorator
else:
from sentry_sdk.tracing_utils_py3 import start_child_span_decorator
from sentry_sdk.utils import logger
from tests.conftest import patch_start_tracing_child
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():
with patch_start_tracing_child() as fake_start_child:
result = my_example_function()
fake_start_child.assert_not_called()
assert result == "return_of_sync_function"
result2 = start_child_span_decorator(my_example_function)()
fake_start_child.assert_called_once_with(
op="function", description="test_decorator_sync.my_example_function"
)
assert result2 == "return_of_sync_function"
def test_trace_decorator_no_trx():
with patch_start_tracing_child(fake_transaction_is_none=True):
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(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_sync.my_example_function",
)
assert result2 == "return_of_sync_function"
sentry-python-1.39.2/tests/tracing/test_deprecated.py 0000664 0000000 0000000 00000001077 14547447232 0022774 0 ustar 00root root 0000000 0000000 from sentry_sdk import start_span
from sentry_sdk.tracing import Span
def test_start_span_to_start_transaction(sentry_init, capture_events):
# XXX: this only exists for backwards compatibility with code before
# Transaction / start_transaction were introduced.
sentry_init(traces_sample_rate=1.0)
events = capture_events()
with start_span(transaction="/1/"):
pass
with start_span(Span(transaction="/2/")):
pass
assert len(events) == 2
assert events[0]["transaction"] == "/1/"
assert events[1]["transaction"] == "/2/"
sentry-python-1.39.2/tests/tracing/test_http_headers.py 0000664 0000000 0000000 00000003425 14547447232 0023345 0 ustar 00root root 0000000 0000000 import pytest
from sentry_sdk.tracing import Transaction
from sentry_sdk.tracing_utils import extract_sentrytrace_data
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
@pytest.mark.parametrize("sampled", [True, False, None])
def test_to_traceparent(sampled):
transaction = Transaction(
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
trace_id="12312012123120121231201212312012",
sampled=sampled,
)
traceparent = transaction.to_traceparent()
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])
def test_sentrytrace_extraction(sampling_decision):
sentrytrace_header = "12312012123120121231201212312012-0415201309082013-{}".format(
1 if sampling_decision is True else 0
)
assert extract_sentrytrace_data(sentrytrace_header) == {
"trace_id": "12312012123120121231201212312012",
"parent_span_id": "0415201309082013",
"parent_sampled": sampling_decision,
}
def test_iter_headers(monkeypatch):
monkeypatch.setattr(
Transaction,
"to_traceparent",
mock.Mock(return_value="12312012123120121231201212312012-0415201309082013-0"),
)
transaction = Transaction(
name="/interactions/other-dogs/new-dog",
op="greeting.sniff",
)
headers = dict(transaction.iter_headers())
assert (
headers["sentry-trace"] == "12312012123120121231201212312012-0415201309082013-0"
)
sentry-python-1.39.2/tests/tracing/test_integration_tests.py 0000664 0000000 0000000 00000022612 14547447232 0024437 0 ustar 00root root 0000000 0000000 # coding: utf-8
import weakref
import gc
import re
import pytest
import random
from sentry_sdk import (
capture_message,
configure_scope,
Hub,
start_span,
start_transaction,
)
from sentry_sdk.transport import Transport
from sentry_sdk.tracing import Transaction
@pytest.mark.parametrize("sample_rate", [0.0, 1.0])
def test_basic(sentry_init, capture_events, sample_rate):
sentry_init(traces_sample_rate=sample_rate)
events = capture_events()
with start_transaction(name="hi") as transaction:
transaction.set_status("ok")
with pytest.raises(ZeroDivisionError):
with start_span(op="foo", description="foodesc"):
1 / 0
with start_span(op="bar", description="bardesc"):
pass
if 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"
assert span1["op"] == "foo"
assert span1["description"] == "foodesc"
assert "status" not in span2.get("tags", {})
assert span2["op"] == "bar"
assert span2["description"] == "bardesc"
assert parent_span["transaction"] == "hi"
assert "status" not in event["tags"]
assert event["contexts"]["trace"]["status"] == "ok"
else:
assert not events
@pytest.mark.parametrize("sampled", [True, False, None])
@pytest.mark.parametrize("sample_rate", [0.0, 1.0])
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)
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):
with start_span() as old_span:
old_span.sampled = sampled
headers = dict(Hub.current.iter_trace_propagation_headers(old_span))
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
assert child_transaction.trace_id == old_span.trace_id
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
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
# open)
with start_transaction(child_transaction):
with configure_scope() as scope:
# change the transaction name from "WRONG" to make sure the change
# is reflected in the final data
scope.transaction = "ho"
capture_message("hello")
# in this case the child transaction won't be captured
if sampled is False or (sample_rate == 0 and sampled is None):
trace1, message = envelopes
message_payload = message.get_event()
trace1_payload = trace1.get_transaction_event()
assert trace1_payload["transaction"] == "hi"
else:
trace1, message, trace2 = envelopes
trace1_payload = trace1.get_transaction_event()
message_payload = message.get_event()
trace2_payload = trace2.get_transaction_event()
assert trace1_payload["transaction"] == "hi"
assert trace2_payload["transaction"] == "ho"
assert (
trace1_payload["contexts"]["trace"]["trace_id"]
== trace2_payload["contexts"]["trace"]["trace_id"]
== child_transaction.trace_id
== message_payload["contexts"]["trace"]["trace_id"]
)
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),
"sampled": "true" if transaction.sampled else "false",
"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,sentry-sampled=%s"
% (sample_rate, trace_id, "true" if transaction.sampled else "false")
)
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),
"sampled": "true" if transaction.sampled else "false",
"transaction": "Head SDK tx",
"trace_id": trace_id,
}
@pytest.mark.parametrize(
"args,expected_refcount",
[({"traces_sample_rate": 1.0}, 100), ({"traces_sample_rate": 0.0}, 0)],
)
def test_memory_usage(sentry_init, capture_events, args, expected_refcount):
sentry_init(**args)
references = weakref.WeakSet()
with start_transaction(name="hi"):
for i in range(100):
with start_span(op="helloworld", description="hi {}".format(i)) as span:
def foo():
pass
references.add(foo)
span.set_tag("foo", foo)
pass
del foo
del span
# required only for pypy (cpython frees immediately)
gc.collect()
assert len(references) == expected_refcount
def test_transactions_do_not_go_through_before_send(sentry_init, capture_events):
def before_send(event, hint):
raise RuntimeError("should not be called")
sentry_init(traces_sample_rate=1.0, before_send=before_send)
events = capture_events()
with start_transaction(name="/"):
pass
assert len(events) == 1
def test_start_span_after_finish(sentry_init, capture_events):
class CustomTransport(Transport):
def capture_envelope(self, envelope):
pass
def capture_event(self, event):
start_span(op="toolate", description="justdont")
pass
sentry_init(traces_sample_rate=1, transport=CustomTransport())
events = capture_events()
with start_transaction(name="hi"):
with start_span(op="bar", description="bardesc"):
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()
sentry-python-1.39.2/tests/tracing/test_misc.py 0000664 0000000 0000000 00000030725 14547447232 0021631 0 ustar 00root root 0000000 0000000 import pytest
import gc
import uuid
import os
import sentry_sdk
from sentry_sdk import Hub, start_span, start_transaction, set_measurement, push_scope
from sentry_sdk.consts import MATCH_ALL
from sentry_sdk.tracing import Span, Transaction
from sentry_sdk.tracing_utils import should_propagate_trace
from sentry_sdk.utils import Dsn
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):
sentry_init(traces_sample_rate=1.0, _experiments={"max_spans": 3})
events = capture_events()
with start_transaction(name="hi"):
for i in range(10):
with start_span(op="foo{}".format(i)):
pass
(event,) = events
assert len(event["spans"]) == 3
span1, span2, span3 = event["spans"]
assert span1["op"] == "foo0"
assert span2["op"] == "foo1"
assert span3["op"] == "foo2"
def test_transaction_naming(sentry_init, capture_events):
sentry_init(traces_sample_rate=1.0)
events = capture_events()
# only transactions have names - spans don't
with pytest.raises(TypeError):
start_span(name="foo")
assert len(events) == 0
# default name in event if no name is passed
with start_transaction() as transaction:
pass
assert len(events) == 1
assert events[0]["transaction"] == ""
# the name can be set once the transaction's already started
with start_transaction() as transaction:
transaction.name = "name-known-after-transaction-started"
assert len(events) == 2
assert events[1]["transaction"] == "name-known-after-transaction-started"
# passing in a name works, too
with start_transaction(name="a"):
pass
assert len(events) == 3
assert events[2]["transaction"] == "a"
def test_start_transaction(sentry_init):
sentry_init(traces_sample_rate=1.0)
# you can have it start a transaction for you
result1 = start_transaction(
name="/interactions/other-dogs/new-dog", op="greeting.sniff"
)
assert isinstance(result1, Transaction)
assert result1.name == "/interactions/other-dogs/new-dog"
assert result1.op == "greeting.sniff"
# or you can pass it an already-created transaction
preexisting_transaction = Transaction(
name="/interactions/other-dogs/new-dog", op="greeting.sniff"
)
result2 = start_transaction(preexisting_transaction)
assert result2 is preexisting_transaction
def test_finds_transaction_on_scope(sentry_init):
sentry_init(traces_sample_rate=1.0)
transaction = start_transaction(name="dogpark")
scope = Hub.current.scope
# See note in Scope class re: getters and setters of the `transaction`
# property. For the moment, assigning to scope.transaction merely sets the
# transaction name, rather than putting the transaction on the scope, so we
# have to assign to _span directly.
scope._span = transaction
# Reading scope.property, however, does what you'd expect, and returns the
# transaction on the scope.
assert scope.transaction is not None
assert isinstance(scope.transaction, Transaction)
assert scope.transaction.name == "dogpark"
# If the transaction is also set as the span on the scope, it can be found
# by accessing _span, too.
assert scope._span is not None
assert isinstance(scope._span, Transaction)
assert scope._span.name == "dogpark"
def test_finds_transaction_when_descendent_span_is_on_scope(
sentry_init,
):
sentry_init(traces_sample_rate=1.0)
transaction = start_transaction(name="dogpark")
child_span = transaction.start_child(op="sniffing")
scope = Hub.current.scope
scope._span = child_span
# this is the same whether it's the transaction itself or one of its
# decedents directly attached to the scope
assert scope.transaction is not None
assert isinstance(scope.transaction, Transaction)
assert scope.transaction.name == "dogpark"
# here we see that it is in fact the span on the scope, rather than the
# transaction itself
assert scope._span is not None
assert isinstance(scope._span, Span)
assert scope._span.op == "sniffing"
def test_finds_orphan_span_on_scope(sentry_init):
# this is deprecated behavior which may be removed at some point (along with
# the start_span function)
sentry_init(traces_sample_rate=1.0)
span = start_span(op="sniffing")
scope = Hub.current.scope
scope._span = span
assert scope._span is not None
assert isinstance(scope._span, Span)
assert scope._span.op == "sniffing"
def test_finds_non_orphan_span_on_scope(sentry_init):
sentry_init(traces_sample_rate=1.0)
transaction = start_transaction(name="dogpark")
child_span = transaction.start_child(op="sniffing")
scope = Hub.current.scope
scope._span = child_span
assert scope._span is not None
assert isinstance(scope._span, Span)
assert scope._span.op == "sniffing"
def test_circular_references(monkeypatch, sentry_init, request):
# TODO: We discovered while writing this test about transaction/span
# reference cycles that there's actually also a circular reference in
# `serializer.py`, between the functions `_serialize_node` and
# `_serialize_node_impl`, both of which are defined inside of the main
# `serialize` function, and each of which calls the other one. For now, in
# order to avoid having those ref cycles give us a false positive here, we
# can mock out `serialize`. In the long run, though, we should probably fix
# that. (Whenever we do work on fixing it, it may be useful to add
#
# gc.set_debug(gc.DEBUG_LEAK)
# request.addfinalizer(lambda: gc.set_debug(~gc.DEBUG_LEAK))
#
# immediately after the initial collection below, so we can see what new
# objects the garbage collector has to clean up once `transaction.finish` is
# called and the serializer runs.)
monkeypatch.setattr(
sentry_sdk.client,
"serialize",
mock.Mock(
return_value=None,
),
)
# In certain versions of python, in some environments (specifically, python
# 3.4 when run in GH Actions), we run into a `ctypes` bug which creates
# circular references when `uuid4()` is called, as happens when we're
# generating event ids. Mocking it with an implementation which doesn't use
# the `ctypes` function lets us avoid having false positives when garbage
# collecting. See https://bugs.python.org/issue20519.
monkeypatch.setattr(
uuid,
"uuid4",
mock.Mock(
return_value=uuid.UUID(bytes=os.urandom(16)),
),
)
gc.disable()
request.addfinalizer(gc.enable)
sentry_init(traces_sample_rate=1.0)
# Make sure that we're starting with a clean slate before we start creating
# transaction/span reference cycles
gc.collect()
dogpark_transaction = start_transaction(name="dogpark")
sniffing_span = dogpark_transaction.start_child(op="sniffing")
wagging_span = dogpark_transaction.start_child(op="wagging")
# At some point, you have to stop sniffing - there are balls to chase! - so finish
# this span while the dogpark transaction is still open
sniffing_span.finish()
# The wagging, however, continues long past the dogpark, so that span will
# NOT finish before the transaction ends. (Doing it in this order proves
# that both finished and unfinished spans get their cycles broken.)
dogpark_transaction.finish()
# Eventually you gotta sleep...
wagging_span.finish()
# assuming there are no cycles by this point, these should all be able to go
# out of scope and get their memory deallocated without the garbage
# collector having anything to do
del sniffing_span
del wagging_span
del dogpark_transaction
assert gc.collect() == 0
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()
# This test assumes the urls are not Sentry URLs. Use test_should_propagate_trace_to_sentry for sentry URLs.
hub.is_sentry_url = lambda _: False
hub.client.options = {"trace_propagation_targets": trace_propagation_targets}
hub.client.transport = MagicMock()
hub.client.transport.parsed_dsn = Dsn("https://bla@xxx.sentry.io/12312012")
assert should_propagate_trace(hub, url) == expected_propagation_decision
@pytest.mark.parametrize(
"dsn,url,expected_propagation_decision",
[
(
"https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
"http://example.com",
True,
),
(
"https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
"https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
False,
),
(
"https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
"http://squirrelchasers.ingest.sentry.io/12312012",
False,
),
(
"https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012",
"http://ingest.sentry.io/12312012",
True,
),
(
"https://abc@localsentry.example.com/12312012",
"http://localsentry.example.com",
False,
),
],
)
def test_should_propagate_trace_to_sentry(
sentry_init, dsn, url, expected_propagation_decision
):
sentry_init(
dsn=dsn,
traces_sample_rate=1.0,
)
Hub.current.client.transport.parsed_dsn = Dsn(dsn)
assert should_propagate_trace(Hub.current, url) == expected_propagation_decision
def test_start_transaction_updates_scope_name_source(sentry_init):
sentry_init(traces_sample_rate=1.0)
with push_scope() as scope:
with start_transaction(name="foobar", source="route"):
assert scope._transaction == "foobar"
assert scope._transaction_info == {"source": "route"}
sentry-python-1.39.2/tests/tracing/test_noop_span.py 0000664 0000000 0000000 00000003400 14547447232 0022660 0 ustar 00root root 0000000 0000000 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
sentry-python-1.39.2/tests/tracing/test_sampling.py 0000664 0000000 0000000 00000024623 14547447232 0022510 0 ustar 00root root 0000000 0000000 import random
import pytest
from sentry_sdk import Hub, start_span, start_transaction, capture_exception
from sentry_sdk.tracing import Transaction
from sentry_sdk.utils import logger
try:
from unittest import mock # python 3.3 and above
except ImportError:
import mock # python < 3.3
def test_sampling_decided_only_for_transactions(sentry_init, capture_events):
sentry_init(traces_sample_rate=0.5)
with start_transaction(name="hi") as transaction:
assert transaction.sampled is not None
with start_span() as span:
assert span.sampled == transaction.sampled
with start_span() as span:
assert span.sampled is None
@pytest.mark.parametrize("sampled", [True, False])
def test_nested_transaction_sampling_override(sentry_init, sampled):
sentry_init(traces_sample_rate=1.0)
with start_transaction(name="outer", sampled=sampled) as outer_transaction:
assert outer_transaction.sampled is sampled
with start_transaction(
name="inner", sampled=(not sampled)
) as inner_transaction:
assert inner_transaction.sampled is not sampled
assert outer_transaction.sampled is sampled
def test_no_double_sampling(sentry_init, capture_events):
# Transactions should not be subject to the global/error sample rate.
# Only the traces_sample_rate should apply.
sentry_init(traces_sample_rate=1.0, sample_rate=0.0)
events = capture_events()
with start_transaction(name="/"):
pass
assert len(events) == 1
@pytest.mark.parametrize("sampling_decision", [True, False])
def test_get_transaction_and_span_from_scope_regardless_of_sampling_decision(
sentry_init, sampling_decision
):
sentry_init(traces_sample_rate=1.0)
with start_transaction(name="/", sampled=sampling_decision):
with start_span(op="child-span"):
with start_span(op="child-child-span"):
scope = Hub.current.scope
assert scope.span.op == "child-child-span"
assert scope.transaction.name == "/"
@pytest.mark.parametrize(
"traces_sample_rate,expected_decision",
[(0.0, False), (0.25, False), (0.75, True), (1.00, True)],
)
def test_uses_traces_sample_rate_correctly(
sentry_init,
traces_sample_rate,
expected_decision,
):
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
@pytest.mark.parametrize(
"traces_sampler_return_value,expected_decision",
[(0.0, False), (0.25, False), (0.75, True), (1.00, True)],
)
def test_uses_traces_sampler_return_value_correctly(
sentry_init,
traces_sampler_return_value,
expected_decision,
):
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
@pytest.mark.parametrize("traces_sampler_return_value", [True, False])
def test_tolerates_traces_sampler_returning_a_boolean(
sentry_init, traces_sampler_return_value
):
sentry_init(traces_sampler=mock.Mock(return_value=traces_sampler_return_value))
transaction = start_transaction(name="dogpark")
assert transaction.sampled is traces_sampler_return_value
@pytest.mark.parametrize("sampling_decision", [True, False])
def test_only_captures_transaction_when_sampled_is_true(
sentry_init, sampling_decision, capture_events
):
sentry_init(traces_sampler=mock.Mock(return_value=sampling_decision))
events = capture_events()
transaction = start_transaction(name="dogpark")
transaction.finish()
assert len(events) == (1 if sampling_decision else 0)
@pytest.mark.parametrize(
"traces_sample_rate,traces_sampler_return_value", [(0, True), (1, False)]
)
def test_prefers_traces_sampler_to_traces_sample_rate(
sentry_init,
traces_sample_rate,
traces_sampler_return_value,
):
# make traces_sample_rate imply the opposite of traces_sampler, to prove
# that traces_sampler takes precedence
traces_sampler = mock.Mock(return_value=traces_sampler_return_value)
sentry_init(
traces_sample_rate=traces_sample_rate,
traces_sampler=traces_sampler,
)
transaction = start_transaction(name="dogpark")
assert traces_sampler.called is True
assert transaction.sampled is traces_sampler_return_value
@pytest.mark.parametrize("parent_sampling_decision", [True, False])
def test_ignores_inherited_sample_decision_when_traces_sampler_defined(
sentry_init, parent_sampling_decision
):
# make traces_sampler pick the opposite of the inherited decision, to prove
# that traces_sampler takes precedence
traces_sampler = mock.Mock(return_value=not parent_sampling_decision)
sentry_init(traces_sampler=traces_sampler)
transaction = start_transaction(
name="dogpark", parent_sampled=parent_sampling_decision
)
assert transaction.sampled is not parent_sampling_decision
@pytest.mark.parametrize("explicit_decision", [True, False])
def test_traces_sampler_doesnt_overwrite_explicitly_passed_sampling_decision(
sentry_init, explicit_decision
):
# make traces_sampler pick the opposite of the explicit decision, to prove
# that the explicit decision takes precedence
traces_sampler = mock.Mock(return_value=not explicit_decision)
sentry_init(traces_sampler=traces_sampler)
transaction = start_transaction(name="dogpark", sampled=explicit_decision)
assert transaction.sampled is explicit_decision
@pytest.mark.parametrize("parent_sampling_decision", [True, False])
def test_inherits_parent_sampling_decision_when_traces_sampler_undefined(
sentry_init, parent_sampling_decision
):
# make sure the parent sampling decision is the opposite of what
# traces_sample_rate would produce, to prove the inheritance takes
# precedence
sentry_init(traces_sample_rate=0.5)
mock_random_value = 0.25 if parent_sampling_decision is False else 0.75
with mock.patch.object(random, "random", return_value=mock_random_value):
transaction = start_transaction(
name="dogpark", parent_sampled=parent_sampling_decision
)
assert transaction.sampled is parent_sampling_decision
@pytest.mark.parametrize("parent_sampling_decision", [True, False])
def test_passes_parent_sampling_decision_in_sampling_context(
sentry_init, parent_sampling_decision
):
sentry_init(traces_sample_rate=1.0)
sentry_trace_header = (
"12312012123120121231201212312012-1121201211212012-{sampled}".format(
sampled=int(parent_sampling_decision)
)
)
transaction = Transaction.continue_from_headers(
headers={"sentry-trace": sentry_trace_header}, name="dogpark"
)
spy = mock.Mock(wraps=transaction)
start_transaction(transaction=spy)
# there's only one call (so index at 0) and kwargs are always last in a call
# tuple (so index at -1)
sampling_context = spy._set_initial_sampling_decision.mock_calls[0][-1][
"sampling_context"
]
assert "parent_sampled" in sampling_context
# because we passed in a spy, attribute access requires unwrapping
assert sampling_context["parent_sampled"]._mock_wraps is parent_sampling_decision
def test_passes_custom_samling_context_from_start_transaction_to_traces_sampler(
sentry_init, DictionaryContaining # noqa: N803
):
traces_sampler = mock.Mock()
sentry_init(traces_sampler=traces_sampler)
start_transaction(custom_sampling_context={"dogs": "yes", "cats": "maybe"})
traces_sampler.assert_any_call(
DictionaryContaining({"dogs": "yes", "cats": "maybe"})
)
def test_sample_rate_affects_errors(sentry_init, capture_events):
sentry_init(sample_rate=0)
events = capture_events()
try:
1 / 0
except Exception:
capture_exception()
assert len(events) == 0
@pytest.mark.parametrize(
"traces_sampler_return_value",
[
"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_and_sets_sampled_to_false_on_invalid_traces_sampler_return_value(
sentry_init, traces_sampler_return_value, StringContaining # noqa: N803
):
sentry_init(traces_sampler=mock.Mock(return_value=traces_sampler_return_value))
with mock.patch.object(logger, "warning", mock.Mock()):
transaction = start_transaction(name="dogpark")
logger.warning.assert_any_call(StringContaining("Given sample rate is invalid"))
assert transaction.sampled is False
@pytest.mark.parametrize(
"traces_sample_rate,sampled_output,reports_output",
[
(None, False, []),
(0.0, False, [("sample_rate", "transaction")]),
(1.0, True, []),
],
)
def test_records_lost_event_only_if_traces_sample_rate_enabled(
sentry_init, traces_sample_rate, sampled_output, reports_output, monkeypatch
):
reports = []
def record_lost_event(reason, data_category=None, item=None):
reports.append((reason, data_category))
sentry_init(traces_sample_rate=traces_sample_rate)
monkeypatch.setattr(
Hub.current.client.transport, "record_lost_event", record_lost_event
)
transaction = start_transaction(name="dogpark")
assert transaction.sampled is sampled_output
transaction.finish()
assert reports == reports_output
@pytest.mark.parametrize(
"traces_sampler,sampled_output,reports_output",
[
(None, False, []),
(lambda _x: 0.0, False, [("sample_rate", "transaction")]),
(lambda _x: 1.0, True, []),
],
)
def test_records_lost_event_only_if_traces_sampler_enabled(
sentry_init, traces_sampler, sampled_output, reports_output, monkeypatch
):
reports = []
def record_lost_event(reason, data_category=None, item=None):
reports.append((reason, data_category))
sentry_init(traces_sampler=traces_sampler)
monkeypatch.setattr(
Hub.current.client.transport, "record_lost_event", record_lost_event
)
transaction = start_transaction(name="dogpark")
assert transaction.sampled is sampled_output
transaction.finish()
assert reports == reports_output
sentry-python-1.39.2/tests/utils/ 0000775 0000000 0000000 00000000000 14547447232 0016767 5 ustar 00root root 0000000 0000000 sentry-python-1.39.2/tests/utils/__init__.py 0000664 0000000 0000000 00000000050 14547447232 0021073 0 ustar 00root root 0000000 0000000 # Make this a module for test_abs_path.
sentry-python-1.39.2/tests/utils/test_contextvars.py 0000664 0000000 0000000 00000001432 14547447232 0022760 0 ustar 00root root 0000000 0000000 import pytest
import random
import time
@pytest.mark.forked
def test_leaks(maybe_monkeypatched_threading):
import threading
# Need to explicitly call _get_contextvars because the SDK has already
# decided upon gevent on import.
from sentry_sdk import utils
_, ContextVar = utils._get_contextvars() # noqa: N806
ts = []
var = ContextVar("test_contextvar_leaks")
success = []
def run():
value = int(random.random() * 1000)
var.set(value)
for _ in range(100):
time.sleep(0)
assert var.get(None) == value
success.append(1)
for _ in range(20):
t = threading.Thread(target=run)
t.start()
ts.append(t)
for t in ts:
t.join()
assert len(success) == 20
sentry-python-1.39.2/tests/utils/test_general.py 0000664 0000000 0000000 00000041313 14547447232 0022017 0 ustar 00root root 0000000 0000000 # coding: utf-8
import sys
import os
import pytest
from sentry_sdk.utils import (
BadDsn,
Dsn,
safe_repr,
exceptions_from_error_tuple,
filename_for_module,
iter_event_stacktraces,
to_base64,
from_base64,
set_in_app_in_frames,
strip_string,
AnnotatedValue,
)
from sentry_sdk._compat import text_type, string_types
try:
from hypothesis import given
import hypothesis.strategies as st
except ImportError:
pass
else:
any_string = st.one_of(st.binary(), st.text())
@given(x=any_string)
def test_safe_repr_never_broken_for_strings(x):
r = safe_repr(x)
assert isinstance(r, text_type)
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",
)
# 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
assert character not in safe_repr(string)
assert character not in safe_repr(string.encode("utf-8"))
def test_abs_path():
"""Check if abs_path is actually an absolute path. This can happen either
with eval/exec like here, or when the file in the frame is relative to
__main__"""
code = compile("1/0", "test.py", "exec")
try:
exec(code, {})
except Exception:
exceptions = exceptions_from_error_tuple(sys.exc_info())
(exception,) = exceptions
frame1, frame2 = frames = exception["stacktrace"]["frames"]
for frame in frames:
assert os.path.abspath(frame["abs_path"]) == frame["abs_path"]
assert frame1["filename"] == "tests/utils/test_general.py"
assert frame2["filename"] == "test.py"
def test_filename():
x = filename_for_module
assert x("bogus", "bogus") == "bogus"
assert x("os", os.__file__) == "os.py"
import sentry_sdk.utils
assert x("sentry_sdk.utils", sentry_sdk.utils.__file__) == "sentry_sdk/utils.py"
@pytest.mark.parametrize(
"given,expected_store,expected_envelope",
[
(
"https://foobar@sentry.io/123",
"https://sentry.io/api/123/store/",
"https://sentry.io/api/123/envelope/",
),
(
"https://foobar@sentry.io/bam/123",
"https://sentry.io/bam/api/123/store/",
"https://sentry.io/bam/api/123/envelope/",
),
(
"https://foobar@sentry.io/bam/baz/123",
"https://sentry.io/bam/baz/api/123/store/",
"https://sentry.io/bam/baz/api/123/envelope/",
),
],
)
def test_parse_dsn_paths(given, expected_store, expected_envelope):
dsn = Dsn(given)
auth = dsn.to_auth()
assert auth.store_api_url == expected_store
assert auth.get_api_url("store") == expected_store
assert auth.get_api_url("envelope") == expected_envelope
@pytest.mark.parametrize(
"dsn",
[
"https://foobar@sentry.io"
"https://foobar@sentry.io/"
"https://foobar@sentry.io/asdf"
"https://foobar@sentry.io/asdf/"
"https://foobar@sentry.io/asdf/123/"
],
)
def test_parse_invalid_dsn(dsn):
with pytest.raises(BadDsn):
dsn = Dsn(dsn)
@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 new_frames[0] == resulting_frame
def test_iter_stacktraces():
assert set(
iter_event_stacktraces(
{
"threads": {"values": [{"stacktrace": 1}]},
"stacktrace": 2,
"exception": {"values": [{"stacktrace": 3}]},
}
)
) == {1, 2, 3}
# fmt: off
@pytest.mark.parametrize(
("original", "base64_encoded"),
[
# ascii only
("Dogs are great!", "RG9ncyBhcmUgZ3JlYXQh"),
# emoji
(u"🐶", "8J+Qtg=="),
# non-ascii
(
u"Καλό κορίτσι, Μάιζεϊ!",
"zprOsc67z4wgzrrOv8+Bzq/PhM+DzrksIM6czqzOuc62zrXPiiE=",
),
# mix of ascii and non-ascii
(
u"Of margir hundar! Ég geri ráð fyrir að ég þurfi stærra rúm.",
"T2YgbWFyZ2lyIGh1bmRhciEgw4lnIGdlcmkgcsOhw7AgZnlyaXIgYcOwIMOpZyDDvnVyZmkgc3TDpnJyYSByw7ptLg==",
),
],
)
# fmt: on
def test_successful_base64_conversion(original, base64_encoded):
# all unicode characters should be handled correctly
assert to_base64(original) == base64_encoded
assert from_base64(base64_encoded) == original
# "to" and "from" should be inverses
assert from_base64(to_base64(original)) == original
assert to_base64(from_base64(base64_encoded)) == base64_encoded
@pytest.mark.parametrize(
"input",
[
1231, # incorrect type
True, # incorrect type
[], # incorrect type
{}, # incorrect type
None, # incorrect type
"yayfordogs", # wrong length
"#dog", # invalid ascii character
"🐶", # non-ascii character
],
)
def test_failed_base64_conversion(input):
# conversion from base64 should fail if given input of the wrong type or
# input which isn't a valid base64 string
assert from_base64(input) is None
# any string can be converted to base64, so only type errors will cause
# 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
sentry-python-1.39.2/tests/utils/test_transaction.py 0000664 0000000 0000000 00000003003 14547447232 0022721 0 ustar 00root root 0000000 0000000 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):
pass
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"
assert x(MyClass.myfunc) == "tests.utils.test_transaction.MyClass.myfunc"
assert x(myfunc) == "tests.utils.test_transaction.myfunc"
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>)"
)
sentry-python-1.39.2/tox.ini 0000664 0000000 0000000 00000047247 14547447232 0016016 0 ustar 00root root 0000000 0000000 # Tox (http://codespeak.net/~hpk/tox/) is a tool for running tests
# in multiple virtualenvs. This configuration file will run the
# test suite on all supported python versions. To use it, "pip install tox"
# and then run "tox" from this directory.
[tox]
envlist =
# === Common ===
{py2.7,py3.5,py3.6,py3.7,py3.8,py3.9,py3.10,py3.11,py3.12}-common
# === Integrations ===
# 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-v{3.2}
# {py3.10}-django-v{4.0}
# instead of:
# {py3.7}-django-v{3.2}
# {py3.7,py3.10}-django-v{3.2,4.0}
#
# At a minimum, we should test against at least the lowest
# and the latest supported version of a framework.
# AIOHTTP
{py3.7}-aiohttp-v{3.4}
{py3.7,py3.9,py3.11}-aiohttp-v{3.8}
{py3.8,py3.11}-aiohttp-latest
# Ariadne
{py3.8,py3.11}-ariadne-v{0.20}
{py3.8,py3.11,py3.12}-ariadne-latest
# Arq
{py3.7,py3.11}-arq-v{0.23}
{py3.7,py3.11,py3.12}-arq-latest
# Asgi
{py3.7,py3.11,py3.12}-asgi
# asyncpg
{py3.7,py3.10}-asyncpg-v{0.23}
{py3.8,py3.11,py3.12}-asyncpg-latest
# AWS Lambda
# The aws_lambda tests deploy to the real AWS and have their own
# matrix of Python versions to run the test lambda function in.
# see `lambda_runtime` fixture in tests/integrations/aws_lambda.py
{py3.9}-aws_lambda
# Beam
{py3.7}-beam-v{2.12}
{py3.8,py3.11}-beam-latest
# Boto3
{py2.7,py3.6,py3.7}-boto3-v{1.12}
{py3.7,py3.11,py3.12}-boto3-v{1.21}
{py3.7,py3.11,py3.12}-boto3-v{1.29}
{py3.7,py3.11,py3.12}-boto3-latest
# Bottle
{py2.7,py3.5,py3.9}-bottle-v{0.12}
{py3.5,py3.11,py3.12}-bottle-latest
# Celery
{py2.7}-celery-v{3}
{py2.7,py3.5,py3.8}-celery-v{4}
{py3.6,py3.8}-celery-v{5.0}
{py3.7,py3.10}-celery-v{5.1,5.2}
{py3.8,py3.11}-celery-v{5.3}
{py3.8,py3.11}-celery-latest
# Chalice
{py3.6,py3.9}-chalice-v{1.16}
{py3.7,py3.10}-chalice-latest
# Clickhouse Driver
{py3.8,py3.11}-clickhouse_driver-v{0.2.0}
{py3.8,py3.11,py3.12}-clickhouse_driver-latest
# Cloud Resource Context
{py3.6,py3.11,py3.12}-cloud_resource_context
# Django
# - Django 1.x
{py2.7,py3.5}-django-v{1.8}
{py2.7,py3.5,py3.7}-django-v{1.11}
# - Django 2.x
{py3.5,py3.7}-django-v{2.0}
{py3.5,py3.9}-django-v{2.2}
# - Django 3.x
{py3.6,py3.9}-django-v{3.0}
{py3.6,py3.11}-django-v{3.2}
# - Django 4.x
{py3.8,py3.11,py3.12}-django-v{4.0,4.1,4.2}
# - Django 5.x
{py3.10,py3.11,py3.12}-django-v{5.0}
{py3.10,py3.11,py3.12}-django-latest
# Falcon
{py2.7,py3.5,py3.7}-falcon-v{1,1.4,2}
{py3.5,py3.6,py3.11,py3.12}-falcon-v{3}
{py3.7,py3.11,py3.12}-falcon-latest
# FastAPI
{py3.7,py3.10}-fastapi-v{0.79}
{py3.8,py3.11,py3.12}-fastapi-latest
# Flask
{py2.7,py3.5}-flask-v{0,0.11}
{py2.7,py3.5,py3.8}-flask-v{1}
{py3.8,py3.11,py3.12}-flask-v{2}
{py3.10,py3.11,py3.12}-flask-v{3}
{py3.10,py3.11,py3.12}-flask-latest
# Gevent
{py2.7,py3.6,py3.8,py3.10,py3.11}-gevent
# GCP
{py3.7}-gcp
# GQL
{py3.7,py3.11}-gql-v{3.4}
{py3.7,py3.11}-gql-latest
# Graphene
{py3.7,py3.11}-graphene-v{3.3}
{py3.7,py3.11,py3.12}-graphene-latest
# gRPC
{py3.7,py3.10}-grpc-v{1.21,1.30,1.40}
{py3.7,py3.11}-grpc-v{1.50}
{py3.8,py3.11,py3.12}-grpc-latest
# HTTPX
{py3.6,py3.9}-httpx-v{0.16,0.18}
{py3.6,py3.10}-httpx-v{0.20,0.22}
{py3.7,py3.11,py3.12}-httpx-v{0.23,0.24}
{py3.9,py3.11,py3.12}-httpx-v{0.25}
{py3.9,py3.11,py3.12}-httpx-latest
# Huey
{py2.7,py3.5,py3.11,py3.12}-huey-v{2.0}
{py3.5,py3.11,py3.12}-huey-latest
# Loguru
{py3.5,py3.11,py3.12}-loguru-v{0.5}
{py3.5,py3.11,py3.12}-loguru-latest
# OpenTelemetry (OTel)
{py3.7,py3.9,py3.11,py3.12}-opentelemetry
# pure_eval
{py3.5,py3.11,py3.12}-pure_eval
# PyMongo (Mongo DB)
{py2.7,py3.6}-pymongo-v{3.1}
{py2.7,py3.6,py3.9}-pymongo-v{3.12}
{py3.6,py3.11}-pymongo-v{4.0}
{py3.7,py3.11,py3.12}-pymongo-v{4.3,4.6}
{py3.7,py3.11,py3.12}-pymongo-latest
# Pyramid
{py2.7,py3.5,py3.11}-pyramid-v{1.6}
{py2.7,py3.5,py3.11,py3.12}-pyramid-v{1.10}
{py3.6,py3.11,py3.12}-pyramid-v{2.0}
{py3.6,py3.11,py3.12}-pyramid-latest
# Quart
{py3.7,py3.11}-quart-v{0.16}
{py3.8,py3.11,py3.12}-quart-v{0.19}
{py3.8,py3.11,py3.12}-quart-latest
# Redis
{py2.7,py3.7,py3.8}-redis-v{3}
{py3.7,py3.8,py3.11}-redis-v{4}
{py3.7,py3.11,py3.12}-redis-v{5}
{py3.7,py3.11,py3.12}-redis-latest
# Redis Cluster
{py2.7,py3.7,py3.8}-rediscluster-v{1,2}
# no -latest, not developed anymore
# Requests
{py2.7,py3.8,py3.11,py3.12}-requests
# RQ (Redis Queue)
{py2.7,py3.5,py3.6}-rq-v{0.6}
{py2.7,py3.5,py3.9}-rq-v{0.13,1.0}
{py3.5,py3.11}-rq-v{1.5,1.10}
{py3.7,py3.11,py3.12}-rq-v{1.15}
{py3.7,py3.11,py3.12}-rq-latest
# Sanic
{py3.5,py3.7}-sanic-v{0.8}
{py3.6,py3.8}-sanic-v{20}
{py3.7,py3.11}-sanic-v{22}
{py3.7,py3.11}-sanic-v{23}
{py3.8,py3.11}-sanic-latest
# Starlette
{py3.7,py3.10}-starlette-v{0.19}
{py3.7,py3.11}-starlette-v{0.20,0.24,0.28}
{py3.8,py3.11,py3.12}-starlette-v{0.32}
{py3.8,py3.11,py3.12}-starlette-latest
# Starlite
{py3.8,py3.11}-starlite-v{1.48,1.51}
# 1.51.14 is the last starlite version; the project continues as litestar
# SQL Alchemy
{py2.7,py3.7,py3.9}-sqlalchemy-v{1.2,1.4}
{py3.7,py3.11}-sqlalchemy-v{2.0}
{py3.7,py3.11,py3.12}-sqlalchemy-latest
# Strawberry
{py3.8,py3.11}-strawberry-v{0.209}
{py3.8,py3.11,py3.12}-strawberry-latest
# Tornado
{py3.7,py3.9}-tornado-v{5}
{py3.8,py3.11,py3.12}-tornado-v{6}
{py3.8,py3.11,py3.12}-tornado-latest
# Trytond
{py3.5,py3.6}-trytond-v{4}
{py3.6,py3.8}-trytond-v{5}
{py3.6,py3.11}-trytond-v{6}
{py3.8,py3.11,py3.12}-trytond-v{7}
{py3.8,py3.11,py3.12}-trytond-latest
[testenv]
deps =
# if you change test-requirements.txt and your change is not being reflected
# in what's installed by tox (when running tox locally), try running tox
# with the -r flag
-r test-requirements.txt
py3.8-common: hypothesis
linters: -r linter-requirements.txt
linters: werkzeug<2.3.0
# Common
{py3.6,py3.7,py3.8,py3.9,py3.10,py3.11,py3.12}-common: pytest-asyncio<=0.21.1
# See https://github.com/pytest-dev/pytest/issues/9621
# and https://github.com/pytest-dev/pytest-forked/issues/67
# for justification of the upper bound on pytest
{py3.6,py3.7,py3.8,py3.9,py3.10,py3.11,py3.12}-common: pytest<7.0.0
# AIOHTTP
aiohttp-v3.4: aiohttp~=3.4.0
aiohttp-v3.8: aiohttp~=3.8.0
aiohttp-latest: aiohttp
aiohttp: pytest-aiohttp
aiohttp-v3.8: pytest-asyncio<=0.21.1
aiohttp-latest: pytest-asyncio<=0.21.1
# Ariadne
ariadne-v0.20: ariadne~=0.20.0
ariadne-latest: ariadne
ariadne: fastapi
ariadne: flask
ariadne: httpx
# Arq
arq-v0.23: arq~=0.23.0
arq-v0.23: pydantic<2
arq-latest: arq
arq: fakeredis>=2.2.0,<2.8
arq: pytest-asyncio<=0.21.1
arq: async-timeout
# Asgi
asgi: pytest-asyncio<=0.21.1
asgi: async-asgi-testclient
# Asyncpg
asyncpg-v0.23: asyncpg~=0.23.0
asyncpg-latest: asyncpg
asyncpg: pytest-asyncio<=0.21.1
# AWS Lambda
aws_lambda: boto3
# Beam
beam-v2.12: apache-beam~=2.12.0
beam-latest: apache-beam
# Boto3
boto3-v1.12: boto3~=1.12.0
boto3-v1.21: boto3~=1.21.0
boto3-v1.29: boto3~=1.29.0
boto3-latest: boto3
# Bottle
bottle: Werkzeug<2.1.0
bottle-v0.12: bottle~=0.12.0
bottle-latest: bottle
# Celery
celery: redis
celery-v3: Celery~=3.0
celery-v4: Celery~=4.0
celery-v5.0: Celery~=5.0.0
celery-v5.1: Celery~=5.1.0
celery-v5.2: Celery~=5.2.0
celery-v5.3: Celery~=5.3.0
celery-latest: Celery
{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
chalice-latest: chalice
chalice: pytest-chalice==0.0.5
{py3.7}-chalice: botocore~=1.31
{py3.8}-chalice: botocore~=1.31
# Clickhouse Driver
clickhouse_driver-v0.2.0: clickhouse_driver~=0.2.0
clickhouse_driver-latest: clickhouse_driver
# Django
django: psycopg2-binary
django-v{1.11,2.0,2.1,2.2,3.0,3.1,3.2}: djangorestframework>=3.0.0,<4.0.0
django-v{2.0,2.2,3.0,3.2,4.0,4.1,4.2,5.0}: channels[daphne]
django-v{1.8,1.11,2.0,2.2,3.0,3.2}: Werkzeug<2.1.0
django-v{1.8,1.11,2.0}: pytest-django<4.0
django-v{2.2,3.0,3.2,4.0,4.1,4.2,5.0}: pytest-django
django-v{4.0,4.1,4.2,5.0}: djangorestframework
django-v{4.0,4.1,4.2,5.0}: pytest-asyncio<=0.21.1
django-v{4.0,4.1,4.2,5.0}: Werkzeug
django-latest: djangorestframework
django-latest: pytest-asyncio<=0.21.1
django-latest: pytest-django
django-latest: Werkzeug
django-latest: channels[daphne]
django-v1.8: Django~=1.8.0
django-v1.11: Django~=1.11.0
django-v2.0: Django~=2.0.0
django-v2.2: Django~=2.2.0
django-v3.0: Django~=3.0.0
django-v3.2: Django~=3.2.0
django-v4.0: Django~=4.0.0
django-v4.1: Django~=4.1.0
django-v4.2: Django~=4.2.0
django-v5.0: Django~=5.0.0
django-latest: Django
# Falcon
falcon-v1.4: falcon~=1.4.0
falcon-v1: falcon~=1.0
falcon-v2: falcon~=2.0
falcon-v3: falcon~=3.0
falcon-latest: falcon
# FastAPI
fastapi: httpx
fastapi: anyio<4.0.0 # thats a dep of httpx
fastapi: pytest-asyncio<=0.21.1
fastapi: python-multipart
fastapi: requests
fastapi-v{0.79}: fastapi~=0.79.0
fastapi-latest: fastapi
# Flask
flask: flask-login
flask-v{0.11,0,1,2.0}: Werkzeug<2.1.0
flask-v{0.11,0,1,2.0}: markupsafe<2.1.0
flask-v{3}: Werkzeug
flask-v0.11: Flask~=0.11.0
flask-v0: Flask~=0.11
flask-v1: Flask~=1.0
flask-v2: Flask~=2.0
flask-v3: Flask~=3.0
flask-latest: Flask
# Gevent
# See http://www.gevent.org/install.html#older-versions-of-python
# for justification of the versions pinned below
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,py3.12}-gevent: gevent>=22.10.0, <22.11.0
# See https://github.com/pytest-dev/pytest/issues/9621
# and https://github.com/pytest-dev/pytest-forked/issues/67
# for justification of the upper bound on pytest
{py3.6,py3.7,py3.8,py3.9,py3.10,py3.11,py3.12}-gevent: pytest<7.0.0
# GQL
gql-v{3.4}: gql[all]~=3.4.0
gql-latest: gql[all]
# Graphene
graphene: blinker
graphene: fastapi
graphene: flask
graphene: httpx
graphene-v{3.3}: graphene~=3.3.0
graphene-latest: graphene
# gRPC
grpc: protobuf
grpc: mypy-protobuf
grpc: types-protobuf
grpc: pytest-asyncio<=0.21.1
grpc-v1.21: grpcio-tools~=1.21.0
grpc-v1.30: grpcio-tools~=1.30.0
grpc-v1.40: grpcio-tools~=1.40.0
grpc-v1.50: grpcio-tools~=1.50.0
grpc-latest: grpcio-tools
# HTTPX
httpx-v0.16: pytest-httpx==0.10.0
httpx-v0.18: pytest-httpx==0.12.0
httpx-v0.20: pytest-httpx==0.14.0
httpx-v0.22: pytest-httpx==0.19.0
httpx-v0.23: pytest-httpx==0.21.0
httpx-v0.24: pytest-httpx==0.22.0
httpx-v0.25: pytest-httpx==0.25.0
httpx: pytest-httpx
# anyio is a dep of httpx
httpx: anyio<4.0.0
httpx-v0.16: httpx~=0.16.0
httpx-v0.18: httpx~=0.18.0
httpx-v0.20: httpx~=0.20.0
httpx-v0.22: httpx~=0.22.0
httpx-v0.23: httpx~=0.23.0
httpx-v0.24: httpx~=0.24.0
httpx-v0.25: httpx~=0.25.0
httpx-latest: httpx
# Huey
huey-v2.0: huey~=2.0.0
huey-latest: huey
# Loguru
loguru-v0.5: loguru~=0.5.0
loguru-latest: loguru
# OpenTelemetry (OTel)
opentelemetry: opentelemetry-distro
# pure_eval
pure_eval: pure_eval
# PyMongo (MongoDB)
pymongo: mockupdb
pymongo-v3.1: pymongo~=3.1.0
pymongo-v3.13: pymongo~=3.13.0
pymongo-v4.0: pymongo~=4.0.0
pymongo-v4.3: pymongo~=4.3.0
pymongo-v4.6: pymongo~=4.6.0
pymongo-latest: pymongo
# Pyramid
pyramid: Werkzeug<2.1.0
pyramid-v1.6: pyramid~=1.6.0
pyramid-v1.10: pyramid~=1.10.0
pyramid-v2.0: pyramid~=2.0.0
pyramid-latest: pyramid
# Quart
quart: quart-auth
quart: pytest-asyncio<=0.21.1
quart-v0.16: blinker<1.6
quart-v0.16: jinja2<3.1.0
quart-v0.16: Werkzeug<2.1.0
quart-v0.16: hypercorn<0.15.0
quart-v0.16: quart~=0.16.0
quart-v0.19: Werkzeug>=3.0.0
quart-v0.19: quart~=0.19.0
quart-latest: quart
# Redis
redis: fakeredis!=1.7.4
{py3.7,py3.8,py3.9,py3.10,py3.11}-redis: pytest-asyncio<=0.21.1
redis-v3: redis~=3.0
redis-v4: redis~=4.0
redis-v5: redis~=5.0
redis-latest: redis
# Redis Cluster
rediscluster-v1: redis-py-cluster~=1.0
rediscluster-v2: redis-py-cluster~=2.0
# Requests
requests: requests>=2.0
# RQ (Redis Queue)
# https://github.com/jamesls/fakeredis/issues/245
rq-v{0.6}: fakeredis<1.0
rq-v{0.6}: redis<3.2.2
rq-v{0.13,1.0,1.5,1.10}: fakeredis>=1.0,<1.7.4
rq-v{1.15}: fakeredis
rq-latest: fakeredis
rq-v0.6: rq~=0.6.0
rq-v0.13: rq~=0.13.0
rq-v1.0: rq~=1.0.0
rq-v1.5: rq~=1.5.0
rq-v1.10: rq~=1.10.0
rq-v1.15: rq~=1.15.0
rq-latest: rq
# Sanic
sanic: websockets<11.0
sanic: aiohttp
sanic-v{22,23}: sanic_testing
sanic-latest: sanic_testing
{py3.5,py3.6}-sanic: aiocontextvars==0.2.1
{py3.5}-sanic: ujson<4
sanic-v0.8: sanic~=0.8.0
sanic-v20: sanic~=20.0
sanic-v22: sanic~=22.0
sanic-v23: sanic~=23.0
sanic-latest: sanic
# Starlette
starlette: pytest-asyncio<=0.21.1
starlette: python-multipart
starlette: requests
starlette: httpx
starlette: anyio<4.0.0 # thats a dep of httpx
starlette: jinja2
starlette-v0.19: starlette~=0.19.0
starlette-v0.20: starlette~=0.20.0
starlette-v0.24: starlette~=0.24.0
starlette-v0.28: starlette~=0.28.0
starlette-v0.32: starlette~=0.32.0
starlette-latest: starlette
# Starlite
starlite: pytest-asyncio<=0.21.1
starlite: python-multipart
starlite: requests
starlite: cryptography
starlite: pydantic<2.0.0
{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
starlite-v{1.48}: starlite~=1.48.0
starlite-v{1.51}: starlite~=1.51.0
# SQLAlchemy
sqlalchemy-v1.2: sqlalchemy~=1.2.0
sqlalchemy-v1.4: sqlalchemy~=1.4.0
sqlalchemy-v2.0: sqlalchemy~=2.0.0
sqlalchemy-latest: sqlalchemy
# Strawberry
strawberry: fastapi
strawberry: flask
strawberry: httpx
strawberry-v0.209: strawberry-graphql[fastapi,flask]~=0.209.0
strawberry-latest: strawberry-graphql[fastapi,flask]
# Tornado
tornado-v5: tornado~=5.0
tornado-v6: tornado~=6.0
tornado-latest: tornado
# Trytond
trytond-v4: trytond~=4.0
trytond-v5: trytond~=5.0
trytond-v6: trytond~=6.0
trytond-v7: trytond~=7.0
trytond-latest: trytond
trytond-v{4}: werkzeug<1.0
trytond-v{5,6,7}: werkzeug<2.0
trytond-latest: werkzeug<2.0
setenv =
PYTHONDONTWRITEBYTECODE=1
common: TESTPATH=tests
aiohttp: TESTPATH=tests/integrations/aiohttp
ariadne: TESTPATH=tests/integrations/ariadne
arq: TESTPATH=tests/integrations/arq
asgi: TESTPATH=tests/integrations/asgi
asyncpg: TESTPATH=tests/integrations/asyncpg
aws_lambda: TESTPATH=tests/integrations/aws_lambda
beam: TESTPATH=tests/integrations/beam
boto3: TESTPATH=tests/integrations/boto3
bottle: TESTPATH=tests/integrations/bottle
celery: TESTPATH=tests/integrations/celery
chalice: TESTPATH=tests/integrations/chalice
clickhouse_driver: TESTPATH=tests/integrations/clickhouse_driver
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
gql: TESTPATH=tests/integrations/gql
graphene: TESTPATH=tests/integrations/graphene
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
quart: TESTPATH=tests/integrations/quart
redis: TESTPATH=tests/integrations/redis
rediscluster: TESTPATH=tests/integrations/rediscluster
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
strawberry: TESTPATH=tests/integrations/strawberry
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 =
SENTRY_PYTHON_TEST_AWS_ACCESS_KEY_ID
SENTRY_PYTHON_TEST_AWS_SECRET_ACCESS_KEY
SENTRY_PYTHON_TEST_POSTGRES_USER
SENTRY_PYTHON_TEST_POSTGRES_PASSWORD
SENTRY_PYTHON_TEST_POSTGRES_NAME
SENTRY_PYTHON_TEST_POSTGRES_HOST
usedevelop = True
extras =
bottle: bottle
falcon: falcon
flask: flask
pymongo: pymongo
basepython =
py2.7: python2.7
py3.5: python3.5
py3.6: python3.6
py3.7: python3.7
py3.8: python3.8
py3.9: python3.9
py3.10: python3.10
py3.11: python3.11
py3.12: python3.12
# 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.12
commands =
{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,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-v{0.11,0.12}: pip install more-itertools<8.11.0
; use old pytest for old Python versions:
{py2.7,py3.5}: pip install pytest-forked==1.1.3
; 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,py3.12}: python -m pytest -rsx -s --durations=5 -vvv {env:TESTPATH} {posargs}
[testenv:linters]
commands =
flake8 tests sentry_sdk
black --check tests sentry_sdk
mypy sentry_sdk