From a163f83ad16299553d68b12ad162435c5387006f Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Tue, 5 Aug 2025 13:14:20 +0200 Subject: [PATCH 01/18] Do not set and then overwrite middlewares __call__ --- sentry_sdk/integrations/asgi.py | 14 ++++++++++---- sentry_sdk/integrations/starlette.py | 2 +- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py index 1b020ebbc0..9facef6834 100644 --- a/sentry_sdk/integrations/asgi.py +++ b/sentry_sdk/integrations/asgi.py @@ -42,7 +42,6 @@ if TYPE_CHECKING: from typing import Any - from typing import Callable from typing import Dict from typing import Optional from typing import Tuple @@ -102,6 +101,7 @@ def __init__( mechanism_type="asgi", # type: str span_origin="manual", # type: str http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE, # type: Tuple[str, ...] + asgi_version=None, # type: Optional[int] ): # type: (...) -> None """ @@ -140,9 +140,15 @@ def __init__( self.app = app self.http_methods_to_capture = http_methods_to_capture - if _looks_like_asgi3(app): - self.__call__ = self._run_asgi3 # type: Callable[..., Any] - else: + if asgi_version is None: + if _looks_like_asgi3(app): + asgi_version = 3 + else: + asgi_version = 2 + + if asgi_version == 3: + self.__call__ = self._run_asgi3 + elif asgi_version == 2: self.__call__ = self._run_asgi2 def _capture_lifespan_exception(self, exc): diff --git a/sentry_sdk/integrations/starlette.py b/sentry_sdk/integrations/starlette.py index d0f0bf2045..6fa09baa04 100644 --- a/sentry_sdk/integrations/starlette.py +++ b/sentry_sdk/integrations/starlette.py @@ -403,9 +403,9 @@ async def _sentry_patched_asgi_app(self, scope, receive, send): if integration else DEFAULT_HTTP_METHODS_TO_CAPTURE ), + asgi_version=3, ) - middleware.__call__ = middleware._run_asgi3 return await middleware(scope, receive, send) Starlette.__call__ = _sentry_patched_asgi_app From 6aec4fb0aebcbd4a50cc22365e2dd3adda9f3125 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Wed, 6 Aug 2025 10:19:56 +0200 Subject: [PATCH 02/18] Remove logging from asgi --- sentry_sdk/integrations/asgi.py | 19 ------------------- sentry_sdk/integrations/fastapi.py | 8 +------- sentry_sdk/integrations/starlette.py | 4 ---- 3 files changed, 1 insertion(+), 30 deletions(-) diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py index 9facef6834..1c80d8ace5 100644 --- a/sentry_sdk/integrations/asgi.py +++ b/sentry_sdk/integrations/asgi.py @@ -223,10 +223,6 @@ async def _run_app(self, scope, receive, send, asgi_version): source=transaction_source, origin=self.span_origin, ) - logger.debug( - "[ASGI] Created transaction (continuing trace): %s", - transaction, - ) else: transaction = Transaction( op=OP.HTTP_SERVER, @@ -234,17 +230,9 @@ async def _run_app(self, scope, receive, send, asgi_version): source=transaction_source, origin=self.span_origin, ) - logger.debug( - "[ASGI] Created transaction (new): %s", transaction - ) if transaction: transaction.set_tag("asgi.type", ty) - logger.debug( - "[ASGI] Set transaction name and source on transaction: '%s' / '%s'", - transaction.name, - transaction.source, - ) with ( sentry_sdk.start_transaction( @@ -254,7 +242,6 @@ async def _run_app(self, scope, receive, send, asgi_version): if transaction is not None else nullcontext() ): - logger.debug("[ASGI] Started transaction: %s", transaction) try: async def _sentry_wrapped_send(event): @@ -309,12 +296,6 @@ def event_processor(self, event, hint, asgi_scope): event["transaction"] = name event["transaction_info"] = {"source": source} - logger.debug( - "[ASGI] Set transaction name and source in event_processor: '%s' / '%s'", - event["transaction"], - event["transaction_info"]["source"], - ) - return event # Helper functions. diff --git a/sentry_sdk/integrations/fastapi.py b/sentry_sdk/integrations/fastapi.py index 76c6adee0f..1473cbcab7 100644 --- a/sentry_sdk/integrations/fastapi.py +++ b/sentry_sdk/integrations/fastapi.py @@ -6,10 +6,7 @@ from sentry_sdk.integrations import DidNotEnable from sentry_sdk.scope import should_send_default_pii from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource -from sentry_sdk.utils import ( - transaction_from_function, - logger, -) +from sentry_sdk.utils import transaction_from_function from typing import TYPE_CHECKING @@ -66,9 +63,6 @@ def _set_transaction_name_and_source(scope, transaction_style, request): source = SOURCE_FOR_STYLE[transaction_style] scope.set_transaction_name(name, source=source) - logger.debug( - "[FastAPI] Set transaction name and source on scope: %s / %s", name, source - ) def patch_get_request_handler(): diff --git a/sentry_sdk/integrations/starlette.py b/sentry_sdk/integrations/starlette.py index 6fa09baa04..c7ce40618b 100644 --- a/sentry_sdk/integrations/starlette.py +++ b/sentry_sdk/integrations/starlette.py @@ -29,7 +29,6 @@ capture_internal_exceptions, ensure_integration_enabled, event_from_exception, - logger, parse_version, transaction_from_function, ) @@ -723,9 +722,6 @@ def _set_transaction_name_and_source(scope, transaction_style, request): source = TransactionSource.ROUTE scope.set_transaction_name(name, source=source) - logger.debug( - "[Starlette] Set transaction name and source on scope: %s / %s", name, source - ) def _get_transaction_from_middleware(app, asgi_scope, integration): From 8278cf31b6cd2bc2bd773dffb92adec1717b7888 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Wed, 6 Aug 2025 14:45:00 +0200 Subject: [PATCH 03/18] format --- sentry_sdk/tracing.py | 1 - 1 file changed, 1 deletion(-) diff --git a/sentry_sdk/tracing.py b/sentry_sdk/tracing.py index dd1392d150..9abf8ddfe1 100644 --- a/sentry_sdk/tracing.py +++ b/sentry_sdk/tracing.py @@ -822,7 +822,6 @@ def __init__( # type: ignore[misc] **kwargs, # type: Unpack[SpanKwargs] ): # type: (...) -> None - super().__init__(**kwargs) self.name = name From f63d40c53b2ff7d307df56c3674406e8ba6917b6 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Wed, 6 Aug 2025 14:49:09 +0200 Subject: [PATCH 04/18] Cache is_gevent --- sentry_sdk/utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py index b0f3fa4a4c..00eb8d86a9 100644 --- a/sentry_sdk/utils.py +++ b/sentry_sdk/utils.py @@ -13,7 +13,7 @@ from collections import namedtuple from datetime import datetime, timezone from decimal import Decimal -from functools import partial, partialmethod, wraps +from functools import lru_cache, partial, partialmethod, wraps from numbers import Real from urllib.parse import parse_qs, unquote, urlencode, urlsplit, urlunsplit @@ -1858,6 +1858,7 @@ def is_module_patched(mod_name): return False +@lru_cache(maxsize=1) def is_gevent(): # type: () -> bool return is_module_patched("threading") or is_module_patched("_thread") From 78368b38b8c809258e1e71cefe240be03533369e Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Wed, 6 Aug 2025 14:50:45 +0200 Subject: [PATCH 05/18] Cache _looks_like_asgi3 --- sentry_sdk/integrations/asgi.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py index 1c80d8ace5..6d43414eb2 100644 --- a/sentry_sdk/integrations/asgi.py +++ b/sentry_sdk/integrations/asgi.py @@ -7,7 +7,7 @@ import asyncio import inspect from copy import deepcopy -from functools import partial +from functools import lru_cache, partial import sentry_sdk from sentry_sdk.api import continue_trace @@ -67,6 +67,7 @@ def _capture_exception(exc, mechanism_type="asgi"): sentry_sdk.capture_event(event, hint=hint) +@lru_cache(maxsize=5) def _looks_like_asgi3(app): # type: (Any) -> bool """ From 155e9aa6d6b773dc59a1232a6e4d647a6dd149dd Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Wed, 6 Aug 2025 14:54:01 +0200 Subject: [PATCH 06/18] Do not guess ASGI version in Quart integration --- sentry_sdk/integrations/quart.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sentry_sdk/integrations/quart.py b/sentry_sdk/integrations/quart.py index 51306bb4cd..64f7e0bcd2 100644 --- a/sentry_sdk/integrations/quart.py +++ b/sentry_sdk/integrations/quart.py @@ -95,8 +95,8 @@ async def sentry_patched_asgi_app(self, scope, receive, send): middleware = SentryAsgiMiddleware( lambda *a, **kw: old_app(self, *a, **kw), span_origin=QuartIntegration.origin, + asgi_version=3, ) - middleware.__call__ = middleware._run_asgi3 return await middleware(scope, receive, send) Quart.__call__ = sentry_patched_asgi_app From 0e37a51e75c08f642f9cc8dc3945addaff71b2c6 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Thu, 7 Aug 2025 12:23:32 +0200 Subject: [PATCH 07/18] Use asgi_version in Starlite, Litestar too --- sentry_sdk/integrations/litestar.py | 2 +- sentry_sdk/integrations/starlite.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sentry_sdk/integrations/litestar.py b/sentry_sdk/integrations/litestar.py index 4e15081cba..2be4d376e0 100644 --- a/sentry_sdk/integrations/litestar.py +++ b/sentry_sdk/integrations/litestar.py @@ -85,6 +85,7 @@ def __init__(self, app, span_origin=LitestarIntegration.origin): transaction_style="endpoint", mechanism_type="asgi", span_origin=span_origin, + asgi_version=3, ) def _capture_request_exception(self, exc): @@ -116,7 +117,6 @@ def injection_wrapper(self, *args, **kwargs): *(kwargs.get("after_exception") or []), ] - SentryLitestarASGIMiddleware.__call__ = SentryLitestarASGIMiddleware._run_asgi3 # type: ignore middleware = kwargs.get("middleware") or [] kwargs["middleware"] = [SentryLitestarASGIMiddleware, *middleware] old__init__(self, *args, **kwargs) diff --git a/sentry_sdk/integrations/starlite.py b/sentry_sdk/integrations/starlite.py index 24707a18b1..b402aa2184 100644 --- a/sentry_sdk/integrations/starlite.py +++ b/sentry_sdk/integrations/starlite.py @@ -65,6 +65,7 @@ def __init__(self, app, span_origin=StarliteIntegration.origin): transaction_style="endpoint", mechanism_type="asgi", span_origin=span_origin, + asgi_version=3, ) @@ -94,7 +95,6 @@ def injection_wrapper(self, *args, **kwargs): ] ) - SentryStarliteASGIMiddleware.__call__ = SentryStarliteASGIMiddleware._run_asgi3 # type: ignore middleware = kwargs.get("middleware") or [] kwargs["middleware"] = [SentryStarliteASGIMiddleware, *middleware] old__init__(self, *args, **kwargs) From 9f0c233490b73870b2ded78c6b6c706b94ef68d5 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Thu, 7 Aug 2025 12:24:35 +0200 Subject: [PATCH 08/18] mypy fixes --- sentry_sdk/integrations/asgi.py | 3 +-- sentry_sdk/integrations/django/asgi.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py index 6d43414eb2..14b2c93d51 100644 --- a/sentry_sdk/integrations/asgi.py +++ b/sentry_sdk/integrations/asgi.py @@ -12,7 +12,6 @@ import sentry_sdk from sentry_sdk.api import continue_trace from sentry_sdk.consts import OP - from sentry_sdk.integrations._asgi_common import ( _get_headers, _get_request_data, @@ -150,7 +149,7 @@ def __init__( if asgi_version == 3: self.__call__ = self._run_asgi3 elif asgi_version == 2: - self.__call__ = self._run_asgi2 + self.__call__ = self._run_asgi2 # type: ignore def _capture_lifespan_exception(self, exc): # type: (Exception) -> None diff --git a/sentry_sdk/integrations/django/asgi.py b/sentry_sdk/integrations/django/asgi.py index 63a3f0b8f2..773c538045 100644 --- a/sentry_sdk/integrations/django/asgi.py +++ b/sentry_sdk/integrations/django/asgi.py @@ -155,7 +155,7 @@ async def sentry_patched_asgi_handler(self, receive, send): http_methods_to_capture=integration.http_methods_to_capture, ) - return await middleware(self.scope)(receive, send) + return await middleware(self.scope)(receive, send) # type: ignore cls.__call__ = sentry_patched_asgi_handler From f4d06af7b384011a549c787e3f69e41d90bb8701 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 7 Aug 2025 10:20:55 +0200 Subject: [PATCH 09/18] feat(tracing): Improve `@trace` decorator. (#4648) Update the `@trace` decorator and make it more powerful. It accepts now the following parameters: `op`, `name`, `attributes`. Example usage: ```python import sentry_sdk from sentry_sdk.consts import OP # Simple usage (like before) @sentry_sdk.trace def process_data(): # Function implementation pass # With custom parameters @sentry_sdk.trace( op=OP.DB_QUERY, name="Get user data", attributes={"postgres": True} ) def make_db_query(sql): # Function implementation pass ``` This creates better DX for our users. --------- Co-authored-by: Daniel Szoke <7881302+szokeasaurusrex@users.noreply.github.com> --- docs/api.rst | 1 + sentry_sdk/integrations/starlite.py | 2 +- sentry_sdk/tracing.py | 78 +++++++++++++++++++------ sentry_sdk/tracing_utils.py | 90 +++++++++++++++++------------ tests/tracing/test_decorator.py | 6 +- 5 files changed, 120 insertions(+), 57 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index 7d59030033..802abee75d 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -37,6 +37,7 @@ Enriching Events Performance Monitoring ====================== +.. autofunction:: sentry_sdk.api.trace .. autofunction:: sentry_sdk.api.continue_trace .. autofunction:: sentry_sdk.api.get_current_span .. autofunction:: sentry_sdk.api.start_span diff --git a/sentry_sdk/integrations/starlite.py b/sentry_sdk/integrations/starlite.py index b402aa2184..d9d4a0724f 100644 --- a/sentry_sdk/integrations/starlite.py +++ b/sentry_sdk/integrations/starlite.py @@ -17,7 +17,7 @@ from starlite.plugins.base import get_plugin_for_value # type: ignore from starlite.routes.http import HTTPRoute # type: ignore from starlite.utils import ConnectionDataExtractor, is_async_callable, Ref # type: ignore - from pydantic import BaseModel # type: ignore + from pydantic import BaseModel except ImportError: raise DidNotEnable("Starlite is not installed") diff --git a/sentry_sdk/tracing.py b/sentry_sdk/tracing.py index 9abf8ddfe1..de575dfed2 100644 --- a/sentry_sdk/tracing.py +++ b/sentry_sdk/tracing.py @@ -1339,43 +1339,85 @@ def _set_initial_sampling_decision(self, sampling_context): if TYPE_CHECKING: @overload - def trace(func=None): - # type: (None) -> Callable[[Callable[P, R]], Callable[P, R]] + def trace(func=None, *, op=None, name=None, attributes=None): + # type: (None, Optional[str], Optional[str], Optional[dict[str, Any]]) -> Callable[[Callable[P, R]], Callable[P, R]] + # Handles: @trace() and @trace(op="custom") pass @overload def trace(func): # type: (Callable[P, R]) -> Callable[P, R] + # Handles: @trace pass -def trace(func=None): - # type: (Optional[Callable[P, R]]) -> Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]] +def trace(func=None, *, op=None, name=None, attributes=None): + # type: (Optional[Callable[P, R]], Optional[str], Optional[str], Optional[dict[str, Any]]) -> Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]] """ - Decorator to start a child span under the existing current transaction. - If there is no current transaction, then nothing will be traced. + Decorator to start a child span around a function call. - .. code-block:: - :caption: Usage + This decorator automatically creates a new span when the decorated function + is called, and finishes the span when the function returns or raises an exception. + + :param func: The function to trace. When used as a decorator without parentheses, + this is the function being decorated. When used with parameters (e.g., + ``@trace(op="custom")``, this should be None. + :type func: Callable or None + + :param op: The operation name for the span. This is a high-level description + of what the span represents (e.g., "http.client", "db.query"). + You can use predefined constants from :py:class:`sentry_sdk.consts.OP` + or provide your own string. If not provided, a default operation will + be assigned based on the template. + :type op: str or None + + :param name: The human-readable name/description for the span. If not provided, + defaults to the function name. This provides more specific details about + what the span represents (e.g., "GET /api/users", "process_user_data"). + :type name: str or None + + :param attributes: A dictionary of key-value pairs to add as attributes to the span. + Attribute values must be strings, integers, floats, or booleans. These + attributes provide additional context about the span's execution. + :type attributes: dict[str, Any] or None + + :returns: When used as ``@trace``, returns the decorated function. When used as + ``@trace(...)`` with parameters, returns a decorator function. + :rtype: Callable or decorator function + + Example:: import sentry_sdk + from sentry_sdk.consts import OP + # Simple usage with default values @sentry_sdk.trace - def my_function(): - ... + def process_data(): + # Function implementation + pass - @sentry_sdk.trace - async def my_async_function(): - ... + # With custom parameters + @sentry_sdk.trace( + op=OP.DB_QUERY, + name="Get user data", + attributes={"postgres": True} + ) + def make_db_query(sql): + # Function implementation + pass """ - from sentry_sdk.tracing_utils import start_child_span_decorator + from sentry_sdk.tracing_utils import create_span_decorator + + decorator = create_span_decorator( + op=op, + name=name, + attributes=attributes, + ) - # This patterns allows usage of both @sentry_traced and @sentry_traced(...) - # See https://stackoverflow.com/questions/52126071/decorator-with-arguments-avoid-parenthesis-when-no-arguments/52126278 if func: - return start_child_span_decorator(func) + return decorator(func) else: - return start_child_span_decorator + return decorator # Circular imports diff --git a/sentry_sdk/tracing_utils.py b/sentry_sdk/tracing_utils.py index 552f4fd59a..447a708d4d 100644 --- a/sentry_sdk/tracing_utils.py +++ b/sentry_sdk/tracing_utils.py @@ -1,4 +1,5 @@ import contextlib +import functools import inspect import os import re @@ -6,7 +7,6 @@ from collections.abc import Mapping from datetime import timedelta from decimal import ROUND_DOWN, Decimal, DefaultContext, localcontext -from functools import wraps from random import Random from urllib.parse import quote, unquote import uuid @@ -770,70 +770,86 @@ def normalize_incoming_data(incoming_data): return data -def start_child_span_decorator(func): - # type: (Any) -> Any +def create_span_decorator(op=None, name=None, attributes=None): + # type: (Optional[str], Optional[str], Optional[dict[str, Any]]) -> Any """ - Decorator to add child spans for functions. + Create a span decorator that can wrap both sync and async functions. - See also ``sentry_sdk.tracing.trace()``. + :param op: The operation type for the span. + :param name: The name of the span. + :param attributes: Additional attributes to set on the span. """ - # Asynchronous case - if inspect.iscoroutinefunction(func): - @wraps(func) - async def func_with_tracing(*args, **kwargs): - # type: (*Any, **Any) -> Any + def span_decorator(f): + # type: (Any) -> Any + """ + Decorator to create a span for the given function. + """ - span = get_current_span() + @functools.wraps(f) + async def async_wrapper(*args, **kwargs): + # type: (*Any, **Any) -> Any + current_span = get_current_span() - if span is None: + if current_span is None: logger.debug( "Cannot create a child span for %s. " "Please start a Sentry transaction before calling this function.", - qualname_from_function(func), + qualname_from_function(f), ) - return await func(*args, **kwargs) + return await f(*args, **kwargs) + + span_op = op or OP.FUNCTION + span_name = name or qualname_from_function(f) or "" - with span.start_child( - op=OP.FUNCTION, - name=qualname_from_function(func), - ): - return await func(*args, **kwargs) + with current_span.start_child( + op=span_op, + name=span_name, + ) as span: + span.update_data(attributes or {}) + result = await f(*args, **kwargs) + return result try: - func_with_tracing.__signature__ = inspect.signature(func) # type: ignore[attr-defined] + async_wrapper.__signature__ = inspect.signature(f) # type: ignore[attr-defined] except Exception: pass - # Synchronous case - else: - - @wraps(func) - def func_with_tracing(*args, **kwargs): + @functools.wraps(f) + def sync_wrapper(*args, **kwargs): # type: (*Any, **Any) -> Any + current_span = get_current_span() - span = get_current_span() - - if span is None: + if current_span is None: logger.debug( "Cannot create a child span for %s. " "Please start a Sentry transaction before calling this function.", - qualname_from_function(func), + qualname_from_function(f), ) - return func(*args, **kwargs) + return f(*args, **kwargs) + + span_op = op or OP.FUNCTION + span_name = name or qualname_from_function(f) or "" - with span.start_child( - op=OP.FUNCTION, - name=qualname_from_function(func), - ): - return func(*args, **kwargs) + with current_span.start_child( + op=span_op, + name=span_name, + ) as span: + span.update_data(attributes or {}) + result = f(*args, **kwargs) + return result try: - func_with_tracing.__signature__ = inspect.signature(func) # type: ignore[attr-defined] + sync_wrapper.__signature__ = inspect.signature(f) # type: ignore[attr-defined] except Exception: pass - return func_with_tracing + if inspect.iscoroutinefunction(f): + return async_wrapper + else: + return sync_wrapper + + return span_decorator def get_current_span(scope=None): diff --git a/tests/tracing/test_decorator.py b/tests/tracing/test_decorator.py index 18a66bd43e..9a7074c470 100644 --- a/tests/tracing/test_decorator.py +++ b/tests/tracing/test_decorator.py @@ -4,7 +4,7 @@ import pytest from sentry_sdk.tracing import trace -from sentry_sdk.tracing_utils import start_child_span_decorator +from sentry_sdk.tracing_utils import create_span_decorator from sentry_sdk.utils import logger from tests.conftest import patch_start_tracing_child @@ -24,6 +24,7 @@ def test_trace_decorator(): fake_start_child.assert_not_called() assert result == "return_of_sync_function" + start_child_span_decorator = create_span_decorator() result2 = start_child_span_decorator(my_example_function)() fake_start_child.assert_called_once_with( op="function", name="test_decorator.my_example_function" @@ -38,6 +39,7 @@ def test_trace_decorator_no_trx(): fake_debug.assert_not_called() assert result == "return_of_sync_function" + start_child_span_decorator = create_span_decorator() result2 = start_child_span_decorator(my_example_function)() fake_debug.assert_called_once_with( "Cannot create a child span for %s. " @@ -55,6 +57,7 @@ async def test_trace_decorator_async(): fake_start_child.assert_not_called() assert result == "return_of_async_function" + start_child_span_decorator = create_span_decorator() result2 = await start_child_span_decorator(my_async_example_function)() fake_start_child.assert_called_once_with( op="function", @@ -71,6 +74,7 @@ async def test_trace_decorator_async_no_trx(): fake_debug.assert_not_called() assert result == "return_of_async_function" + start_child_span_decorator = create_span_decorator() result2 = await start_child_span_decorator(my_async_example_function)() fake_debug.assert_called_once_with( "Cannot create a child span for %s. " From 0926981305a224594a195c55e1336ba23f975af7 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Fri, 8 Aug 2025 14:35:29 +0200 Subject: [PATCH 10/18] .copy() instead of copy() --- sentry_sdk/scope.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/sentry_sdk/scope.py b/sentry_sdk/scope.py index 73bf43573e..a0f5ffecd7 100644 --- a/sentry_sdk/scope.py +++ b/sentry_sdk/scope.py @@ -238,24 +238,24 @@ def __copy__(self): rv._name = self._name rv._fingerprint = self._fingerprint rv._transaction = self._transaction - rv._transaction_info = dict(self._transaction_info) + rv._transaction_info = self._transaction_info.copy() rv._user = self._user - rv._tags = dict(self._tags) - rv._contexts = dict(self._contexts) - rv._extras = dict(self._extras) + rv._tags = self._tags.copy() + rv._contexts = self._contexts.copy() + rv._extras = self._extras.copy() rv._breadcrumbs = copy(self._breadcrumbs) - rv._n_breadcrumbs_truncated = copy(self._n_breadcrumbs_truncated) - rv._event_processors = list(self._event_processors) - rv._error_processors = list(self._error_processors) + rv._n_breadcrumbs_truncated = self._n_breadcrumbs_truncated + rv._event_processors = self._event_processors.copy() + rv._error_processors = self._error_processors.copy() rv._propagation_context = self._propagation_context rv._should_capture = self._should_capture rv._span = self._span rv._session = self._session rv._force_auto_session_tracking = self._force_auto_session_tracking - rv._attachments = list(self._attachments) + rv._attachments = self._attachments.copy() rv._profile = self._profile From 5d624244e3c9135e3dba442bcff23a4410215ee5 Mon Sep 17 00:00:00 2001 From: Daniel Szoke <7881302+szokeasaurusrex@users.noreply.github.com> Date: Thu, 7 Aug 2025 17:37:01 +0200 Subject: [PATCH 11/18] ref(clickhouse): List `send_data` parameters (#4667) Explicitly list the `send_data` parameters in the wrapped function. The parameters are coming from [here](https://github.com/mymarilyn/clickhouse-driver/blob/8a4e7c5b99b532df2b015651d893a6f36288a22c/clickhouse_driver/client.py#L634). Continue also providing `*args` and `**kwargs`, but only for forwards-compatibility. --- Thank you for contributing to `sentry-python`! Please add tests to validate your changes, and lint your code using `tox -e linters`. Running the test suite on your PR might require maintainer approval. --- sentry_sdk/integrations/clickhouse_driver.py | 24 +++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/sentry_sdk/integrations/clickhouse_driver.py b/sentry_sdk/integrations/clickhouse_driver.py index 2561bfad04..7a977bc278 100644 --- a/sentry_sdk/integrations/clickhouse_driver.py +++ b/sentry_sdk/integrations/clickhouse_driver.py @@ -49,9 +49,7 @@ def setup_once() -> None: ) # If the query contains parameters then the send_data function is used to send those parameters to clickhouse - clickhouse_driver.client.Client.send_data = _wrap_send_data( - clickhouse_driver.client.Client.send_data - ) + _wrap_send_data() # Every query ends either with the Client's `receive_end_of_query` (no result expected) # or its `receive_result` (result expected) @@ -128,23 +126,27 @@ def _inner_end(*args: P.args, **kwargs: P.kwargs) -> T: return _inner_end -def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]: - def _inner_send_data(*args: P.args, **kwargs: P.kwargs) -> T: - instance = args[0] # type: clickhouse_driver.client.Client - data = args[2] - span = getattr(instance.connection, "_sentry_span", None) +def _wrap_send_data() -> None: + original_send_data = clickhouse_driver.client.Client.send_data + + def _inner_send_data( # type: ignore[no-untyped-def] # clickhouse-driver does not type send_data + self, sample_block, data, types_check=False, columnar=False, *args, **kwargs + ): + span = getattr(self.connection, "_sentry_span", None) if span is not None: - _set_db_data(span, instance.connection) + _set_db_data(span, self.connection) if should_send_default_pii(): db_params = span._data.get("db.params", []) db_params.extend(data) span.set_data("db.params", db_params) - return f(*args, **kwargs) + return original_send_data( + self, sample_block, data, types_check, columnar, *args, **kwargs + ) - return _inner_send_data + clickhouse_driver.client.Client.send_data = _inner_send_data def _set_db_data( From fac580d8ac23596151b3c246939910137ec2ef37 Mon Sep 17 00:00:00 2001 From: Daniel Szoke <7881302+szokeasaurusrex@users.noreply.github.com> Date: Thu, 7 Aug 2025 17:37:12 +0200 Subject: [PATCH 12/18] fix(clickhouse): Don't eat the generator data (#4669) Currently, the Clickhouse integration consumes any data passed as a generator when reading it for insertion as `db_params`. Instead, since generators cannot be cloned, we need to wrap the generator to add the params as we iterate over it. Fixes #4657 --- Thank you for contributing to `sentry-python`! Please add tests to validate your changes, and lint your code using `tox -e linters`. Running the test suite on your PR might require maintainer approval. --- sentry_sdk/integrations/clickhouse_driver.py | 22 +++++++++++-- .../test_clickhouse_driver.py | 32 +++++++++++++++++++ 2 files changed, 52 insertions(+), 2 deletions(-) diff --git a/sentry_sdk/integrations/clickhouse_driver.py b/sentry_sdk/integrations/clickhouse_driver.py index 7a977bc278..bbaaaeec8e 100644 --- a/sentry_sdk/integrations/clickhouse_driver.py +++ b/sentry_sdk/integrations/clickhouse_driver.py @@ -11,7 +11,8 @@ # without introducing a hard dependency on `typing_extensions` # from: https://stackoverflow.com/a/71944042/300572 if TYPE_CHECKING: - from typing import ParamSpec, Callable + from collections.abc import Iterator + from typing import Any, ParamSpec, Callable else: # Fake ParamSpec class ParamSpec: @@ -139,7 +140,24 @@ def _inner_send_data( # type: ignore[no-untyped-def] # clickhouse-driver does n if should_send_default_pii(): db_params = span._data.get("db.params", []) - db_params.extend(data) + + if isinstance(data, (list, tuple)): + db_params.extend(data) + + else: # data is a generic iterator + orig_data = data + + # Wrap the generator to add items to db.params as they are yielded. + # This allows us to send the params to Sentry without needing to allocate + # memory for the entire generator at once. + def wrapped_generator() -> "Iterator[Any]": + for item in orig_data: + db_params.append(item) + yield item + + # Replace the original iterator with the wrapped one. + data = wrapped_generator() + span.set_data("db.params", db_params) return original_send_data( diff --git a/tests/integrations/clickhouse_driver/test_clickhouse_driver.py b/tests/integrations/clickhouse_driver/test_clickhouse_driver.py index 0675ad9ff5..635f9334c4 100644 --- a/tests/integrations/clickhouse_driver/test_clickhouse_driver.py +++ b/tests/integrations/clickhouse_driver/test_clickhouse_driver.py @@ -342,6 +342,38 @@ def test_clickhouse_client_spans( assert event["spans"] == expected_spans +def test_clickhouse_spans_with_generator(sentry_init, capture_events): + sentry_init( + integrations=[ClickhouseDriverIntegration()], + send_default_pii=True, + traces_sample_rate=1.0, + ) + events = capture_events() + + # Use a generator to test that the integration obtains values from the generator, + # without consuming the generator. + values = ({"x": i} for i in range(3)) + + with start_transaction(name="test_clickhouse_transaction"): + 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", values) + res = client.execute("SELECT x FROM test") + + # Verify that the integration did not consume the generator + assert res == [(0,), (1,), (2,)] + + (event,) = events + spans = event["spans"] + + [span] = [ + span for span in spans if span["description"] == "INSERT INTO test (x) VALUES" + ] + + assert span["data"]["db.params"] == [{"x": 0}, {"x": 1}, {"x": 2}] + + def test_clickhouse_client_spans_with_pii( sentry_init, capture_events, capture_envelopes ) -> None: From 66f47ecbbb407cbdc4d4ef2a7d477c238a575ddb Mon Sep 17 00:00:00 2001 From: Fabian Schindler Date: Fri, 8 Aug 2025 13:03:03 +0200 Subject: [PATCH 13/18] feat(anthropic) Update span attributes to use `gen_ai.*` namespace instead of `ai.*` (#4674) Update `AnthropicIntegration` to support Otel and Sentry AI Agents module compatible span attributes of `gen_ai.*` family. Closes https://linear.app/getsentry/issue/TET-996/improve-integration-for-anthropic-sdk --------- Co-authored-by: Anton Pirker --- sentry_sdk/ai/utils.py | 18 +- sentry_sdk/integrations/anthropic.py | 213 ++++++++++++------ sentry_sdk/integrations/starlite.py | 2 +- .../integrations/anthropic/test_anthropic.py | 212 +++++++++-------- 4 files changed, 267 insertions(+), 178 deletions(-) diff --git a/sentry_sdk/ai/utils.py b/sentry_sdk/ai/utils.py index a3c62600c0..cf52cba6e8 100644 --- a/sentry_sdk/ai/utils.py +++ b/sentry_sdk/ai/utils.py @@ -7,8 +7,8 @@ from sentry_sdk.utils import logger -def _normalize_data(data): - # type: (Any) -> Any +def _normalize_data(data, unpack=True): + # type: (Any, bool) -> Any # convert pydantic data (e.g. OpenAI v1+) to json compatible format if hasattr(data, "model_dump"): @@ -18,18 +18,18 @@ def _normalize_data(data): logger.warning("Could not convert pydantic data to JSON: %s", e) return data if isinstance(data, list): - if len(data) == 1: - return _normalize_data(data[0]) # remove empty dimensions - return list(_normalize_data(x) for x in data) + if unpack and len(data) == 1: + return _normalize_data(data[0], unpack=unpack) # remove empty dimensions + return list(_normalize_data(x, unpack=unpack) for x in data) if isinstance(data, dict): - return {k: _normalize_data(v) for (k, v) in data.items()} + return {k: _normalize_data(v, unpack=unpack) for (k, v) in data.items()} return data -def set_data_normalized(span, key, value): - # type: (Span, str, Any) -> None - normalized = _normalize_data(value) +def set_data_normalized(span, key, value, unpack=True): + # type: (Span, str, Any, bool) -> None + normalized = _normalize_data(value, unpack=unpack) if isinstance(normalized, (int, float, bool, str)): span.set_data(key, normalized) else: diff --git a/sentry_sdk/integrations/anthropic.py b/sentry_sdk/integrations/anthropic.py index 1e1f9112a1..05d45ef62f 100644 --- a/sentry_sdk/integrations/anthropic.py +++ b/sentry_sdk/integrations/anthropic.py @@ -1,8 +1,10 @@ from functools import wraps +import json from typing import TYPE_CHECKING import sentry_sdk from sentry_sdk.ai.monitoring import record_token_usage +from sentry_sdk.ai.utils import set_data_normalized from sentry_sdk.consts import OP, SPANDATA from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration from sentry_sdk.scope import should_send_default_pii @@ -10,9 +12,15 @@ capture_internal_exceptions, event_from_exception, package_version, + safe_serialize, ) try: + try: + from anthropic import NOT_GIVEN + except ImportError: + NOT_GIVEN = None + from anthropic.resources import AsyncMessages, Messages if TYPE_CHECKING: @@ -53,8 +61,11 @@ def _capture_exception(exc): sentry_sdk.capture_event(event, hint=hint) -def _calculate_token_usage(result, span): - # type: (Messages, Span) -> None +def _get_token_usage(result): + # type: (Messages) -> tuple[int, int] + """ + Get token usage from the Anthropic response. + """ input_tokens = 0 output_tokens = 0 if hasattr(result, "usage"): @@ -64,37 +75,13 @@ def _calculate_token_usage(result, span): if hasattr(usage, "output_tokens") and isinstance(usage.output_tokens, int): output_tokens = usage.output_tokens - total_tokens = input_tokens + output_tokens + return input_tokens, output_tokens - record_token_usage( - span, - input_tokens=input_tokens, - output_tokens=output_tokens, - total_tokens=total_tokens, - ) - -def _get_responses(content): - # type: (list[Any]) -> list[dict[str, Any]] +def _collect_ai_data(event, model, input_tokens, output_tokens, content_blocks): + # type: (MessageStreamEvent, str | None, int, int, list[str]) -> tuple[str | None, int, int, list[str]] """ - Get JSON of a Anthropic responses. - """ - responses = [] - for item in content: - if hasattr(item, "text"): - responses.append( - { - "type": item.type, - "text": item.text, - } - ) - return responses - - -def _collect_ai_data(event, input_tokens, output_tokens, content_blocks): - # type: (MessageStreamEvent, int, int, list[str]) -> tuple[int, int, list[str]] - """ - Count token usage and collect content blocks from the AI streaming response. + Collect model information, token usage, and collect content blocks from the AI streaming response. """ with capture_internal_exceptions(): if hasattr(event, "type"): @@ -102,6 +89,7 @@ def _collect_ai_data(event, input_tokens, output_tokens, content_blocks): usage = event.message.usage input_tokens += usage.input_tokens output_tokens += usage.output_tokens + model = event.message.model or model elif event.type == "content_block_start": pass elif event.type == "content_block_delta": @@ -114,31 +102,80 @@ def _collect_ai_data(event, input_tokens, output_tokens, content_blocks): elif event.type == "message_delta": output_tokens += event.usage.output_tokens - return input_tokens, output_tokens, content_blocks + return model, input_tokens, output_tokens, content_blocks -def _add_ai_data_to_span( - span, integration, input_tokens, output_tokens, content_blocks -): - # type: (Span, AnthropicIntegration, int, int, list[str]) -> None +def _set_input_data(span, kwargs, integration): + # type: (Span, dict[str, Any], AnthropicIntegration) -> None """ - Add token usage and content blocks from the AI streaming response to the span. + Set input data for the span based on the provided keyword arguments for the anthropic message creation. """ - with capture_internal_exceptions(): - if should_send_default_pii() and integration.include_prompts: - complete_message = "".join(content_blocks) - span.set_data( - SPANDATA.AI_RESPONSES, - [{"type": "text", "text": complete_message}], - ) - total_tokens = input_tokens + output_tokens - record_token_usage( + messages = kwargs.get("messages") + if ( + messages is not None + and len(messages) > 0 + and should_send_default_pii() + and integration.include_prompts + ): + set_data_normalized( + span, SPANDATA.GEN_AI_REQUEST_MESSAGES, safe_serialize(messages) + ) + + set_data_normalized( + span, SPANDATA.GEN_AI_RESPONSE_STREAMING, kwargs.get("stream", False) + ) + + kwargs_keys_to_attributes = { + "max_tokens": SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, + "model": SPANDATA.GEN_AI_REQUEST_MODEL, + "temperature": SPANDATA.GEN_AI_REQUEST_TEMPERATURE, + "top_k": SPANDATA.GEN_AI_REQUEST_TOP_K, + "top_p": SPANDATA.GEN_AI_REQUEST_TOP_P, + } + for key, attribute in kwargs_keys_to_attributes.items(): + value = kwargs.get(key) + if value is not NOT_GIVEN and value is not None: + set_data_normalized(span, attribute, value) + + # Input attributes: Tools + tools = kwargs.get("tools") + if tools is not NOT_GIVEN and tools is not None and len(tools) > 0: + set_data_normalized( + span, SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS, safe_serialize(tools) + ) + + +def _set_output_data( + span, + integration, + model, + input_tokens, + output_tokens, + content_blocks, + finish_span=False, +): + # type: (Span, AnthropicIntegration, str | None, int | None, int | None, list[Any], bool) -> None + """ + Set output data for the span based on the AI response.""" + span.set_data(SPANDATA.GEN_AI_RESPONSE_MODEL, model) + if should_send_default_pii() and integration.include_prompts: + set_data_normalized( span, - input_tokens=input_tokens, - output_tokens=output_tokens, - total_tokens=total_tokens, + SPANDATA.GEN_AI_RESPONSE_TEXT, + json.dumps(content_blocks), + unpack=False, ) - span.set_data(SPANDATA.AI_STREAMING, True) + + record_token_usage( + span, + input_tokens=input_tokens, + output_tokens=output_tokens, + ) + + # TODO: GEN_AI_RESPONSE_TOOL_CALLS ? + + if finish_span: + span.__exit__(None, None, None) def _sentry_patched_create_common(f, *args, **kwargs): @@ -155,31 +192,41 @@ def _sentry_patched_create_common(f, *args, **kwargs): except TypeError: return f(*args, **kwargs) + model = kwargs.get("model", "") + span = sentry_sdk.start_span( - op=OP.ANTHROPIC_MESSAGES_CREATE, - description="Anthropic messages create", + op=OP.GEN_AI_CHAT, + name=f"chat {model}".strip(), origin=AnthropicIntegration.origin, ) span.__enter__() - result = yield f, args, kwargs + _set_input_data(span, kwargs, integration) - # add data to span and finish it - messages = list(kwargs["messages"]) - model = kwargs.get("model") + result = yield f, args, kwargs with capture_internal_exceptions(): - span.set_data(SPANDATA.AI_MODEL_ID, model) - span.set_data(SPANDATA.AI_STREAMING, False) - - if should_send_default_pii() and integration.include_prompts: - span.set_data(SPANDATA.AI_INPUT_MESSAGES, messages) - if hasattr(result, "content"): - if should_send_default_pii() and integration.include_prompts: - span.set_data(SPANDATA.AI_RESPONSES, _get_responses(result.content)) - _calculate_token_usage(result, span) - span.__exit__(None, None, None) + input_tokens, output_tokens = _get_token_usage(result) + + content_blocks = [] + for content_block in result.content: + if hasattr(content_block, "to_dict"): + content_blocks.append(content_block.to_dict()) + elif hasattr(content_block, "model_dump"): + content_blocks.append(content_block.model_dump()) + elif hasattr(content_block, "text"): + content_blocks.append({"type": "text", "text": content_block.text}) + + _set_output_data( + span=span, + integration=integration, + model=getattr(result, "model", None), + input_tokens=input_tokens, + output_tokens=output_tokens, + content_blocks=content_blocks, + finish_span=True, + ) # Streaming response elif hasattr(result, "_iterator"): @@ -187,37 +234,53 @@ def _sentry_patched_create_common(f, *args, **kwargs): def new_iterator(): # type: () -> Iterator[MessageStreamEvent] + model = None input_tokens = 0 output_tokens = 0 content_blocks = [] # type: list[str] for event in old_iterator: - input_tokens, output_tokens, content_blocks = _collect_ai_data( - event, input_tokens, output_tokens, content_blocks + model, input_tokens, output_tokens, content_blocks = ( + _collect_ai_data( + event, model, input_tokens, output_tokens, content_blocks + ) ) yield event - _add_ai_data_to_span( - span, integration, input_tokens, output_tokens, content_blocks + _set_output_data( + span=span, + integration=integration, + model=model, + input_tokens=input_tokens, + output_tokens=output_tokens, + content_blocks=[{"text": "".join(content_blocks), "type": "text"}], + finish_span=True, ) - span.__exit__(None, None, None) async def new_iterator_async(): # type: () -> AsyncIterator[MessageStreamEvent] + model = None input_tokens = 0 output_tokens = 0 content_blocks = [] # type: list[str] async for event in old_iterator: - input_tokens, output_tokens, content_blocks = _collect_ai_data( - event, input_tokens, output_tokens, content_blocks + model, input_tokens, output_tokens, content_blocks = ( + _collect_ai_data( + event, model, input_tokens, output_tokens, content_blocks + ) ) yield event - _add_ai_data_to_span( - span, integration, input_tokens, output_tokens, content_blocks + _set_output_data( + span=span, + integration=integration, + model=model, + input_tokens=input_tokens, + output_tokens=output_tokens, + content_blocks=[{"text": "".join(content_blocks), "type": "text"}], + finish_span=True, ) - span.__exit__(None, None, None) if str(type(result._iterator)) == "": result._iterator = new_iterator_async() diff --git a/sentry_sdk/integrations/starlite.py b/sentry_sdk/integrations/starlite.py index d9d4a0724f..b402aa2184 100644 --- a/sentry_sdk/integrations/starlite.py +++ b/sentry_sdk/integrations/starlite.py @@ -17,7 +17,7 @@ from starlite.plugins.base import get_plugin_for_value # type: ignore from starlite.routes.http import HTTPRoute # type: ignore from starlite.utils import ConnectionDataExtractor, is_async_callable, Ref # type: ignore - from pydantic import BaseModel + from pydantic import BaseModel # type: ignore except ImportError: raise DidNotEnable("Starlite is not installed") diff --git a/tests/integrations/anthropic/test_anthropic.py b/tests/integrations/anthropic/test_anthropic.py index e6e1a40aa9..eba07a1df6 100644 --- a/tests/integrations/anthropic/test_anthropic.py +++ b/tests/integrations/anthropic/test_anthropic.py @@ -20,7 +20,7 @@ async def __call__(self, *args, **kwargs): from anthropic.types.message_delta_event import MessageDeltaEvent from anthropic.types.message_start_event import MessageStartEvent -from sentry_sdk.integrations.anthropic import _add_ai_data_to_span, _collect_ai_data +from sentry_sdk.integrations.anthropic import _set_output_data, _collect_ai_data from sentry_sdk.utils import package_version try: @@ -112,23 +112,27 @@ def test_nonstreaming_create_message( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"type": "text", "text": "Hi, I'm Claude."} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "Hello, Claude"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "Hi, I\'m Claude.", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 10 - assert span["data"]["gen_ai.usage.output_tokens"] == 20 - assert span["data"]["gen_ai.usage.total_tokens"] == 30 - assert span["data"][SPANDATA.AI_STREAMING] is False + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 10 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 20 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 30 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is False @pytest.mark.asyncio @@ -180,23 +184,27 @@ async def test_nonstreaming_create_message_async( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"type": "text", "text": "Hi, I'm Claude."} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "Hello, Claude"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "Hi, I\'m Claude.", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 10 - assert span["data"]["gen_ai.usage.output_tokens"] == 20 - assert span["data"]["gen_ai.usage.total_tokens"] == 30 - assert span["data"][SPANDATA.AI_STREAMING] is False + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 10 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 20 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 30 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is False @pytest.mark.parametrize( @@ -279,24 +287,28 @@ def test_streaming_create_message( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"type": "text", "text": "Hi! I'm Claude!"} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "Hello, Claude"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "Hi! I\'m Claude!", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 10 - assert span["data"]["gen_ai.usage.output_tokens"] == 30 - assert span["data"]["gen_ai.usage.total_tokens"] == 40 - assert span["data"][SPANDATA.AI_STREAMING] is True + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 10 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 30 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 40 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True @pytest.mark.asyncio @@ -382,24 +394,28 @@ async def test_streaming_create_message_async( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"type": "text", "text": "Hi! I'm Claude!"} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "Hello, Claude"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "Hi! I\'m Claude!", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 10 - assert span["data"]["gen_ai.usage.output_tokens"] == 30 - assert span["data"]["gen_ai.usage.total_tokens"] == 40 - assert span["data"][SPANDATA.AI_STREAMING] is True + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 10 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 30 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 40 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True @pytest.mark.skipif( @@ -512,23 +528,27 @@ def test_streaming_create_message_with_input_json_delta( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"text": "{'location': 'San Francisco, CA'}", "type": "text"} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "What is the weather like in San Francisco?"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "{\'location\': \'San Francisco, CA\'}", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 366 - assert span["data"]["gen_ai.usage.output_tokens"] == 51 - assert span["data"]["gen_ai.usage.total_tokens"] == 417 - assert span["data"][SPANDATA.AI_STREAMING] is True + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 366 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 51 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 417 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True @pytest.mark.asyncio @@ -648,24 +668,28 @@ async def test_streaming_create_message_with_input_json_delta_async( assert len(event["spans"]) == 1 (span,) = event["spans"] - assert span["op"] == OP.ANTHROPIC_MESSAGES_CREATE - assert span["description"] == "Anthropic messages create" - assert span["data"][SPANDATA.AI_MODEL_ID] == "model" + assert span["op"] == OP.GEN_AI_CHAT + assert span["description"] == "chat model" + assert span["data"][SPANDATA.GEN_AI_REQUEST_MODEL] == "model" if send_default_pii and include_prompts: - assert span["data"][SPANDATA.AI_INPUT_MESSAGES] == messages - assert span["data"][SPANDATA.AI_RESPONSES] == [ - {"text": "{'location': 'San Francisco, CA'}", "type": "text"} - ] + assert ( + span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES] + == '[{"role": "user", "content": "What is the weather like in San Francisco?"}]' + ) + assert ( + span["data"][SPANDATA.GEN_AI_RESPONSE_TEXT] + == '[{"text": "{\'location\': \'San Francisco, CA\'}", "type": "text"}]' + ) else: - assert SPANDATA.AI_INPUT_MESSAGES not in span["data"] - assert SPANDATA.AI_RESPONSES not in span["data"] + assert SPANDATA.GEN_AI_REQUEST_MESSAGES not in span["data"] + assert SPANDATA.GEN_AI_RESPONSE_TEXT not in span["data"] - assert span["data"]["gen_ai.usage.input_tokens"] == 366 - assert span["data"]["gen_ai.usage.output_tokens"] == 51 - assert span["data"]["gen_ai.usage.total_tokens"] == 417 - assert span["data"][SPANDATA.AI_STREAMING] is True + assert span["data"][SPANDATA.GEN_AI_USAGE_INPUT_TOKENS] == 366 + assert span["data"][SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS] == 51 + assert span["data"][SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS] == 417 + assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True def test_exception_message_create(sentry_init, capture_events): @@ -770,15 +794,16 @@ def test_collect_ai_data_with_input_json_delta(): index=0, type="content_block_delta", ) - + model = None input_tokens = 10 output_tokens = 20 content_blocks = [] - new_input_tokens, new_output_tokens, new_content_blocks = _collect_ai_data( - event, input_tokens, output_tokens, content_blocks + model, new_input_tokens, new_output_tokens, new_content_blocks = _collect_ai_data( + event, model, input_tokens, output_tokens, content_blocks ) + assert model is None assert new_input_tokens == input_tokens assert new_output_tokens == output_tokens assert new_content_blocks == ["test"] @@ -788,7 +813,7 @@ def test_collect_ai_data_with_input_json_delta(): ANTHROPIC_VERSION < (0, 27), reason="Versions <0.27.0 do not include InputJSONDelta.", ) -def test_add_ai_data_to_span_with_input_json_delta(sentry_init): +def test_set_output_data_with_input_json_delta(sentry_init): sentry_init( integrations=[AnthropicIntegration(include_prompts=True)], traces_sample_rate=1.0, @@ -798,19 +823,20 @@ def test_add_ai_data_to_span_with_input_json_delta(sentry_init): with start_transaction(name="test"): span = start_span() integration = AnthropicIntegration() - - _add_ai_data_to_span( + json_deltas = ["{'test': 'data',", "'more': 'json'}"] + _set_output_data( span, integration, + model="", input_tokens=10, output_tokens=20, - content_blocks=["{'test': 'data',", "'more': 'json'}"], + content_blocks=[{"text": "".join(json_deltas), "type": "text"}], ) - assert span._data.get("ai.responses") == [ - {"type": "text", "text": "{'test': 'data','more': 'json'}"} - ] - assert span._data.get("ai.streaming") is True - assert span._data.get("gen_ai.usage.input_tokens") == 10 - assert span._data.get("gen_ai.usage.output_tokens") == 20 - assert span._data.get("gen_ai.usage.total_tokens") == 30 + assert ( + span._data.get(SPANDATA.GEN_AI_RESPONSE_TEXT) + == "[{\"text\": \"{'test': 'data','more': 'json'}\", \"type\": \"text\"}]" + ) + assert span._data.get(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS) == 10 + assert span._data.get(SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS) == 20 + assert span._data.get(SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS) == 30 From dd323d6f8112af7063f48d4880b97b0c91ebdaa2 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 11 Aug 2025 14:26:27 +0200 Subject: [PATCH 14/18] Help for debugging Cron problems (#4686) A debug message to see what check-ins are send including the `monitor_slug` and the check-in `status`. --------- Co-authored-by: Daniel Szoke <7881302+szokeasaurusrex@users.noreply.github.com> --- sentry_sdk/crons/api.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/sentry_sdk/crons/api.py b/sentry_sdk/crons/api.py index 20e95685a7..b67e5961c8 100644 --- a/sentry_sdk/crons/api.py +++ b/sentry_sdk/crons/api.py @@ -1,6 +1,7 @@ import uuid import sentry_sdk +from sentry_sdk.utils import logger from typing import TYPE_CHECKING @@ -54,4 +55,8 @@ def capture_checkin( sentry_sdk.capture_event(check_in_event) + logger.debug( + f"[Crons] Captured check-in ({check_in_event.get('check_in_id')}): {check_in_event.get('monitor_slug')} -> {check_in_event.get('status')}" + ) + return check_in_event["check_in_id"] From c9230c53c4feb6f08fd44a2ba05984ec292822aa Mon Sep 17 00:00:00 2001 From: Neel Shah Date: Fri, 15 Mar 2024 14:38:47 +0100 Subject: [PATCH 15/18] Make UUID generation lazy --- sentry_sdk/tracing.py | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) diff --git a/sentry_sdk/tracing.py b/sentry_sdk/tracing.py index de575dfed2..92f7ae2073 100644 --- a/sentry_sdk/tracing.py +++ b/sentry_sdk/tracing.py @@ -257,8 +257,8 @@ class Span: """ __slots__ = ( - "trace_id", - "span_id", + "_trace_id", + "_span_id", "parent_span_id", "same_process_as_parent", "sampled", @@ -301,8 +301,8 @@ def __init__( name=None, # type: Optional[str] ): # type: (...) -> None - self.trace_id = trace_id or uuid.uuid4().hex - self.span_id = span_id or uuid.uuid4().hex[16:] + self._trace_id = trace_id + self._span_id = span_id self.parent_span_id = parent_span_id self.same_process_as_parent = same_process_as_parent self.sampled = sampled @@ -356,6 +356,32 @@ def init_span_recorder(self, maxlen): if self._span_recorder is None: self._span_recorder = _SpanRecorder(maxlen) + @property + def trace_id(self): + # type: () -> str + if not self._trace_id: + self._trace_id = uuid.uuid4().hex + + return self._trace_id + + @trace_id.setter + def trace_id(self, value): + # type: (str) -> None + self._trace_id = value + + @property + def span_id(self): + # type: () -> str + if not self._span_id: + self._span_id = uuid.uuid4().hex[16:] + + return self._span_id + + @span_id.setter + def span_id(self, value): + # type: (str) -> None + self._span_id = value + def _get_local_aggregator(self): # type: (...) -> LocalAggregator rv = self._local_aggregator From e2977284ce20787d2ea1888a30c861153dd9403a Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Tue, 12 Aug 2025 13:36:46 +0200 Subject: [PATCH 16/18] fix mypy --- sentry_sdk/scope.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sentry_sdk/scope.py b/sentry_sdk/scope.py index a0f5ffecd7..3356de57a8 100644 --- a/sentry_sdk/scope.py +++ b/sentry_sdk/scope.py @@ -48,7 +48,7 @@ from typing import TYPE_CHECKING if TYPE_CHECKING: - from collections.abc import Mapping, MutableMapping + from collections.abc import Mapping from typing import Any from typing import Callable @@ -683,12 +683,12 @@ def clear(self): self._level = None # type: Optional[LogLevelStr] self._fingerprint = None # type: Optional[List[str]] self._transaction = None # type: Optional[str] - self._transaction_info = {} # type: MutableMapping[str, str] + self._transaction_info = {} # type: dict[str, str] self._user = None # type: Optional[Dict[str, Any]] self._tags = {} # type: Dict[str, Any] self._contexts = {} # type: Dict[str, Dict[str, Any]] - self._extras = {} # type: MutableMapping[str, Any] + self._extras = {} # type: dict[str, Any] self._attachments = [] # type: List[Attachment] self.clear_breadcrumbs() From f344c2d2776172ffc1503bb1e66636c4b98698af Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Tue, 12 Aug 2025 16:34:16 +0200 Subject: [PATCH 17/18] do not cache looks_like_asgi3 --- sentry_sdk/integrations/asgi.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py index 14b2c93d51..dde8128a33 100644 --- a/sentry_sdk/integrations/asgi.py +++ b/sentry_sdk/integrations/asgi.py @@ -7,7 +7,7 @@ import asyncio import inspect from copy import deepcopy -from functools import lru_cache, partial +from functools import partial import sentry_sdk from sentry_sdk.api import continue_trace @@ -66,7 +66,6 @@ def _capture_exception(exc, mechanism_type="asgi"): sentry_sdk.capture_event(event, hint=hint) -@lru_cache(maxsize=5) def _looks_like_asgi3(app): # type: (Any) -> bool """ From f1a67a2d58dadcfe17e33499bfaf1bc9da73b4d0 Mon Sep 17 00:00:00 2001 From: Ivana Kellyer Date: Tue, 12 Aug 2025 16:43:16 +0200 Subject: [PATCH 18/18] remove gevent cache too --- sentry_sdk/utils.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py index 00eb8d86a9..b0f3fa4a4c 100644 --- a/sentry_sdk/utils.py +++ b/sentry_sdk/utils.py @@ -13,7 +13,7 @@ from collections import namedtuple from datetime import datetime, timezone from decimal import Decimal -from functools import lru_cache, partial, partialmethod, wraps +from functools import partial, partialmethod, wraps from numbers import Real from urllib.parse import parse_qs, unquote, urlencode, urlsplit, urlunsplit @@ -1858,7 +1858,6 @@ def is_module_patched(mod_name): return False -@lru_cache(maxsize=1) def is_gevent(): # type: () -> bool return is_module_patched("threading") or is_module_patched("_thread")