sentry-sdk 2.33.1__py2.py3-none-any.whl → 2.34.0__py2.py3-none-any.whl

sentry_sdk/__init__.py

@@ -49,6 +49,7 @@ __all__ = [  # noqa
     "logger",
     "start_session",
     "end_session",
+    "set_transaction_name",
 ]
 
 # Initialize the debug support after everything is loaded

sentry_sdk/ai/monitoring.py

@@ -40,7 +40,7 @@ def ai_track(description, **span_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 @@ def ai_track(description, **span_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)

sentry_sdk/api.py

@@ -84,6 +84,7 @@ __all__ = [
     "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)

sentry_sdk/client.py

@@ -47,7 +47,6 @@ from sentry_sdk.profiler.transaction_profiler import (
 )
 from sentry_sdk.scrubber import EventScrubber
 from sentry_sdk.monitor import Monitor
-from sentry_sdk.spotlight import setup_spotlight
 
 if TYPE_CHECKING:
     from typing import Any
@@ -429,6 +428,10 @@ class _Client(BaseClient):
                 )
 
             if self.options.get("spotlight"):
+                # This is intentionally here to prevent setting up spotlight
+                # stuff we don't need unless spotlight is explicitly enabled
+                from sentry_sdk.spotlight import setup_spotlight
+
                 self.spotlight = setup_spotlight(self.options)
                 if not self.options["dsn"]:
                     sample_all = lambda *_args, **_kwargs: 1.0

sentry_sdk/consts.py

@@ -3,7 +3,10 @@ from enum import Enum
 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 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.33.1"
+VERSION = "2.34.0"

sentry_sdk/integrations/celery/__init__.py

@@ -391,6 +391,7 @@ def _wrap_task_call(task, f):
                         )
 
                 if latency is not None:
+                    latency *= 1000  # milliseconds
                     span.set_data(SPANDATA.MESSAGING_MESSAGE_RECEIVE_LATENCY, latency)
 
                 with capture_internal_exceptions():

sentry_sdk/integrations/django/__init__.py

@@ -7,7 +7,7 @@ from importlib import import_module
 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 @@ class DjangoIntegration(Integration):
         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

sentry_sdk/integrations/gnu_backtrace.py

@@ -12,23 +12,12 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event
 
 
-MODULE_RE = r"[a-zA-Z0-9/._:\\-]+"
-TYPE_RE = r"[a-zA-Z0-9._:<>,-]+"
-HEXVAL_RE = r"[A-Fa-f0-9]+"
-
+FUNCTION_RE = r"[^@]+?)\s+@\s+0x[0-9a-fA-F]+"
 
 FRAME_RE = r"""
-^(?P<index>\d+)\.\s
-(?P<package>{MODULE_RE})\(
-  (?P<retval>{TYPE_RE}\ )?
-  ((?P<function>{TYPE_RE})
-    (?P<args>\(.*\))?
-  )?
-  ((?P<constoffset>\ const)?\+0x(?P<offset>{HEXVAL_RE}))?
-\)\s
-\[0x(?P<retaddr>{HEXVAL_RE})\]$
+^(?P<index>\d+)\.\s+(?P<function>{FUNCTION_RE}\s+in\s+(?P<package>.+)$
 """.format(
-    MODULE_RE=MODULE_RE, HEXVAL_RE=HEXVAL_RE, TYPE_RE=TYPE_RE
+    FUNCTION_RE=FUNCTION_RE,
 )
 
 FRAME_RE = re.compile(FRAME_RE, re.MULTILINE | re.VERBOSE)

sentry_sdk/integrations/openai.py

@@ -10,6 +10,7 @@ from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
+    safe_serialize,
 )
 
 from typing import TYPE_CHECKING
@@ -27,6 +28,14 @@ try:
 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 @@ class OpenAIIntegration(Integration):
     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 @@ class OpenAIIntegration(Integration):
 
 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)) == "<class 'async_generator'>":
-                res._iterator = new_iterator_async()
-            else:
-                res._iterator = new_iterator()
-
+        if str(type(response._iterator)) == "<class 'async_generator'>":
+            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 _wrap_chat_completion_create(f):
 
     @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 _wrap_chat_completion_create(f):
 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 @@ def _wrap_async_chat_completion_create(f):
 
     @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 @@ def _wrap_async_chat_completion_create(f):
 
 
 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 _wrap_embeddings_create(f):
 
     @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 _wrap_embeddings_create(f):
 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 @@ def _wrap_async_embeddings_create(f):
 
     @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 @@ def _wrap_async_embeddings_create(f):
         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

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"<function {full_path}>"
-            except Exception:
-                return f"<callable {type(item).__name__}>"
-        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)

