diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py index 5a719e3ee7..8cdccc8a53 100644 --- a/sentry_sdk/consts.py +++ b/sentry_sdk/consts.py @@ -240,6 +240,24 @@ class SPANDATA: Example: 58 """ + CACHE_KEY = "cache.key" + """ + The key of the requested data. + Example: template.cache.some_item.867da7e2af8e6b2f3aa7213a4080edb3 + """ + + NETWORK_PEER_ADDRESS = "network.peer.address" + """ + Peer address of the network connection - IP address or Unix domain socket name. + Example: 10.1.2.80, /tmp/my.sock, localhost + """ + + NETWORK_PEER_PORT = "network.peer.port" + """ + Peer port number of the network connection. + Example: 6379 + """ + HTTP_QUERY = "http.query" """ The Query string present in the URL. @@ -349,7 +367,8 @@ class SPANDATA: class OP: ANTHROPIC_MESSAGES_CREATE = "ai.messages.create.anthropic" - CACHE_GET_ITEM = "cache.get_item" + CACHE_GET = "cache.get" + CACHE_SET = "cache.set" COHERE_CHAT_COMPLETIONS_CREATE = "ai.chat_completions.create.cohere" COHERE_EMBEDDINGS_CREATE = "ai.embeddings.create.cohere" DB = "db" diff --git a/sentry_sdk/integrations/django/__init__.py b/sentry_sdk/integrations/django/__init__.py index bf2648b6bd..3a6a075c70 100644 --- a/sentry_sdk/integrations/django/__init__.py +++ b/sentry_sdk/integrations/django/__init__.py @@ -104,6 +104,16 @@ def is_authenticated(request_user): class DjangoIntegration(Integration): + """ + Auto instrument a Django application. + + :param transaction_style: How to derive transaction names. Either `"function_name"` or `"url"`. Defaults to `"url"`. + :param middleware_spans: Whether to create spans for middleware. Defaults to `True`. + :param signals_spans: Whether to create spans for signals. Defaults to `True`. + :param signals_denylist: A list of signals to ignore when creating spans. + :param cache_spans: Whether to create spans for cache operations. Defaults to `False`. + """ + identifier = "django" transaction_style = "" @@ -128,10 +138,12 @@ def __init__( ) self.transaction_style = transaction_style self.middleware_spans = middleware_spans + self.signals_spans = signals_spans - self.cache_spans = cache_spans self.signals_denylist = signals_denylist or [] + self.cache_spans = cache_spans + @staticmethod def setup_once(): # type: () -> None diff --git a/sentry_sdk/integrations/django/caching.py b/sentry_sdk/integrations/django/caching.py index 1b2bb477b1..1529aa8a7a 100644 --- a/sentry_sdk/integrations/django/caching.py +++ b/sentry_sdk/integrations/django/caching.py @@ -1,80 +1,151 @@ import functools from typing import TYPE_CHECKING +from urllib3.util import parse_url as urlparse from django import VERSION as DJANGO_VERSION from django.core.cache import CacheHandler import sentry_sdk from sentry_sdk.consts import OP, SPANDATA -from sentry_sdk.utils import ensure_integration_enabled +from sentry_sdk.utils import ( + SENSITIVE_DATA_SUBSTITUTE, + capture_internal_exceptions, + ensure_integration_enabled, +) if TYPE_CHECKING: from typing import Any from typing import Callable + from typing import Optional METHODS_TO_INSTRUMENT = [ + "set", + "set_many", "get", "get_many", ] -def _get_span_description(method_name, args, kwargs): - # type: (str, Any, Any) -> str - description = "{} ".format(method_name) +def _get_key(args, kwargs): + # type: (list[Any], dict[str, Any]) -> str + key = "" if args is not None and len(args) >= 1: - description += str(args[0]) + key = args[0] elif kwargs is not None and "key" in kwargs: - description += str(kwargs["key"]) + key = kwargs["key"] + + if isinstance(key, dict): + # Do not leak sensitive data + # `set_many()` has a dict {"key1": "value1", "key2": "value2"} as first argument. + # Those values could include sensitive data so we replace them with a placeholder + key = {x: SENSITIVE_DATA_SUBSTITUTE for x in key} + + return str(key) + - return description +def _get_span_description(method_name, args, kwargs): + # type: (str, list[Any], dict[str, Any]) -> str + return _get_key(args, kwargs) -def _patch_cache_method(cache, method_name): - # type: (CacheHandler, str) -> None +def _patch_cache_method(cache, method_name, address, port): + # type: (CacheHandler, str, Optional[str], Optional[int]) -> None from sentry_sdk.integrations.django import DjangoIntegration original_method = getattr(cache, method_name) @ensure_integration_enabled(DjangoIntegration, original_method) - def _instrument_call(cache, method_name, original_method, args, kwargs): - # type: (CacheHandler, str, Callable[..., Any], Any, Any) -> Any + def _instrument_call( + cache, method_name, original_method, args, kwargs, address, port + ): + # type: (CacheHandler, str, Callable[..., Any], list[Any], dict[str, Any], Optional[str], Optional[int]) -> Any + is_set_operation = method_name.startswith("set") + is_get_operation = not is_set_operation + + op = OP.CACHE_SET if is_set_operation else OP.CACHE_GET description = _get_span_description(method_name, args, kwargs) - with sentry_sdk.start_span( - op=OP.CACHE_GET_ITEM, description=description - ) as span: + with sentry_sdk.start_span(op=op, description=description) as span: value = original_method(*args, **kwargs) - if value: - span.set_data(SPANDATA.CACHE_HIT, True) - - size = len(str(value)) - span.set_data(SPANDATA.CACHE_ITEM_SIZE, size) - - else: - span.set_data(SPANDATA.CACHE_HIT, False) + with capture_internal_exceptions(): + if address is not None: + span.set_data(SPANDATA.NETWORK_PEER_ADDRESS, address) + + if port is not None: + span.set_data(SPANDATA.NETWORK_PEER_PORT, port) + + key = _get_key(args, kwargs) + if key != "": + span.set_data(SPANDATA.CACHE_KEY, key) + + item_size = None + if is_get_operation: + if value: + item_size = len(str(value)) + span.set_data(SPANDATA.CACHE_HIT, True) + else: + span.set_data(SPANDATA.CACHE_HIT, False) + else: + try: + # 'set' command + item_size = len(str(args[1])) + except IndexError: + # 'set_many' command + item_size = len(str(args[0])) + + if item_size is not None: + span.set_data(SPANDATA.CACHE_ITEM_SIZE, item_size) return value @functools.wraps(original_method) def sentry_method(*args, **kwargs): # type: (*Any, **Any) -> Any - return _instrument_call(cache, method_name, original_method, args, kwargs) + return _instrument_call( + cache, method_name, original_method, args, kwargs, address, port + ) setattr(cache, method_name, sentry_method) -def _patch_cache(cache): - # type: (CacheHandler) -> None +def _patch_cache(cache, address=None, port=None): + # type: (CacheHandler, Optional[str], Optional[int]) -> None if not hasattr(cache, "_sentry_patched"): for method_name in METHODS_TO_INSTRUMENT: - _patch_cache_method(cache, method_name) + _patch_cache_method(cache, method_name, address, port) cache._sentry_patched = True +def _get_address_port(settings): + # type: (dict[str, Any]) -> tuple[Optional[str], Optional[int]] + location = settings.get("LOCATION") + + # TODO: location can also be an array of locations + # see: https://docs.djangoproject.com/en/5.0/topics/cache/#redis + # GitHub issue: https://github.com/getsentry/sentry-python/issues/3062 + if not isinstance(location, str): + return None, None + + if "://" in location: + parsed_url = urlparse(location) + # remove the username and password from URL to not leak sensitive data. + address = "{}://{}{}".format( + parsed_url.scheme or "", + parsed_url.hostname or "", + parsed_url.path or "", + ) + port = parsed_url.port + else: + address = location + port = None + + return address, int(port) if port is not None else None + + def patch_caching(): # type: () -> None from sentry_sdk.integrations.django import DjangoIntegration @@ -90,7 +161,13 @@ def sentry_get_item(self, alias): integration = sentry_sdk.get_client().get_integration(DjangoIntegration) if integration is not None and integration.cache_spans: - _patch_cache(cache) + from django.conf import settings + + address, port = _get_address_port( + settings.CACHES[alias or "default"] + ) + + _patch_cache(cache, address, port) return cache @@ -107,7 +184,9 @@ def sentry_create_connection(self, alias): integration = sentry_sdk.get_client().get_integration(DjangoIntegration) if integration is not None and integration.cache_spans: - _patch_cache(cache) + address, port = _get_address_port(self.settings[alias or "default"]) + + _patch_cache(cache, address, port) return cache diff --git a/sentry_sdk/integrations/redis/__init__.py b/sentry_sdk/integrations/redis/__init__.py index 45f8653e29..725290407b 100644 --- a/sentry_sdk/integrations/redis/__init__.py +++ b/sentry_sdk/integrations/redis/__init__.py @@ -358,6 +358,8 @@ class RedisIntegration(Integration): def __init__(self, max_data_size=_DEFAULT_MAX_DATA_SIZE): # type: (int) -> None self.max_data_size = max_data_size + # TODO: add some prefix that users can set to specify a cache key + # GitHub issue: https://github.com/getsentry/sentry-python/issues/2965 @staticmethod def setup_once(): diff --git a/tests/integrations/aiohttp/test_aiohttp.py b/tests/integrations/aiohttp/test_aiohttp.py index 954cf853b2..2123f1c303 100644 --- a/tests/integrations/aiohttp/test_aiohttp.py +++ b/tests/integrations/aiohttp/test_aiohttp.py @@ -287,7 +287,7 @@ async def hello(request): async def test_traces_sampler_gets_request_object_in_sampling_context( sentry_init, aiohttp_client, - DictionaryContaining, # noqa:N803 + DictionaryContaining, # noqa: N803 ObjectDescribedBy, # noqa: N803 ): traces_sampler = mock.Mock() diff --git a/tests/integrations/aws_lambda/test_aws.py b/tests/integrations/aws_lambda/test_aws.py index 98196d1fcb..d18511397b 100644 --- a/tests/integrations/aws_lambda/test_aws.py +++ b/tests/integrations/aws_lambda/test_aws.py @@ -554,7 +554,7 @@ def test_handler(event, context): def test_traces_sampler_gets_correct_values_in_sampling_context( run_lambda_function, - DictionaryContaining, # noqa:N803 + DictionaryContaining, # noqa: N803 ObjectDescribedBy, # noqa: N803 StringContaining, # noqa: N803 ): diff --git a/tests/integrations/django/test_basic.py b/tests/integrations/django/test_basic.py index 88cf413f47..5e1529c762 100644 --- a/tests/integrations/django/test_basic.py +++ b/tests/integrations/django/test_basic.py @@ -1,6 +1,5 @@ import json import os -import random import re import pytest from functools import partial @@ -22,11 +21,10 @@ from sentry_sdk.consts import SPANDATA from sentry_sdk.integrations.django import DjangoIntegration, _set_db_data from sentry_sdk.integrations.django.signals_handlers import _get_receiver_name -from sentry_sdk.integrations.django.caching import _get_span_description from sentry_sdk.integrations.executing import ExecutingIntegration from sentry_sdk.scope import Scope from sentry_sdk.tracing import Span -from tests.conftest import ApproxDict, unpack_werkzeug_response +from tests.conftest import unpack_werkzeug_response from tests.integrations.django.myapp.wsgi import application from tests.integrations.django.myapp.signals import myapp_custom_signal_silenced from tests.integrations.django.utils import pytest_mark_django_db_decorator @@ -39,36 +37,6 @@ def client(): return Client(application) -@pytest.fixture -def use_django_caching(settings): - settings.CACHES = { - "default": { - "BACKEND": "django.core.cache.backends.locmem.LocMemCache", - "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000), - } - } - - -@pytest.fixture -def use_django_caching_with_middlewares(settings): - settings.CACHES = { - "default": { - "BACKEND": "django.core.cache.backends.locmem.LocMemCache", - "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000), - } - } - if hasattr(settings, "MIDDLEWARE"): - middleware = settings.MIDDLEWARE - elif hasattr(settings, "MIDDLEWARE_CLASSES"): - middleware = settings.MIDDLEWARE_CLASSES - else: - middleware = None - - if middleware is not None: - middleware.insert(0, "django.middleware.cache.UpdateCacheMiddleware") - middleware.append("django.middleware.cache.FetchFromCacheMiddleware") - - def test_view_exceptions(sentry_init, client, capture_exceptions, capture_events): sentry_init(integrations=[DjangoIntegration()], send_default_pii=True) exceptions = capture_exceptions() @@ -1158,240 +1126,3 @@ def dummy(a, b): 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"] == ApproxDict({"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"] == ApproxDict({"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"] == ApproxDict({"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"] == ApproxDict({"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"] == ApproxDict({"cache.hit": False}) - - assert len(second_event["spans"]) == 1 - assert second_event["spans"][0]["op"] == "cache.get_item" - assert second_event["spans"][0]["description"].startswith( - "get template.cache.some_identifier." - ) - assert second_event["spans"][0]["data"]["cache.hit"] - assert "cache.item_size" in second_event["spans"][0]["data"] - - -@pytest.mark.parametrize( - "method_name, args, kwargs, expected_description", - [ - ("get", None, None, "get "), - ("get", [], {}, "get "), - ("get", ["bla", "blub", "foo"], {}, "get bla"), - ( - "get_many", - [["bla 1", "bla 2", "bla 3"], "blub", "foo"], - {}, - "get_many ['bla 1', 'bla 2', 'bla 3']", - ), - ( - "get_many", - [["bla 1", "bla 2", "bla 3"], "blub", "foo"], - {"key": "bar"}, - "get_many ['bla 1', 'bla 2', 'bla 3']", - ), - ("get", [], {"key": "bar"}, "get bar"), - ( - "get", - "something", - {}, - "get s", - ), # this should never happen, just making sure that we are not raising an exception in that case. - ], -) -def test_cache_spans_get_span_description( - method_name, args, kwargs, expected_description -): - assert _get_span_description(method_name, args, kwargs) == expected_description diff --git a/tests/integrations/django/test_cache_module.py b/tests/integrations/django/test_cache_module.py new file mode 100644 index 0000000000..3815d4249a --- /dev/null +++ b/tests/integrations/django/test_cache_module.py @@ -0,0 +1,598 @@ +import pytest +import os +import random + +from django import VERSION as DJANGO_VERSION + +from werkzeug.test import Client + +try: + from django.urls import reverse +except ImportError: + from django.core.urlresolvers import reverse + +import sentry_sdk +from sentry_sdk.integrations.django import DjangoIntegration +from sentry_sdk.integrations.django.caching import _get_span_description +from tests.integrations.django.myapp.wsgi import application +from tests.integrations.django.utils import pytest_mark_django_db_decorator + + +DJANGO_VERSION = DJANGO_VERSION[:2] + + +@pytest.fixture +def client(): + return Client(application) + + +@pytest.fixture +def use_django_caching(settings): + settings.CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.locmem.LocMemCache", + "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000), + } + } + + +@pytest.fixture +def use_django_caching_with_middlewares(settings): + settings.CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.locmem.LocMemCache", + "LOCATION": "unique-snowflake-%s" % random.randint(1, 1000000), + } + } + if hasattr(settings, "MIDDLEWARE"): + middleware = settings.MIDDLEWARE + elif hasattr(settings, "MIDDLEWARE_CLASSES"): + middleware = settings.MIDDLEWARE_CLASSES + else: + middleware = None + + if middleware is not None: + middleware.insert(0, "django.middleware.cache.UpdateCacheMiddleware") + middleware.append("django.middleware.cache.FetchFromCacheMiddleware") + + +@pytest.fixture +def use_django_caching_with_port(settings): + settings.CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.dummy.DummyCache", + "LOCATION": "redis://username:password@127.0.0.1:6379", + } + } + + +@pytest.fixture +def use_django_caching_without_port(settings): + settings.CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.dummy.DummyCache", + "LOCATION": "redis://example.com", + } + } + + +@pytest.fixture +def use_django_caching_with_cluster(settings): + settings.CACHES = { + "default": { + "BACKEND": "django.core.cache.backends.dummy.DummyCache", + "LOCATION": [ + "redis://127.0.0.1:6379", + "redis://127.0.0.2:6378", + "redis://127.0.0.3:6377", + ], + } + } + + +@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 + # first_event - cache.get + assert first_event["spans"][0]["op"] == "cache.get" + assert first_event["spans"][0]["description"].startswith( + "views.decorators.cache.cache_header." + ) + assert first_event["spans"][0]["data"]["network.peer.address"] is not None + assert first_event["spans"][0]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_header." + ) + assert not first_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in first_event["spans"][0]["data"] + # first_event - cache.set + assert first_event["spans"][1]["op"] == "cache.set" + assert first_event["spans"][1]["description"].startswith( + "views.decorators.cache.cache_header." + ) + assert first_event["spans"][1]["data"]["network.peer.address"] is not None + assert first_event["spans"][1]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_header." + ) + assert "cache.hit" not in first_event["spans"][1]["data"] + assert first_event["spans"][1]["data"]["cache.item_size"] == 2 + # second_event - cache.get + assert second_event["spans"][0]["op"] == "cache.get" + assert second_event["spans"][0]["description"].startswith( + "views.decorators.cache.cache_header." + ) + assert second_event["spans"][0]["data"]["network.peer.address"] is not None + assert second_event["spans"][0]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_header." + ) + assert not second_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in second_event["spans"][0]["data"] + # second_event - cache.get 2 + assert second_event["spans"][1]["op"] == "cache.get" + assert second_event["spans"][1]["description"].startswith( + "views.decorators.cache.cache_page." + ) + assert second_event["spans"][1]["data"]["network.peer.address"] is not None + assert second_event["spans"][1]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_page." + ) + assert second_event["spans"][1]["data"]["cache.hit"] + assert second_event["spans"][1]["data"]["cache.item_size"] == 58 + + +@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 + # first_event - cache.get + assert first_event["spans"][0]["op"] == "cache.get" + assert first_event["spans"][0]["description"].startswith( + "views.decorators.cache.cache_header." + ) + assert first_event["spans"][0]["data"]["network.peer.address"] is not None + assert first_event["spans"][0]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_header." + ) + assert not first_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in first_event["spans"][0]["data"] + # first_event - cache.set + assert first_event["spans"][1]["op"] == "cache.set" + assert first_event["spans"][1]["description"].startswith( + "views.decorators.cache.cache_header." + ) + assert first_event["spans"][1]["data"]["network.peer.address"] is not None + assert first_event["spans"][1]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_header." + ) + assert "cache.hit" not in first_event["spans"][1]["data"] + assert first_event["spans"][1]["data"]["cache.item_size"] == 2 + # second_event - cache.get + assert second_event["spans"][1]["op"] == "cache.get" + assert second_event["spans"][1]["description"].startswith( + "views.decorators.cache.cache_page." + ) + assert second_event["spans"][1]["data"]["network.peer.address"] is not None + assert second_event["spans"][1]["data"]["cache.key"].startswith( + "views.decorators.cache.cache_page." + ) + assert second_event["spans"][1]["data"]["cache.hit"] + assert second_event["spans"][1]["data"]["cache.item_size"] == 58 + + +@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"]) == 2 + # first_event - cache.get + assert first_event["spans"][0]["op"] == "cache.get" + assert first_event["spans"][0]["description"].startswith( + "template.cache.some_identifier." + ) + assert first_event["spans"][0]["data"]["network.peer.address"] is not None + assert first_event["spans"][0]["data"]["cache.key"].startswith( + "template.cache.some_identifier." + ) + assert not first_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in first_event["spans"][0]["data"] + # first_event - cache.set + assert first_event["spans"][1]["op"] == "cache.set" + assert first_event["spans"][1]["description"].startswith( + "template.cache.some_identifier." + ) + assert first_event["spans"][1]["data"]["network.peer.address"] is not None + assert first_event["spans"][1]["data"]["cache.key"].startswith( + "template.cache.some_identifier." + ) + assert "cache.hit" not in first_event["spans"][1]["data"] + assert first_event["spans"][1]["data"]["cache.item_size"] == 51 + # second_event - cache.get + assert second_event["spans"][0]["op"] == "cache.get" + assert second_event["spans"][0]["description"].startswith( + "template.cache.some_identifier." + ) + assert second_event["spans"][0]["data"]["network.peer.address"] is not None + assert second_event["spans"][0]["data"]["cache.key"].startswith( + "template.cache.some_identifier." + ) + assert second_event["spans"][0]["data"]["cache.hit"] + assert second_event["spans"][0]["data"]["cache.item_size"] == 51 + + +@pytest.mark.parametrize( + "method_name, args, kwargs, expected_description", + [ + ("get", None, None, ""), + ("get", [], {}, ""), + ("get", ["bla", "blub", "foo"], {}, "bla"), + ( + "get_many", + [["bla 1", "bla 2", "bla 3"], "blub", "foo"], + {}, + "['bla 1', 'bla 2', 'bla 3']", + ), + ( + "get_many", + [["bla 1", "bla 2", "bla 3"], "blub", "foo"], + {"key": "bar"}, + "['bla 1', 'bla 2', 'bla 3']", + ), + ("get", [], {"key": "bar"}, "bar"), + ( + "get", + "something", + {}, + "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 + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_location_with_port( + sentry_init, client, capture_events, use_django_caching_with_port +): + 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")) + + for event in events: + for span in event["spans"]: + assert ( + span["data"]["network.peer.address"] == "redis://127.0.0.1" + ) # Note: the username/password are not included in the address + assert span["data"]["network.peer.port"] == 6379 + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_location_without_port( + sentry_init, client, capture_events, use_django_caching_without_port +): + 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")) + + for event in events: + for span in event["spans"]: + assert span["data"]["network.peer.address"] == "redis://example.com" + assert "network.peer.port" not in span["data"] + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_location_with_cluster( + sentry_init, client, capture_events, use_django_caching_with_cluster +): + 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")) + + for event in events: + for span in event["spans"]: + # because it is a cluster we do not know what host is actually accessed, so we omit the data + assert "network.peer.address" not in span["data"].keys() + assert "network.peer.port" not in span["data"].keys() + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_item_size(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"]) == 3 + assert first_event["spans"][0]["op"] == "cache.get" + assert not first_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in first_event["spans"][0]["data"] + + assert first_event["spans"][1]["op"] == "cache.set" + assert "cache.hit" not in first_event["spans"][1]["data"] + assert first_event["spans"][1]["data"]["cache.item_size"] == 2 + + assert first_event["spans"][2]["op"] == "cache.set" + assert "cache.hit" not in first_event["spans"][2]["data"] + assert first_event["spans"][2]["data"]["cache.item_size"] == 58 + + assert len(second_event["spans"]) == 2 + assert second_event["spans"][0]["op"] == "cache.get" + assert not second_event["spans"][0]["data"]["cache.hit"] + assert "cache.item_size" not in second_event["spans"][0]["data"] + + assert second_event["spans"][1]["op"] == "cache.get" + assert second_event["spans"][1]["data"]["cache.hit"] + assert second_event["spans"][1]["data"]["cache.item_size"] == 58 + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_get_many(sentry_init, 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() + + id = os.getpid() + + from django.core.cache import cache + + with sentry_sdk.start_transaction(): + cache.get_many([f"S{id}", f"S{id+1}"]) + cache.set(f"S{id}", "Sensitive1") + cache.get_many([f"S{id}", f"S{id+1}"]) + + (transaction,) = events + assert len(transaction["spans"]) == 7 + + assert transaction["spans"][0]["op"] == "cache.get" + assert transaction["spans"][0]["description"] == f"['S{id}', 'S{id+1}']" + + assert transaction["spans"][1]["op"] == "cache.get" + assert transaction["spans"][1]["description"] == f"S{id}" + + assert transaction["spans"][2]["op"] == "cache.get" + assert transaction["spans"][2]["description"] == f"S{id+1}" + + assert transaction["spans"][3]["op"] == "cache.set" + assert transaction["spans"][3]["description"] == f"S{id}" + + assert transaction["spans"][4]["op"] == "cache.get" + assert transaction["spans"][4]["description"] == f"['S{id}', 'S{id+1}']" + + assert transaction["spans"][5]["op"] == "cache.get" + assert transaction["spans"][5]["description"] == f"S{id}" + + assert transaction["spans"][6]["op"] == "cache.get" + assert transaction["spans"][6]["description"] == f"S{id+1}" + + +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_cache_spans_set_many(sentry_init, 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() + + id = os.getpid() + + from django.core.cache import cache + + with sentry_sdk.start_transaction(): + cache.set_many({f"S{id}": "Sensitive1", f"S{id+1}": "Sensitive2"}) + cache.get(f"S{id}") + + (transaction,) = events + assert len(transaction["spans"]) == 4 + + assert transaction["spans"][0]["op"] == "cache.set" + assert ( + transaction["spans"][0]["description"] + == f"{{'S{id}': '[Filtered]', 'S{id+1}': '[Filtered]'}}" + ) + + assert transaction["spans"][1]["op"] == "cache.set" + assert transaction["spans"][1]["description"] == f"S{id}" + + assert transaction["spans"][2]["op"] == "cache.set" + assert transaction["spans"][2]["description"] == f"S{id+1}" + + assert transaction["spans"][3]["op"] == "cache.get" + assert transaction["spans"][3]["description"] == f"S{id}" diff --git a/tox.ini b/tox.ini index 64570fa0ad..62d951eb89 100644 --- a/tox.ini +++ b/tox.ini @@ -98,7 +98,7 @@ envlist = {py3.6,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} + {py3.6,py3.9,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