diff --git a/CHANGELOG.md b/CHANGELOG.md index a2ac6e09f8..a1d046b4a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,40 @@ # Changelog +## 2.34.0 + +### Various fixes & improvements + +- Considerably raise `DEFAULT_MAX_VALUE_LENGTH` (#4632) by @sentrivana + + We have increased the string trimming limit considerably, allowing you to see more data + without it being truncated. Note that this might, in rare cases, result in issue regrouping, + for example if you're capturing message events with very long messages (longer than the + default 1024 characters/bytes). + + If you want to adjust the limit, you can set a + [`max_value_limit`](https://docs.sentry.io/platforms/python/configuration/options/#max_value_length) + in your `sentry_sdk.init()`. + +- `OpenAI` integration update (#4612) by @antonpirker + + The `OpenAIIntegration` now supports [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses). + + The data captured will also show up in the new [AI Agents Dashboard](https://docs.sentry.io/product/insights/agents/dashboard/). + + This works out of the box, nothing to do on your side. + +- Expose `set_transaction_name` (#4634) by @sl0thentr0py +- Fix(Celery): Latency should be in milliseconds, not seconds (#4637) by @sentrivana +- Fix(Django): Treat `django.template.context.BasicContext` as sequence in serializer (#4621) by @sl0thentr0py +- Fix(Huggingface): Fix `huggingface_hub` CI tests. (#4619) by @antonpirker +- Fix: Ignore deliberate thread exception warnings (#4611) by @sl0thentr0py +- Fix: Socket tests to not use example.com (#4627) by @sl0thentr0py +- Fix: Threading run patch (#4610) by @sl0thentr0py +- Tests: Simplify celery double patching test (#4626) by @sl0thentr0py +- Tests: Remove remote example.com calls (#4622) by @sl0thentr0py +- Tests: tox.ini update (#4635) by @sentrivana +- Tests: Update tox (#4609) by @sentrivana + ## 2.33.2 ### Various fixes & improvements diff --git a/docs/conf.py b/docs/conf.py index faf861c518..c8debb897e 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -31,7 +31,7 @@ copyright = "2019-{}, Sentry Team and Contributors".format(datetime.now().year) author = "Sentry Team and Contributors" -release = "2.33.2" +release = "2.34.0" version = ".".join(release.split(".")[:2]) # The short X.Y version. diff --git a/scripts/populate_tox/config.py b/scripts/populate_tox/config.py index 411d7fe666..f395289b4a 100644 --- a/scripts/populate_tox/config.py +++ b/scripts/populate_tox/config.py @@ -144,6 +144,7 @@ "deps": { "*": ["pytest-asyncio"], }, + "python": ">=3.10", }, "openfeature": { "package": "openfeature-sdk", diff --git a/sentry_sdk/__init__.py b/sentry_sdk/__init__.py index e03f3b4484..7b1eda172a 100644 --- a/sentry_sdk/__init__.py +++ b/sentry_sdk/__init__.py @@ -49,6 +49,7 @@ "logger", "start_session", "end_session", + "set_transaction_name", ] # Initialize the debug support after everything is loaded diff --git a/sentry_sdk/ai/monitoring.py b/sentry_sdk/ai/monitoring.py index 7a687736d0..e3f372c3ba 100644 --- a/sentry_sdk/ai/monitoring.py +++ b/sentry_sdk/ai/monitoring.py @@ -40,7 +40,7 @@ def sync_wrapped(*args, **kwargs): for k, v in kwargs.pop("sentry_data", {}).items(): span.set_data(k, v) if curr_pipeline: - span.set_data(SPANDATA.AI_PIPELINE_NAME, curr_pipeline) + span.set_data(SPANDATA.GEN_AI_PIPELINE_NAME, curr_pipeline) return f(*args, **kwargs) else: _ai_pipeline_name.set(description) @@ -69,7 +69,7 @@ async def async_wrapped(*args, **kwargs): for k, v in kwargs.pop("sentry_data", {}).items(): span.set_data(k, v) if curr_pipeline: - span.set_data(SPANDATA.AI_PIPELINE_NAME, curr_pipeline) + span.set_data(SPANDATA.GEN_AI_PIPELINE_NAME, curr_pipeline) return await f(*args, **kwargs) else: _ai_pipeline_name.set(description) @@ -108,7 +108,7 @@ def record_token_usage( # TODO: move pipeline name elsewhere ai_pipeline_name = get_ai_pipeline_name() if ai_pipeline_name: - span.set_data(SPANDATA.AI_PIPELINE_NAME, ai_pipeline_name) + span.set_data(SPANDATA.GEN_AI_PIPELINE_NAME, ai_pipeline_name) if input_tokens is not None: span.set_data(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, input_tokens) diff --git a/sentry_sdk/api.py b/sentry_sdk/api.py index 698a2085ab..a4fb95e9a1 100644 --- a/sentry_sdk/api.py +++ b/sentry_sdk/api.py @@ -84,6 +84,7 @@ def overload(x): "monitor", "start_session", "end_session", + "set_transaction_name", ] @@ -466,3 +467,9 @@ def start_session( def end_session(): # type: () -> None return get_isolation_scope().end_session() + + +@scopemethod +def set_transaction_name(name, source=None): + # type: (str, Optional[str]) -> None + return get_current_scope().set_transaction_name(name, source) diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py index a7e713dc0b..dd9055b869 100644 --- a/sentry_sdk/consts.py +++ b/sentry_sdk/consts.py @@ -3,7 +3,10 @@ from typing import TYPE_CHECKING # up top to prevent circular import due to integration import -DEFAULT_MAX_VALUE_LENGTH = 1024 +# This is more or less an arbitrary large-ish value for now, so that we allow +# pretty long strings (like LLM prompts), but still have *some* upper limit +# until we verify that removing the trimming completely is safe. +DEFAULT_MAX_VALUE_LENGTH = 100_000 DEFAULT_MAX_STACK_FRAMES = 100 DEFAULT_ADD_FULL_STACK = False @@ -169,6 +172,7 @@ class SPANDATA: AI_PIPELINE_NAME = "ai.pipeline.name" """ Name of the AI pipeline or chain being executed. + DEPRECATED: Use GEN_AI_PIPELINE_NAME instead. Example: "qa-pipeline" """ @@ -229,6 +233,7 @@ class SPANDATA: AI_STREAMING = "ai.streaming" """ Whether or not the AI model call's response was streamed back asynchronously + DEPRECATED: Use GEN_AI_RESPONSE_STREAMING instead. Example: true """ @@ -372,6 +377,24 @@ class SPANDATA: Example: "chat" """ + GEN_AI_PIPELINE_NAME = "gen_ai.pipeline.name" + """ + Name of the AI pipeline or chain being executed. + Example: "qa-pipeline" + """ + + GEN_AI_RESPONSE_MODEL = "gen_ai.response.model" + """ + Exact model identifier used to generate the response + Example: gpt-4o-mini-2024-07-18 + """ + + GEN_AI_RESPONSE_STREAMING = "gen_ai.response.streaming" + """ + Whether or not the AI model call's response was streamed back asynchronously + Example: true + """ + GEN_AI_RESPONSE_TEXT = "gen_ai.response.text" """ The model's response text messages. @@ -411,7 +434,7 @@ class SPANDATA: GEN_AI_REQUEST_MODEL = "gen_ai.request.model" """ The model identifier being used for the request. - Example: "gpt-4-turbo-preview" + Example: "gpt-4-turbo" """ GEN_AI_REQUEST_PRESENCE_PENALTY = "gen_ai.request.presence_penalty" @@ -649,9 +672,11 @@ class OP: FUNCTION_AWS = "function.aws" FUNCTION_GCP = "function.gcp" GEN_AI_CHAT = "gen_ai.chat" + GEN_AI_EMBEDDINGS = "gen_ai.embeddings" GEN_AI_EXECUTE_TOOL = "gen_ai.execute_tool" GEN_AI_HANDOFF = "gen_ai.handoff" GEN_AI_INVOKE_AGENT = "gen_ai.invoke_agent" + GEN_AI_RESPONSES = "gen_ai.responses" GRAPHQL_EXECUTE = "graphql.execute" GRAPHQL_MUTATION = "graphql.mutation" GRAPHQL_PARSE = "graphql.parse" @@ -674,8 +699,6 @@ class OP: MIDDLEWARE_STARLITE = "middleware.starlite" MIDDLEWARE_STARLITE_RECEIVE = "middleware.starlite.receive" MIDDLEWARE_STARLITE_SEND = "middleware.starlite.send" - OPENAI_CHAT_COMPLETIONS_CREATE = "ai.chat_completions.create.openai" - OPENAI_EMBEDDINGS_CREATE = "ai.embeddings.create.openai" HUGGINGFACE_HUB_CHAT_COMPLETIONS_CREATE = ( "ai.chat_completions.create.huggingface_hub" ) @@ -1181,4 +1204,4 @@ def _get_default_options(): del _get_default_options -VERSION = "2.33.2" +VERSION = "2.34.0" diff --git a/sentry_sdk/integrations/celery/__init__.py b/sentry_sdk/integrations/celery/__init__.py index d8d89217ca..b5601fc0f9 100644 --- a/sentry_sdk/integrations/celery/__init__.py +++ b/sentry_sdk/integrations/celery/__init__.py @@ -391,6 +391,7 @@ def _inner(*args, **kwargs): ) if latency is not None: + latency *= 1000 # milliseconds span.set_data(SPANDATA.MESSAGING_MESSAGE_RECEIVE_LATENCY, latency) with capture_internal_exceptions(): diff --git a/sentry_sdk/integrations/django/__init__.py b/sentry_sdk/integrations/django/__init__.py index ff67b3e39b..2041598fa0 100644 --- a/sentry_sdk/integrations/django/__init__.py +++ b/sentry_sdk/integrations/django/__init__.py @@ -7,7 +7,7 @@ import sentry_sdk from sentry_sdk.consts import OP, SPANDATA from sentry_sdk.scope import add_global_event_processor, should_send_default_pii -from sentry_sdk.serializer import add_global_repr_processor +from sentry_sdk.serializer import add_global_repr_processor, add_repr_sequence_type from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource from sentry_sdk.tracing_utils import add_query_source, record_sql_queries from sentry_sdk.utils import ( @@ -269,6 +269,7 @@ def _django_queryset_repr(value, hint): patch_views() patch_templates() patch_signals() + add_template_context_repr_sequence() if patch_caching is not None: patch_caching() @@ -745,3 +746,13 @@ def _set_db_data(span, cursor_or_db): server_socket_address = connection_params.get("unix_socket") if server_socket_address is not None: span.set_data(SPANDATA.SERVER_SOCKET_ADDRESS, server_socket_address) + + +def add_template_context_repr_sequence(): + # type: () -> None + try: + from django.template.context import BaseContext + + add_repr_sequence_type(BaseContext) + except Exception: + pass diff --git a/sentry_sdk/integrations/openai.py b/sentry_sdk/integrations/openai.py index d906a8e0b2..78fcdd49e2 100644 --- a/sentry_sdk/integrations/openai.py +++ b/sentry_sdk/integrations/openai.py @@ -10,6 +10,7 @@ from sentry_sdk.utils import ( capture_internal_exceptions, event_from_exception, + safe_serialize, ) from typing import TYPE_CHECKING @@ -27,6 +28,14 @@ except ImportError: raise DidNotEnable("OpenAI not installed") +RESPONSES_API_ENABLED = True +try: + # responses API support was introduced in v1.66.0 + from openai.resources.responses import Responses, AsyncResponses + from openai.types.responses.response_completed_event import ResponseCompletedEvent +except ImportError: + RESPONSES_API_ENABLED = False + class OpenAIIntegration(Integration): identifier = "openai" @@ -46,13 +55,17 @@ def __init__(self, include_prompts=True, tiktoken_encoding_name=None): def setup_once(): # type: () -> None Completions.create = _wrap_chat_completion_create(Completions.create) - Embeddings.create = _wrap_embeddings_create(Embeddings.create) - AsyncCompletions.create = _wrap_async_chat_completion_create( AsyncCompletions.create ) + + Embeddings.create = _wrap_embeddings_create(Embeddings.create) AsyncEmbeddings.create = _wrap_async_embeddings_create(AsyncEmbeddings.create) + if RESPONSES_API_ENABLED: + Responses.create = _wrap_responses_create(Responses.create) + AsyncResponses.create = _wrap_async_responses_create(AsyncResponses.create) + def count_tokens(self, s): # type: (OpenAIIntegration, str) -> int if self.tiktoken_encoding is not None: @@ -62,6 +75,12 @@ def count_tokens(self, s): def _capture_exception(exc): # type: (Any) -> None + # Close an eventually open span + # We need to do this by hand because we are not using the start_span context manager + current_span = sentry_sdk.get_current_span() + if current_span is not None: + current_span.__exit__(None, None, None) + event, hint = event_from_exception( exc, client_options=sentry_sdk.get_client().options, @@ -81,7 +100,7 @@ def _get_usage(usage, names): def _calculate_token_usage( messages, response, span, streaming_message_responses, count_tokens ): - # type: (Iterable[ChatCompletionMessageParam], Any, Span, Optional[List[str]], Callable[..., Any]) -> None + # type: (Optional[Iterable[ChatCompletionMessageParam]], Any, Span, Optional[List[str]], Callable[..., Any]) -> None input_tokens = 0 # type: Optional[int] input_tokens_cached = 0 # type: Optional[int] output_tokens = 0 # type: Optional[int] @@ -106,13 +125,13 @@ def _calculate_token_usage( total_tokens = _get_usage(response.usage, ["total_tokens"]) # Manually count tokens - # TODO: when implementing responses API, check for responses API if input_tokens == 0: - for message in messages: - if "content" in message: + for message in messages or []: + if isinstance(message, dict) and "content" in message: input_tokens += count_tokens(message["content"]) + elif isinstance(message, str): + input_tokens += count_tokens(message) - # TODO: when implementing responses API, check for responses API if output_tokens == 0: if streaming_message_responses is not None: for message in streaming_message_responses: @@ -139,138 +158,254 @@ def _calculate_token_usage( ) -def _new_chat_completion_common(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any - integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) - if integration is None: - return f(*args, **kwargs) +def _set_input_data(span, kwargs, operation, integration): + # type: (Span, dict[str, Any], str, OpenAIIntegration) -> None + # Input messages (the prompt or data sent to the model) + messages = kwargs.get("messages") + if messages is None: + messages = kwargs.get("input") + + if isinstance(messages, str): + messages = [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, messages) + + # Input attributes: Common + set_data_normalized(span, SPANDATA.GEN_AI_SYSTEM, "openai") + set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, operation) + + # Input attributes: Optional + kwargs_keys_to_attributes = { + "model": SPANDATA.GEN_AI_REQUEST_MODEL, + "stream": SPANDATA.GEN_AI_RESPONSE_STREAMING, + "max_tokens": SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, + "presence_penalty": SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY, + "frequency_penalty": SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY, + "temperature": SPANDATA.GEN_AI_REQUEST_TEMPERATURE, + "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 None: + set_data_normalized(span, attribute, value) + + # Input attributes: Tools + tools = kwargs.get("tools") + if tools is not None and len(tools) > 0: + set_data_normalized( + span, SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS, safe_serialize(tools) + ) - if "messages" not in kwargs: - # invalid call (in all versions of openai), let it return error - return f(*args, **kwargs) - try: - iter(kwargs["messages"]) - except TypeError: - # invalid call (in all versions), messages must be iterable - return f(*args, **kwargs) +def _set_output_data(span, response, kwargs, integration, finish_span=True): + # type: (Span, Any, dict[str, Any], OpenAIIntegration, bool) -> None + if hasattr(response, "model"): + set_data_normalized(span, SPANDATA.GEN_AI_RESPONSE_MODEL, response.model) - kwargs["messages"] = list(kwargs["messages"]) - messages = kwargs["messages"] - model = kwargs.get("model") - streaming = kwargs.get("stream") - - span = sentry_sdk.start_span( - op=consts.OP.OPENAI_CHAT_COMPLETIONS_CREATE, - name="Chat Completion", - origin=OpenAIIntegration.origin, - ) - span.__enter__() + # Input messages (the prompt or data sent to the model) + # used for the token usage calculation + messages = kwargs.get("messages") + if messages is None: + messages = kwargs.get("input") - res = yield f, args, kwargs + if messages is not None and isinstance(messages, str): + messages = [messages] - with capture_internal_exceptions(): + if hasattr(response, "choices"): if should_send_default_pii() and integration.include_prompts: - set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, messages) - - set_data_normalized(span, SPANDATA.AI_MODEL_ID, model) - set_data_normalized(span, SPANDATA.AI_STREAMING, streaming) + response_text = [choice.message.dict() for choice in response.choices] + if len(response_text) > 0: + set_data_normalized( + span, + SPANDATA.GEN_AI_RESPONSE_TEXT, + safe_serialize(response_text), + ) + _calculate_token_usage(messages, response, span, None, integration.count_tokens) + if finish_span: + span.__exit__(None, None, None) - if hasattr(res, "choices"): - if should_send_default_pii() and integration.include_prompts: + elif hasattr(response, "output"): + if should_send_default_pii() and integration.include_prompts: + response_text = [item.to_dict() for item in response.output] + if len(response_text) > 0: set_data_normalized( span, - SPANDATA.AI_RESPONSES, - list(map(lambda x: x.message, res.choices)), + SPANDATA.GEN_AI_RESPONSE_TEXT, + safe_serialize(response_text), ) - _calculate_token_usage(messages, res, span, None, integration.count_tokens) + _calculate_token_usage(messages, response, span, None, integration.count_tokens) + if finish_span: span.__exit__(None, None, None) - elif hasattr(res, "_iterator"): - data_buf: list[list[str]] = [] # one for each choice - - old_iterator = res._iterator - - def new_iterator(): - # type: () -> Iterator[ChatCompletionChunk] - with capture_internal_exceptions(): - for x in old_iterator: - if hasattr(x, "choices"): - choice_index = 0 - for choice in x.choices: - if hasattr(choice, "delta") and hasattr( - choice.delta, "content" - ): - content = choice.delta.content - if len(data_buf) <= choice_index: - data_buf.append([]) - data_buf[choice_index].append(content or "") - choice_index += 1 - yield x - if len(data_buf) > 0: - all_responses = list( - map(lambda chunk: "".join(chunk), data_buf) + + elif hasattr(response, "_iterator"): + data_buf: list[list[str]] = [] # one for each choice + + old_iterator = response._iterator + + def new_iterator(): + # type: () -> Iterator[ChatCompletionChunk] + with capture_internal_exceptions(): + count_tokens_manually = True + for x in old_iterator: + # OpenAI chat completion API + if hasattr(x, "choices"): + choice_index = 0 + for choice in x.choices: + if hasattr(choice, "delta") and hasattr( + choice.delta, "content" + ): + content = choice.delta.content + if len(data_buf) <= choice_index: + data_buf.append([]) + data_buf[choice_index].append(content or "") + choice_index += 1 + + # OpenAI responses API + elif hasattr(x, "delta"): + if len(data_buf) == 0: + data_buf.append([]) + data_buf[0].append(x.delta or "") + + # OpenAI responses API end of streaming response + if RESPONSES_API_ENABLED and isinstance(x, ResponseCompletedEvent): + _calculate_token_usage( + messages, + x.response, + span, + None, + integration.count_tokens, ) - if should_send_default_pii() and integration.include_prompts: - set_data_normalized( - span, SPANDATA.AI_RESPONSES, all_responses - ) + count_tokens_manually = False + + yield x + + if len(data_buf) > 0: + all_responses = ["".join(chunk) for chunk in data_buf] + if should_send_default_pii() and integration.include_prompts: + set_data_normalized( + span, SPANDATA.GEN_AI_RESPONSE_TEXT, all_responses + ) + if count_tokens_manually: _calculate_token_usage( messages, - res, + response, span, all_responses, integration.count_tokens, ) + + if finish_span: span.__exit__(None, None, None) - async def new_iterator_async(): - # type: () -> AsyncIterator[ChatCompletionChunk] - with capture_internal_exceptions(): - async for x in old_iterator: - if hasattr(x, "choices"): - choice_index = 0 - for choice in x.choices: - if hasattr(choice, "delta") and hasattr( - choice.delta, "content" - ): - content = choice.delta.content - if len(data_buf) <= choice_index: - data_buf.append([]) - data_buf[choice_index].append(content or "") - choice_index += 1 - yield x - if len(data_buf) > 0: - all_responses = list( - map(lambda chunk: "".join(chunk), data_buf) + async def new_iterator_async(): + # type: () -> AsyncIterator[ChatCompletionChunk] + with capture_internal_exceptions(): + count_tokens_manually = True + async for x in old_iterator: + # OpenAI chat completion API + if hasattr(x, "choices"): + choice_index = 0 + for choice in x.choices: + if hasattr(choice, "delta") and hasattr( + choice.delta, "content" + ): + content = choice.delta.content + if len(data_buf) <= choice_index: + data_buf.append([]) + data_buf[choice_index].append(content or "") + choice_index += 1 + + # OpenAI responses API + elif hasattr(x, "delta"): + if len(data_buf) == 0: + data_buf.append([]) + data_buf[0].append(x.delta or "") + + # OpenAI responses API end of streaming response + if RESPONSES_API_ENABLED and isinstance(x, ResponseCompletedEvent): + _calculate_token_usage( + messages, + x.response, + span, + None, + integration.count_tokens, + ) + count_tokens_manually = False + + yield x + + if len(data_buf) > 0: + all_responses = ["".join(chunk) for chunk in data_buf] + if should_send_default_pii() and integration.include_prompts: + set_data_normalized( + span, SPANDATA.GEN_AI_RESPONSE_TEXT, all_responses ) - if should_send_default_pii() and integration.include_prompts: - set_data_normalized( - span, SPANDATA.AI_RESPONSES, all_responses - ) + if count_tokens_manually: _calculate_token_usage( messages, - res, + response, span, all_responses, integration.count_tokens, ) + if finish_span: span.__exit__(None, None, None) - if str(type(res._iterator)) == "": - res._iterator = new_iterator_async() - else: - res._iterator = new_iterator() - + if str(type(response._iterator)) == "": + response._iterator = new_iterator_async() else: - set_data_normalized(span, "unknown_response", True) + response._iterator = new_iterator() + else: + _calculate_token_usage(messages, response, span, None, integration.count_tokens) + if finish_span: span.__exit__(None, None, None) - return res + + +def _new_chat_completion_common(f, *args, **kwargs): + # type: (Any, Any, Any) -> Any + integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) + if integration is None: + return f(*args, **kwargs) + + if "messages" not in kwargs: + # invalid call (in all versions of openai), let it return error + return f(*args, **kwargs) + + try: + iter(kwargs["messages"]) + except TypeError: + # invalid call (in all versions), messages must be iterable + return f(*args, **kwargs) + + model = kwargs.get("model") + operation = "chat" + + span = sentry_sdk.start_span( + op=consts.OP.GEN_AI_CHAT, + name=f"{operation} {model}", + origin=OpenAIIntegration.origin, + ) + span.__enter__() + + _set_input_data(span, kwargs, operation, integration) + + response = yield f, args, kwargs + + _set_output_data(span, response, kwargs, integration, finish_span=True) + + return response def _wrap_chat_completion_create(f): # type: (Callable[..., Any]) -> Callable[..., Any] def _execute_sync(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any + # type: (Any, Any, Any) -> Any gen = _new_chat_completion_common(f, *args, **kwargs) try: @@ -291,7 +426,7 @@ def _execute_sync(f, *args, **kwargs): @wraps(f) def _sentry_patched_create_sync(*args, **kwargs): - # type: (*Any, **Any) -> Any + # type: (Any, Any) -> Any integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) if integration is None or "messages" not in kwargs: # no "messages" means invalid call (in all versions of openai), let it return error @@ -305,7 +440,7 @@ def _sentry_patched_create_sync(*args, **kwargs): def _wrap_async_chat_completion_create(f): # type: (Callable[..., Any]) -> Callable[..., Any] async def _execute_async(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any + # type: (Any, Any, Any) -> Any gen = _new_chat_completion_common(f, *args, **kwargs) try: @@ -326,7 +461,7 @@ async def _execute_async(f, *args, **kwargs): @wraps(f) async def _sentry_patched_create_async(*args, **kwargs): - # type: (*Any, **Any) -> Any + # type: (Any, Any) -> Any integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) if integration is None or "messages" not in kwargs: # no "messages" means invalid call (in all versions of openai), let it return error @@ -338,52 +473,24 @@ async def _sentry_patched_create_async(*args, **kwargs): def _new_embeddings_create_common(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any + # type: (Any, Any, Any) -> Any integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) if integration is None: return f(*args, **kwargs) + model = kwargs.get("model") + operation = "embeddings" + with sentry_sdk.start_span( - op=consts.OP.OPENAI_EMBEDDINGS_CREATE, - description="OpenAI Embedding Creation", + op=consts.OP.GEN_AI_EMBEDDINGS, + name=f"{operation} {model}", origin=OpenAIIntegration.origin, ) as span: - if "input" in kwargs and ( - should_send_default_pii() and integration.include_prompts - ): - if isinstance(kwargs["input"], str): - set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, [kwargs["input"]]) - elif ( - isinstance(kwargs["input"], list) - and len(kwargs["input"]) > 0 - and isinstance(kwargs["input"][0], str) - ): - set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, kwargs["input"]) - if "model" in kwargs: - set_data_normalized(span, SPANDATA.AI_MODEL_ID, kwargs["model"]) + _set_input_data(span, kwargs, operation, integration) response = yield f, args, kwargs - input_tokens = 0 - total_tokens = 0 - if hasattr(response, "usage"): - if hasattr(response.usage, "prompt_tokens") and isinstance( - response.usage.prompt_tokens, int - ): - input_tokens = response.usage.prompt_tokens - if hasattr(response.usage, "total_tokens") and isinstance( - response.usage.total_tokens, int - ): - total_tokens = response.usage.total_tokens - - if input_tokens == 0: - input_tokens = integration.count_tokens(kwargs["input"] or "") - - record_token_usage( - span, - input_tokens=input_tokens, - total_tokens=total_tokens or input_tokens, - ) + _set_output_data(span, response, kwargs, integration, finish_span=False) return response @@ -391,7 +498,7 @@ def _new_embeddings_create_common(f, *args, **kwargs): def _wrap_embeddings_create(f): # type: (Any) -> Any def _execute_sync(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any + # type: (Any, Any, Any) -> Any gen = _new_embeddings_create_common(f, *args, **kwargs) try: @@ -412,7 +519,7 @@ def _execute_sync(f, *args, **kwargs): @wraps(f) def _sentry_patched_create_sync(*args, **kwargs): - # type: (*Any, **Any) -> Any + # type: (Any, Any) -> Any integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) if integration is None: return f(*args, **kwargs) @@ -425,7 +532,7 @@ def _sentry_patched_create_sync(*args, **kwargs): def _wrap_async_embeddings_create(f): # type: (Any) -> Any async def _execute_async(f, *args, **kwargs): - # type: (Any, *Any, **Any) -> Any + # type: (Any, Any, Any) -> Any gen = _new_embeddings_create_common(f, *args, **kwargs) try: @@ -446,7 +553,7 @@ async def _execute_async(f, *args, **kwargs): @wraps(f) async def _sentry_patched_create_async(*args, **kwargs): - # type: (*Any, **Any) -> Any + # type: (Any, Any) -> Any integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) if integration is None: return await f(*args, **kwargs) @@ -454,3 +561,96 @@ async def _sentry_patched_create_async(*args, **kwargs): return await _execute_async(f, *args, **kwargs) return _sentry_patched_create_async + + +def _new_responses_create_common(f, *args, **kwargs): + # type: (Any, Any, Any) -> Any + integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) + if integration is None: + return f(*args, **kwargs) + + model = kwargs.get("model") + operation = "responses" + + span = sentry_sdk.start_span( + op=consts.OP.GEN_AI_RESPONSES, + name=f"{operation} {model}", + origin=OpenAIIntegration.origin, + ) + span.__enter__() + + _set_input_data(span, kwargs, operation, integration) + + response = yield f, args, kwargs + + _set_output_data(span, response, kwargs, integration, finish_span=True) + + return response + + +def _wrap_responses_create(f): + # type: (Any) -> Any + def _execute_sync(f, *args, **kwargs): + # type: (Any, Any, Any) -> Any + gen = _new_responses_create_common(f, *args, **kwargs) + + try: + f, args, kwargs = next(gen) + except StopIteration as e: + return e.value + + try: + try: + result = f(*args, **kwargs) + except Exception as e: + _capture_exception(e) + raise e from None + + return gen.send(result) + except StopIteration as e: + return e.value + + @wraps(f) + def _sentry_patched_create_sync(*args, **kwargs): + # type: (Any, Any) -> Any + integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) + if integration is None: + return f(*args, **kwargs) + + return _execute_sync(f, *args, **kwargs) + + return _sentry_patched_create_sync + + +def _wrap_async_responses_create(f): + # type: (Any) -> Any + async def _execute_async(f, *args, **kwargs): + # type: (Any, Any, Any) -> Any + gen = _new_responses_create_common(f, *args, **kwargs) + + try: + f, args, kwargs = next(gen) + except StopIteration as e: + return await e.value + + try: + try: + result = await f(*args, **kwargs) + except Exception as e: + _capture_exception(e) + raise e from None + + return gen.send(result) + except StopIteration as e: + return e.value + + @wraps(f) + async def _sentry_patched_responses_async(*args, **kwargs): + # type: (Any, Any) -> Any + integration = sentry_sdk.get_client().get_integration(OpenAIIntegration) + if integration is None: + return await f(*args, **kwargs) + + return await _execute_async(f, *args, **kwargs) + + return _sentry_patched_responses_async diff --git a/sentry_sdk/integrations/openai_agents/utils.py b/sentry_sdk/integrations/openai_agents/utils.py index dc66521c83..1525346726 100644 --- a/sentry_sdk/integrations/openai_agents/utils.py +++ b/sentry_sdk/integrations/openai_agents/utils.py @@ -1,16 +1,14 @@ -import json import sentry_sdk from sentry_sdk.consts import SPANDATA from sentry_sdk.integrations import DidNotEnable from sentry_sdk.scope import should_send_default_pii -from sentry_sdk.utils import event_from_exception +from sentry_sdk.utils import event_from_exception, safe_serialize from typing import TYPE_CHECKING if TYPE_CHECKING: from typing import Any from typing import Callable - from typing import Union from agents import Usage try: @@ -162,49 +160,3 @@ def _set_output_data(span, result): span.set_data( SPANDATA.GEN_AI_RESPONSE_TEXT, safe_serialize(output_messages["response"]) ) - - -def safe_serialize(data): - # type: (Any) -> str - """Safely serialize to a readable string.""" - - def serialize_item(item): - # type: (Any) -> Union[str, dict[Any, Any], list[Any], tuple[Any, ...]] - if callable(item): - try: - module = getattr(item, "__module__", None) - qualname = getattr(item, "__qualname__", None) - name = getattr(item, "__name__", "anonymous") - - if module and qualname: - full_path = f"{module}.{qualname}" - elif module and name: - full_path = f"{module}.{name}" - else: - full_path = name - - return f"" - except Exception: - return f"" - elif isinstance(item, dict): - return {k: serialize_item(v) for k, v in item.items()} - elif isinstance(item, (list, tuple)): - return [serialize_item(x) for x in item] - elif hasattr(item, "__dict__"): - try: - attrs = { - k: serialize_item(v) - for k, v in vars(item).items() - if not k.startswith("_") - } - return f"<{type(item).__name__} {attrs}>" - except Exception: - return repr(item) - else: - return item - - try: - serialized = serialize_item(data) - return json.dumps(serialized, default=str) - except Exception: - return str(data) diff --git a/sentry_sdk/integrations/threading.py b/sentry_sdk/integrations/threading.py index 9c99a8e896..fc4f539228 100644 --- a/sentry_sdk/integrations/threading.py +++ b/sentry_sdk/integrations/threading.py @@ -120,7 +120,7 @@ def _run_old_run_func(): # type: () -> Any try: self = current_thread() - return old_run_func(self, *a, **kw) + return old_run_func(self, *a[1:], **kw) except Exception: reraise(*_capture_exception()) diff --git a/sentry_sdk/serializer.py b/sentry_sdk/serializer.py index bc8e38c631..04df9857bd 100644 --- a/sentry_sdk/serializer.py +++ b/sentry_sdk/serializer.py @@ -63,6 +63,14 @@ def add_global_repr_processor(processor): global_repr_processors.append(processor) +sequence_types = [Sequence, Set] # type: List[type] + + +def add_repr_sequence_type(ty): + # type: (type) -> None + sequence_types.append(ty) + + class Memo: __slots__ = ("_ids", "_objs") @@ -332,7 +340,7 @@ def _serialize_node_impl( return rv_dict elif not isinstance(obj, serializable_str_types) and isinstance( - obj, (Set, Sequence) + obj, tuple(sequence_types) ): rv_list = [] diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py index 3b0ab8d746..9c6f2cfc3b 100644 --- a/sentry_sdk/utils.py +++ b/sentry_sdk/utils.py @@ -1938,3 +1938,49 @@ def try_convert(convert_func, value): return convert_func(value) except Exception: return None + + +def safe_serialize(data): + # type: (Any) -> str + """Safely serialize to a readable string.""" + + def serialize_item(item): + # type: (Any) -> Union[str, dict[Any, Any], list[Any], tuple[Any, ...]] + if callable(item): + try: + module = getattr(item, "__module__", None) + qualname = getattr(item, "__qualname__", None) + name = getattr(item, "__name__", "anonymous") + + if module and qualname: + full_path = f"{module}.{qualname}" + elif module and name: + full_path = f"{module}.{name}" + else: + full_path = name + + return f"" + except Exception: + return f"" + elif isinstance(item, dict): + return {k: serialize_item(v) for k, v in item.items()} + elif isinstance(item, (list, tuple)): + return [serialize_item(x) for x in item] + elif hasattr(item, "__dict__"): + try: + attrs = { + k: serialize_item(v) + for k, v in vars(item).items() + if not k.startswith("_") + } + return f"<{type(item).__name__} {attrs}>" + except Exception: + return repr(item) + else: + return item + + try: + serialized = serialize_item(data) + return json.dumps(serialized, default=str) + except Exception: + return str(data) diff --git a/setup.py b/setup.py index 9e75720390..5f1640ac97 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ def get_file_text(file_name): setup( name="sentry-sdk", - version="2.33.2", + version="2.34.0", author="Sentry Team and Contributors", author_email="hello@sentry.io", url="https://github.com/getsentry/sentry-python", diff --git a/tests/integrations/aiohttp/test_aiohttp.py b/tests/integrations/aiohttp/test_aiohttp.py index 47152f254c..dbb4286370 100644 --- a/tests/integrations/aiohttp/test_aiohttp.py +++ b/tests/integrations/aiohttp/test_aiohttp.py @@ -6,7 +6,7 @@ import pytest -from aiohttp import web, ClientSession +from aiohttp import web from aiohttp.client import ServerDisconnectedError from aiohttp.web_request import Request from aiohttp.web_exceptions import ( @@ -636,6 +636,7 @@ async def handler(request): @pytest.mark.asyncio async def test_span_origin( sentry_init, + aiohttp_raw_server, aiohttp_client, capture_events, ): @@ -644,10 +645,16 @@ async def test_span_origin( traces_sample_rate=1.0, ) + # server for making span request + async def handler(request): + return web.Response(text="OK") + + raw_server = await aiohttp_raw_server(handler) + async def hello(request): - async with ClientSession() as session: - async with session.get("http://example.com"): - return web.Response(text="hello") + span_client = await aiohttp_client(raw_server) + await span_client.get("/") + return web.Response(text="hello") app = web.Application() app.router.add_get(r"/", hello) diff --git a/tests/integrations/bottle/test_bottle.py b/tests/integrations/bottle/test_bottle.py index 363a9167e6..1965691d6c 100644 --- a/tests/integrations/bottle/test_bottle.py +++ b/tests/integrations/bottle/test_bottle.py @@ -5,6 +5,7 @@ from io import BytesIO from bottle import Bottle, debug as set_debug, abort, redirect, HTTPResponse from sentry_sdk import capture_message +from sentry_sdk.consts import DEFAULT_MAX_VALUE_LENGTH from sentry_sdk.integrations.bottle import BottleIntegration from sentry_sdk.serializer import MAX_DATABAG_BREADTH @@ -121,9 +122,9 @@ def index(): def test_large_json_request(sentry_init, capture_events, app, get_client): - sentry_init(integrations=[BottleIntegration()]) + sentry_init(integrations=[BottleIntegration()], max_request_body_size="always") - data = {"foo": {"bar": "a" * 2000}} + data = {"foo": {"bar": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)}} @app.route("/", method="POST") def index(): @@ -144,9 +145,14 @@ def index(): (event,) = events assert event["_meta"]["request"]["data"]["foo"]["bar"] == { - "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]} + "": { + "len": DEFAULT_MAX_VALUE_LENGTH + 10, + "rem": [ + ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] + ], + } } - assert len(event["request"]["data"]["foo"]["bar"]) == 1024 + assert len(event["request"]["data"]["foo"]["bar"]) == DEFAULT_MAX_VALUE_LENGTH @pytest.mark.parametrize("data", [{}, []], ids=["empty-dict", "empty-list"]) @@ -174,9 +180,9 @@ def index(): def test_medium_formdata_request(sentry_init, capture_events, app, get_client): - sentry_init(integrations=[BottleIntegration()]) + sentry_init(integrations=[BottleIntegration()], max_request_body_size="always") - data = {"foo": "a" * 2000} + data = {"foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10)} @app.route("/", method="POST") def index(): @@ -194,9 +200,14 @@ def index(): (event,) = events assert event["_meta"]["request"]["data"]["foo"] == { - "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]} + "": { + "len": DEFAULT_MAX_VALUE_LENGTH + 10, + "rem": [ + ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] + ], + } } - assert len(event["request"]["data"]["foo"]) == 1024 + assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH @pytest.mark.parametrize("input_char", ["a", b"a"]) @@ -233,7 +244,10 @@ def index(): def test_files_and_form(sentry_init, capture_events, app, get_client): sentry_init(integrations=[BottleIntegration()], max_request_body_size="always") - data = {"foo": "a" * 2000, "file": (BytesIO(b"hello"), "hello.txt")} + data = { + "foo": "a" * (DEFAULT_MAX_VALUE_LENGTH + 10), + "file": (BytesIO(b"hello"), "hello.txt"), + } @app.route("/", method="POST") def index(): @@ -253,9 +267,14 @@ def index(): (event,) = events assert event["_meta"]["request"]["data"]["foo"] == { - "": {"len": 2000, "rem": [["!limit", "x", 1021, 1024]]} + "": { + "len": DEFAULT_MAX_VALUE_LENGTH + 10, + "rem": [ + ["!limit", "x", DEFAULT_MAX_VALUE_LENGTH - 3, DEFAULT_MAX_VALUE_LENGTH] + ], + } } - assert len(event["request"]["data"]["foo"]) == 1024 + assert len(event["request"]["data"]["foo"]) == DEFAULT_MAX_VALUE_LENGTH assert event["_meta"]["request"]["data"]["file"] == { "": { diff --git a/tests/integrations/celery/test_celery.py b/tests/integrations/celery/test_celery.py index 8c794bd5ff..ce2e693143 100644 --- a/tests/integrations/celery/test_celery.py +++ b/tests/integrations/celery/test_celery.py @@ -246,25 +246,34 @@ def dummy_task(x, y): ] -def test_no_stackoverflows(celery): - """We used to have a bug in the Celery integration where its monkeypatching +def test_no_double_patching(celery): + """Ensure that Celery tasks are only patched once to prevent stack overflows. + + We used to have a bug in the Celery integration where its monkeypatching was repeated for every task invocation, leading to stackoverflows. See https://github.com/getsentry/sentry-python/issues/265 """ - results = [] - @celery.task(name="dummy_task") def dummy_task(): - sentry_sdk.get_isolation_scope().set_tag("foo", "bar") - results.append(42) + return 42 - for _ in range(10000): - dummy_task.delay() + # Initially, the task should not be marked as patched + assert not hasattr(dummy_task, "_sentry_is_patched") + + # First invocation should trigger patching + result1 = dummy_task.delay() + assert result1.get() == 42 + assert getattr(dummy_task, "_sentry_is_patched", False) is True + + patched_run = dummy_task.run - assert results == [42] * 10000 - assert not sentry_sdk.get_isolation_scope()._tags + # Second invocation should not re-patch + result2 = dummy_task.delay() + assert result2.get() == 42 + assert dummy_task.run is patched_run + assert getattr(dummy_task, "_sentry_is_patched", False) is True def test_simple_no_propagation(capture_events, init_celery): diff --git a/tests/integrations/django/test_basic.py b/tests/integrations/django/test_basic.py index 0e3f700105..e96cd09e4f 100644 --- a/tests/integrations/django/test_basic.py +++ b/tests/integrations/django/test_basic.py @@ -10,11 +10,13 @@ from werkzeug.test import Client from django import VERSION as DJANGO_VERSION + from django.contrib.auth.models import User from django.core.management import execute_from_command_line from django.db.utils import OperationalError, ProgrammingError, DataError from django.http.request import RawPostDataException from django.utils.functional import SimpleLazyObject +from django.template.context import make_context try: from django.urls import reverse @@ -310,6 +312,27 @@ def test_queryset_repr(sentry_init, capture_events): ) +@pytest.mark.forked +@pytest_mark_django_db_decorator() +def test_context_nested_queryset_repr(sentry_init, capture_events): + sentry_init(integrations=[DjangoIntegration()]) + events = capture_events() + User.objects.create_user("john", "lennon@thebeatles.com", "johnpassword") + + try: + context = make_context({"entries": User.objects.all()}) # noqa + 1 / 0 + except Exception: + capture_exception() + + (event,) = events + + (exception,) = event["exception"]["values"] + assert exception["type"] == "ZeroDivisionError" + (frame,) = exception["stacktrace"]["frames"] + assert "