sentry_sdk/integrations/threading.py

@@ -120,7 +120,7 @@ def _wrap_run(isolation_scope_to_use, current_scope_to_use, 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())
 

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(event, **kwargs):
             return rv_dict
 
         elif not isinstance(obj, serializable_str_types) and isinstance(
-            obj, (Set, Sequence)
+            obj, tuple(sequence_types)
         ):
             rv_list = []
 

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"<function {full_path}>"
+            except Exception:
+                return f"<callable {type(item).__name__}>"
+        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)

{sentry_sdk-2.33.1.dist-info → sentry_sdk-2.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.33.1
+Version: 2.34.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.33.1.dist-info → sentry_sdk-2.34.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sentry_sdk/__init__.py,sha256=c3IYjMHt7ZJlOKg4DQK2xMOVQm4A9jVfBIGuzjoCq-k,1255
+sentry_sdk/__init__.py,sha256=a9ZsEg5C8RSuLekRk1dbS_9-4ej5E2ebvktY5YPnT-k,1283
 sentry_sdk/_compat.py,sha256=Pxcg6cUYPiOoXIFfLI_H3ATb7SfrcXOeZdzpeWv3umI,3116
 sentry_sdk/_init_implementation.py,sha256=WL54d8nggjRunBm3XlG-sWSx4yS5lpYYggd7YBWpuVk,2559
 sentry_sdk/_log_batcher.py,sha256=bBpspIlf1ejxlbudo17bZOSir226LGAdjDe_3kHkOro,5085
@@ -6,10 +6,10 @@ sentry_sdk/_lru_cache.py,sha256=phZMBm9EKU1m67OOApnKCffnlWAlVz9bYjig7CglQuk,1229
 sentry_sdk/_queue.py,sha256=UUzbmliDYmdVYiDA32NMYkX369ElWMFNSj5kodqVQZE,11250
 sentry_sdk/_types.py,sha256=TMdmMSxc0dYErvRA5ikEnNxH_Iwb2Wiw3ZUMNlp0HCA,10482
 sentry_sdk/_werkzeug.py,sha256=m3GPf-jHd8v3eVOfBHaKw5f0uHoLkXrSO1EcY-8EisY,3734
-sentry_sdk/api.py,sha256=mdw2-KPGLrYwN7QPRbk2TL4gDfOV56fIO8fAdafMcFo,12192
+sentry_sdk/api.py,sha256=K4cNSmsJXI1HFyeCdHMans-IgQuDxviyhO4H2rrMkWY,12387
 sentry_sdk/attachments.py,sha256=0Dylhm065O6hNFjB40fWCd5Hg4qWSXndmi1TPWglZkI,3109
-sentry_sdk/client.py,sha256=7G9qH7YsBhl2ga9BZgmW0ESuXl4Z8pQZz2M8GC3aIV4,38668
-sentry_sdk/consts.py,sha256=lCgJ_91AWBwfPSc_JmMVFBk9zjV-Sf-sv3c-jBX07EI,45069
+sentry_sdk/client.py,sha256=gHznIT7uGb6-h5gZFtN2qmjUEZNOuqIJQXwB1V-lSPU,38839
+sentry_sdk/consts.py,sha256=ikw6F3xZxjhylV9Dy8r2uj78guKAhK2KekpxZj6YZCo,45825
 sentry_sdk/debug.py,sha256=ddBehQlAuQC1sg1XO-N4N3diZ0x0iT5RWJwFdrtcsjw,1019
 sentry_sdk/envelope.py,sha256=Mgcib0uLm_5tSVzOrznRLdK9B3CjQ6TEgM1ZIZIfjWo,10355
 sentry_sdk/feature_flags.py,sha256=99JRig6TBkrkBzVCKqYcmVgjsuA_Hk-ul7jFHGhJplc,2233
@@ -20,7 +20,7 @@ sentry_sdk/monitor.py,sha256=52CG1m2e8okFDVoTpbqfm9zeeaLa0ciC_r9x2RiXuDg,3639
 sentry_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sentry_sdk/scope.py,sha256=fl6Hm7BD-1HlzghOHkWY_zQY3FkakrNrqdjebfJ0LbY,63942
 sentry_sdk/scrubber.py,sha256=rENmQ35buugDl269bRZuIAtgr27B9SzisJYUF-691pc,6064
-sentry_sdk/serializer.py,sha256=iXiRwTuRj0gcKyHRO0GNTZB1Hmk0LMDiBt6Be7RpGt8,13087
+sentry_sdk/serializer.py,sha256=xUw3xjSsGF0cWRHL9ofe0nmWEtZvzPOHSQ6IHvo6UAc,13239
 sentry_sdk/session.py,sha256=TqDVmRKKHUDSmZb4jQR-s8wDt7Fwb6QaG21hawUGWEs,5571
 sentry_sdk/sessions.py,sha256=UZ2jfrqhYvZzTxCDGc1MLD6P_aHLJnTFetSUROIaPaA,9154
 sentry_sdk/spotlight.py,sha256=93kdd8KxdLfcPaxFnFuqHgYAAL4FCfpK1hiiPoD7Ac4,8678
@@ -28,10 +28,10 @@ sentry_sdk/tracing.py,sha256=dEyLZn0JSj5WMjVJEQUxRud5NewBRau9dkuDrrzJ_Xw,48114
 sentry_sdk/tracing_utils.py,sha256=J_eY_0XuyydslEmcFZcrv8dt2ItpW7uWwe6CoXxoK5Q,28820
 sentry_sdk/transport.py,sha256=A0uux7XnniDJuExLudLyyFDYnS5C6r7zozGbkveUM7E,32469
 sentry_sdk/types.py,sha256=NLbnRzww2K3_oGz2GzcC8TdX5L2DXYso1-H1uCv2Hwc,1222
-sentry_sdk/utils.py,sha256=q0jJzpUVs71Ejkq-1ZAr-9EyKjYnakTkv4BmuQCaxV4,59461
+sentry_sdk/utils.py,sha256=Uv_85CVVn_grmr1GjqGkogAbZPW1mr-iEcYcvlYp6EE,61036
 sentry_sdk/worker.py,sha256=VSMaigRMbInVyupSFpBC42bft2oIViea-0C_d9ThnIo,4464
 sentry_sdk/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sentry_sdk/ai/monitoring.py,sha256=o9rRRTIODEy-0wbINQQwSKVpUnE2V3FHfsdIlwKEwpw,4936
+sentry_sdk/ai/monitoring.py,sha256=OqQHsi832ZTL6mf38hO_qehaqMqVAb2E6HOyyaXSOtY,4948
 sentry_sdk/ai/utils.py,sha256=QCwhHoptrdXyYroJqzCKxqi0cmrlD9IDDWUcBk6yWZc,950
 sentry_sdk/crons/__init__.py,sha256=3Zt6g1-pZZ12uRKKsC8QLm3XgJ4K1VYxgVpNNUygOZY,221
 sentry_sdk/crons/api.py,sha256=s3x6SG-jqIdWS-Kj0sAxJv0nz2A3stdGE1UCtQyRUy4,1559
@@ -65,7 +65,7 @@ sentry_sdk/integrations/falcon.py,sha256=uhjqFPKa8bWRQr0za4pVXGYaPr-LRdICw2rUO-l
 sentry_sdk/integrations/fastapi.py,sha256=KJsG73Xrm5AmAb2yiiINyfvlU9tIaVbPWA4urj6uEOU,4718
 sentry_sdk/integrations/flask.py,sha256=t7q73JoJT46RWDtrNImtIloGyDg7CnsNFKpS4gOuBIw,8740
 sentry_sdk/integrations/gcp.py,sha256=u1rSi3nK2ISUQqkRnmKFG23Ks-SefshTf5PV0Dwp3_4,8274
-sentry_sdk/integrations/gnu_backtrace.py,sha256=cVY7t6gjVjeRf4PdnmZrATFqMOZ7-qJu-84xIXOD5R4,2894
+sentry_sdk/integrations/gnu_backtrace.py,sha256=EdMQB6ZFBZhZHtkmEyKdQdJzNmzFRIP1hjg1ve2_qOQ,2658
 sentry_sdk/integrations/gql.py,sha256=ppC7fjpyQ6jWST-batRt5HtebxE_9IeHbmZ-CJ1TfUU,4179
 sentry_sdk/integrations/graphene.py,sha256=I6ZJ8Apd9dO9XPVvZY7I46-v1eXOW1C1rAkWwasF3gU,5042
 sentry_sdk/integrations/httpx.py,sha256=WwUulqzBLoGGqWUUdQg_MThwQUKzBXnA-m3g_1GOpCE,5866
@@ -77,7 +77,7 @@ sentry_sdk/integrations/litestar.py,sha256=ui52AfgyyAO4aQ9XSkqJZNcPduX0BccCYUkQA
 sentry_sdk/integrations/logging.py,sha256=-0o9HTFo5RpHkCpxfZvpiBj5VWpH4aIJmH-HNQzj3Ec,13643
 sentry_sdk/integrations/loguru.py,sha256=mEWYWsNHQLlWknU4M8RBgOf2-5B5cBr5aGd-ZH1Emq4,6193
 sentry_sdk/integrations/modules.py,sha256=vzLx3Erg77Vl4mnUvAgTg_3teAuWy7zylFpAidBI9I0,820
-sentry_sdk/integrations/openai.py,sha256=TiVo7zlBbbTHH6KVmxZsS_6Yeqq1mFBML18uzEZ3nEA,16434
+sentry_sdk/integrations/openai.py,sha256=1IyriExZ4BVCteq9Ml8Q0swRR4BkAboqfumoSFm74TA,22788
 sentry_sdk/integrations/openfeature.py,sha256=NXRKnhg0knMKOx_TO_2Z4zSsh4Glgk3tStu-lI99XsE,1235
 sentry_sdk/integrations/pure_eval.py,sha256=OvT76XvllQ_J6ABu3jVNU6KD2QAxnXMtTZ7hqhXNhpY,4581
 sentry_sdk/integrations/pymongo.py,sha256=cPpMGEbXHlV6HTHgmIDL1F-x3w7ZMROXVb4eUhLs3bw,6380
@@ -96,16 +96,16 @@ sentry_sdk/integrations/statsig.py,sha256=-e57hxHfHo1S13YQKObV65q_UvREyxbR56fnf7
 sentry_sdk/integrations/stdlib.py,sha256=vgB9weDGh455vBwmUSgcQRgzViKstu3O0syOthCn_H0,8831
 sentry_sdk/integrations/strawberry.py,sha256=u7Lk4u3sNEycdSmY1nQBzYKmqI-mO8BWKAAJkCSuTRA,14126
 sentry_sdk/integrations/sys_exit.py,sha256=AwShgGBWPdiY25aOWDLRAs2RBUKm5T3CrL-Q-zAk0l4,2493
-sentry_sdk/integrations/threading.py,sha256=Ez3LmZJXfZf8LjDnaQ7ces6S-nYCz1HEJveZT71-bcU,5392
+sentry_sdk/integrations/threading.py,sha256=tV7pQB8LwR8dIju-I81rgjps4sRxSofj_2YFBL2JXWM,5396
 sentry_sdk/integrations/tornado.py,sha256=Qcft8FZxdVICnaa1AhsDB262sInEQZPf-pvgI-Agjmc,7206
 sentry_sdk/integrations/trytond.py,sha256=BaLCNqQeRWDbHHDEelS5tmj-p_CrbmtGEHIn6JfzEFE,1651
 sentry_sdk/integrations/typer.py,sha256=FQrFgpR9t6yQWF-oWCI9KJLFioEnA2c_1BEtYV-mPAs,1815
 sentry_sdk/integrations/unleash.py,sha256=6JshqyuAY_kbu9Nr20tMOhtgx-ryqPHCrq_EQIzeqm4,1058
 sentry_sdk/integrations/wsgi.py,sha256=aW_EnDCcex41NGdrxKFZsfJxJhndsMCv0d2a5LBb7wU,10747
-sentry_sdk/integrations/celery/__init__.py,sha256=p30Im1vtw-Lm6QIce4DplS0Z9LB_hbdPmi7asRee048,18647
+sentry_sdk/integrations/celery/__init__.py,sha256=FNmrLL0Cs95kv6yUCpJGu9X8Cpw20mMYGmnkBC4IL4Y,18699
 sentry_sdk/integrations/celery/beat.py,sha256=WHEdKetrDJgtZGNp1VUMa6BG1q-MhsLZMefUmVrPu3w,8953
 sentry_sdk/integrations/celery/utils.py,sha256=CMWQOpg9yniEkm3WlXe7YakJfVnLwaY0-jyeo2GX-ZI,1208
-sentry_sdk/integrations/django/__init__.py,sha256=0AfKHTPxLv8SXgLBFA312ceCR-h3xS5BqJNnU_bDESc,24966
+sentry_sdk/integrations/django/__init__.py,sha256=KqAgBKkuyJGw0lqNZBj0otqZGy_YHqPsisgPZLCN8mQ,25247
 sentry_sdk/integrations/django/asgi.py,sha256=RdDiCjlWAJ2pKm84-0li3jpp2Zl_GmLNprYdkLDTXgY,8333
 sentry_sdk/integrations/django/caching.py,sha256=UvYaiI7xrN08Se59vMgJWrSO2BuowOyx3jmXmZoxQJo,6427
 sentry_sdk/integrations/django/middleware.py,sha256=UVKq134w_TyOVPV7WwBW0QjHY-ziDipcZBIDQmjqceE,6009
@@ -122,7 +122,7 @@ sentry_sdk/integrations/grpc/aio/client.py,sha256=csOwlJb7fg9fBnzeNHxr-qpZEmU97I
 sentry_sdk/integrations/grpc/aio/server.py,sha256=SCkdikPZRdWyrlnZewsSGpPk4v6AsdSApVAbO-lf_Lk,4019
 sentry_sdk/integrations/openai_agents/__init__.py,sha256=-ydqG0sFIrvJlT9JHO58EZpCAzyy9J59Av8dxn0fHuw,1424
 sentry_sdk/integrations/openai_agents/consts.py,sha256=PTb3vlqkuMPktu21ALK72o5WMIX4-cewTEiTRdHKFdQ,38
-sentry_sdk/integrations/openai_agents/utils.py,sha256=fZ00TW7eUBH3e0BSBp0QnXJioYQgGh32S-mptJz96-4,7099
+sentry_sdk/integrations/openai_agents/utils.py,sha256=ZtsID9kIF7pUYRqzJcGrtnhJZ838DxO2G7yhPdTHRUc,5499
 sentry_sdk/integrations/openai_agents/patches/__init__.py,sha256=I7C9JZ70Mf8PV3wPdFsxTqvcYl4TYUgSZYfNU2Spb7Y,231
 sentry_sdk/integrations/openai_agents/patches/agent_run.py,sha256=jDYY2jVTcoJLiH-0KOKMryv7IAoDKjWXsMwnxJU8KHM,5736
 sentry_sdk/integrations/openai_agents/patches/models.py,sha256=DtwqCmSsYFlhRZquKM2jiTOnnAg97eyCTtJYZkWqdww,1405
@@ -158,9 +158,9 @@ sentry_sdk/profiler/__init__.py,sha256=3PI3bHk9RSkkOXZKN84DDedk_7M65EiqqaIGo-DYs
 sentry_sdk/profiler/continuous_profiler.py,sha256=s0DHkj3RZYRg9HnQQC0G44ku6DaFqRy30fZTMtTYvIs,22828
 sentry_sdk/profiler/transaction_profiler.py,sha256=4Gj6FHLnK1di3GmnI1cCc_DbNcBVMdBjZZFvPvm7C7k,27877
 sentry_sdk/profiler/utils.py,sha256=G5s4tYai9ATJqcHrQ3bOIxlK6jIaHzELrDtU5k3N4HI,6556
-sentry_sdk-2.33.1.dist-info/licenses/LICENSE,sha256=KhQNZg9GKBL6KQvHQNBGMxJsXsRdhLebVp4Sew7t3Qs,1093
-sentry_sdk-2.33.1.dist-info/METADATA,sha256=klU6hCfX8PKwiXAmPNHdRDa6nAh66KrRkFAN882VV10,10278
-sentry_sdk-2.33.1.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-sentry_sdk-2.33.1.dist-info/entry_points.txt,sha256=qacZEz40UspQZD1IukCXykx0JtImqGDOctS5KfOLTko,91
-sentry_sdk-2.33.1.dist-info/top_level.txt,sha256=XrQz30XE9FKXSY_yGLrd9bsv2Rk390GTDJOSujYaMxI,11
-sentry_sdk-2.33.1.dist-info/RECORD,,
+sentry_sdk-2.34.0.dist-info/licenses/LICENSE,sha256=KhQNZg9GKBL6KQvHQNBGMxJsXsRdhLebVp4Sew7t3Qs,1093
+sentry_sdk-2.34.0.dist-info/METADATA,sha256=lx1pIBA63c_gfGyea7bRqZdtENj63J4xeHDUQbE8ie4,10278
+sentry_sdk-2.34.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+sentry_sdk-2.34.0.dist-info/entry_points.txt,sha256=qacZEz40UspQZD1IukCXykx0JtImqGDOctS5KfOLTko,91
+sentry_sdk-2.34.0.dist-info/top_level.txt,sha256=XrQz30XE9FKXSY_yGLrd9bsv2Rk390GTDJOSujYaMxI,11
+sentry_sdk-2.34.0.dist-info/RECORD,,