sentry-sdk 2.37.0__py2.py3-none-any.whl → 2.38.0__py2.py3-none-any.whl

sentry_sdk/__init__.py

@@ -1,10 +1,10 @@
+from sentry_sdk import profiler
 from sentry_sdk.scope import Scope
 from sentry_sdk.transport import Transport, HttpTransport
 from sentry_sdk.client import Client
 
 from sentry_sdk.api import *  # noqa
-
-from sentry_sdk.consts import VERSION  # noqa
+from sentry_sdk.consts import VERSION
 
 __all__ = [  # noqa
     "Hub",
@@ -12,6 +12,7 @@ __all__ = [  # noqa
     "Client",
     "Transport",
     "HttpTransport",
+    "VERSION",
     "integrations",
     # From sentry_sdk.api
     "init",
@@ -47,6 +48,7 @@ __all__ = [  # noqa
     "trace",
     "monitor",
     "logger",
+    "profiler",
     "start_session",
     "end_session",
     "set_transaction_name",

sentry_sdk/_types.py

@@ -269,7 +269,7 @@ if TYPE_CHECKING:
         "metric_bucket",
         "monitor",
         "span",
-        "log",
+        "log_item",
     ]
     SessionStatus = Literal["ok", "exited", "crashed", "abnormal"]
 

sentry_sdk/ai/utils.py

@@ -3,9 +3,10 @@ import json
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any
+    from typing import Any, Callable
     from sentry_sdk.tracing import Span
 
+import sentry_sdk
 from sentry_sdk.utils import logger
 
 
@@ -37,3 +38,12 @@ def set_data_normalized(span, key, value, unpack=True):
         span.set_data(key, normalized)
     else:
         span.set_data(key, json.dumps(normalized))
+
+
+def get_start_span_function():
+    # type: () -> Callable[..., Any]
+    current_span = sentry_sdk.get_current_span()
+    transaction_exists = (
+        current_span is not None and current_span.containing_transaction is not None
+    )
+    return sentry_sdk.start_span if transaction_exists else sentry_sdk.start_transaction

sentry_sdk/consts.py

@@ -795,6 +795,7 @@ class OP:
     GEN_AI_CREATE_AGENT = "gen_ai.create_agent"
     GEN_AI_EMBEDDINGS = "gen_ai.embeddings"
     GEN_AI_EXECUTE_TOOL = "gen_ai.execute_tool"
+    GEN_AI_GENERATE_TEXT = "gen_ai.generate_text"
     GEN_AI_HANDOFF = "gen_ai.handoff"
     GEN_AI_PIPELINE = "gen_ai.pipeline"
     GEN_AI_INVOKE_AGENT = "gen_ai.invoke_agent"
@@ -1330,4 +1331,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.37.0"
+VERSION = "2.38.0"

sentry_sdk/envelope.py

@@ -273,7 +273,7 @@ class Item:
         elif ty == "event":
             return "error"
         elif ty == "log":
-            return "log"
+            return "log_item"
         elif ty == "client_report":
             return "internal"
         elif ty == "profile":

sentry_sdk/integrations/__init__.py

@@ -141,7 +141,7 @@ _MIN_VERSIONS = {
     "gql": (3, 4, 1),
     "graphene": (3, 3),
     "grpc": (1, 32, 0),  # grpcio
-    "huggingface_hub": (0, 22),
+    "huggingface_hub": (0, 24, 7),
     "langchain": (0, 1, 0),
     "langgraph": (0, 6, 6),
     "launchdarkly": (9, 8, 0),

sentry_sdk/integrations/anthropic.py

@@ -1,10 +1,9 @@
 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.ai.utils import set_data_normalized, get_start_span_function
 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
@@ -117,8 +116,29 @@ def _set_input_data(span, kwargs, integration):
         and should_send_default_pii()
         and integration.include_prompts
     ):
+        normalized_messages = []
+        for message in messages:
+            if (
+                message.get("role") == "user"
+                and "content" in message
+                and isinstance(message["content"], (list, tuple))
+            ):
+                for item in message["content"]:
+                    if item.get("type") == "tool_result":
+                        normalized_messages.append(
+                            {
+                                "role": "tool",
+                                "content": {
+                                    "tool_use_id": item.get("tool_use_id"),
+                                    "output": item.get("content"),
+                                },
+                            }
+                        )
+            else:
+                normalized_messages.append(message)
+
         set_data_normalized(
-            span, SPANDATA.GEN_AI_REQUEST_MESSAGES, safe_serialize(messages)
+            span, SPANDATA.GEN_AI_REQUEST_MESSAGES, normalized_messages, unpack=False
         )
 
     set_data_normalized(
@@ -159,12 +179,29 @@ def _set_output_data(
     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,
-            SPANDATA.GEN_AI_RESPONSE_TEXT,
-            json.dumps(content_blocks),
-            unpack=False,
-        )
+        output_messages = {
+            "response": [],
+            "tool": [],
+        }  # type: (dict[str, list[Any]])
+
+        for output in content_blocks:
+            if output["type"] == "text":
+                output_messages["response"].append(output["text"])
+            elif output["type"] == "tool_use":
+                output_messages["tool"].append(output)
+
+        if len(output_messages["tool"]) > 0:
+            set_data_normalized(
+                span,
+                SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
+                output_messages["tool"],
+                unpack=False,
+            )
+
+        if len(output_messages["response"]) > 0:
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
+            )
 
     record_token_usage(
         span,
@@ -172,8 +209,6 @@ def _set_output_data(
         output_tokens=output_tokens,
     )
 
-    # TODO: GEN_AI_RESPONSE_TOOL_CALLS ?
-
     if finish_span:
         span.__exit__(None, None, None)
 
@@ -194,7 +229,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
 
     model = kwargs.get("model", "")
 
-    span = sentry_sdk.start_span(
+    span = get_start_span_function()(
         op=OP.GEN_AI_CHAT,
         name=f"chat {model}".strip(),
         origin=AnthropicIntegration.origin,

sentry_sdk/integrations/asyncio.py

@@ -51,6 +51,8 @@ def patch_asyncio():
                     ):
                         try:
                             result = await coro
+                        except StopAsyncIteration as e:
+                            raise e from None
                         except Exception:
                             reraise(*_capture_exception())
 

sentry_sdk/integrations/dedupe.py

@@ -1,5 +1,5 @@
 import sentry_sdk
-from sentry_sdk.utils import ContextVar
+from sentry_sdk.utils import ContextVar, logger
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import add_global_event_processor
 
@@ -37,7 +37,9 @@ class DedupeIntegration(Integration):
 
             exc = exc_info[1]
             if integration._last_seen.get(None) is exc:
+                logger.info("DedupeIntegration dropped duplicated error event %s", exc)
                 return None
+
             integration._last_seen.set(exc)
             return event
 

sentry_sdk/integrations/gql.py

@@ -18,6 +18,13 @@ try:
     )
     from gql.transport import Transport, AsyncTransport  # type: ignore[import-not-found]
     from gql.transport.exceptions import TransportQueryError  # type: ignore[import-not-found]
+
+    try:
+        # gql 4.0+
+        from gql import GraphQLRequest
+    except ImportError:
+        GraphQLRequest = None
+
 except ImportError:
     raise DidNotEnable("gql is not installed")
 
@@ -92,13 +99,13 @@ def _patch_execute():
     real_execute = gql.Client.execute
 
     @ensure_integration_enabled(GQLIntegration, real_execute)
-    def sentry_patched_execute(self, document, *args, **kwargs):
+    def sentry_patched_execute(self, document_or_request, *args, **kwargs):
         # type: (gql.Client, DocumentNode, Any, Any) -> Any
         scope = sentry_sdk.get_isolation_scope()
-        scope.add_event_processor(_make_gql_event_processor(self, document))
+        scope.add_event_processor(_make_gql_event_processor(self, document_or_request))
 
         try:
-            return real_execute(self, document, *args, **kwargs)
+            return real_execute(self, document_or_request, *args, **kwargs)
         except TransportQueryError as e:
             event, hint = event_from_exception(
                 e,
@@ -112,8 +119,8 @@ def _patch_execute():
     gql.Client.execute = sentry_patched_execute
 
 
-def _make_gql_event_processor(client, document):
-    # type: (gql.Client, DocumentNode) -> EventProcessor
+def _make_gql_event_processor(client, document_or_request):
+    # type: (gql.Client, Union[DocumentNode, gql.GraphQLRequest]) -> EventProcessor
     def processor(event, hint):
         # type: (Event, dict[str, Any]) -> Event
         try:
@@ -130,6 +137,16 @@ def _make_gql_event_processor(client, document):
         )
 
         if should_send_default_pii():
+            if GraphQLRequest is not None and isinstance(
+                document_or_request, GraphQLRequest
+            ):
+                # In v4.0.0, gql moved to using GraphQLRequest instead of
+                # DocumentNode in execute
+                # https://github.com/graphql-python/gql/pull/556
+                document = document_or_request.document
+            else:
+                document = document_or_request
+
             request["data"] = _data_from_document(document)
             contexts = event.setdefault("contexts", {})
             response = contexts.setdefault("response", {})

sentry_sdk/integrations/huggingface_hub.py

@@ -1,24 +1,24 @@
+import inspect
 from functools import wraps
 
-from sentry_sdk import consts
+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 SPANDATA
-
-from typing import Any, Iterable, Callable
-
-import sentry_sdk
-from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
 )
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, Iterable
+
 try:
     import huggingface_hub.inference._client
-
-    from huggingface_hub import ChatCompletionStreamOutput, TextGenerationOutput
 except ImportError:
     raise DidNotEnable("Huggingface not installed")
 
@@ -34,9 +34,18 @@ class HuggingfaceHubIntegration(Integration):
     @staticmethod
     def setup_once():
         # type: () -> None
+
+        # Other tasks that can be called: https://huggingface.co/docs/huggingface_hub/guides/inference#supported-providers-and-tasks
         huggingface_hub.inference._client.InferenceClient.text_generation = (
-            _wrap_text_generation(
-                huggingface_hub.inference._client.InferenceClient.text_generation
+            _wrap_huggingface_task(
+                huggingface_hub.inference._client.InferenceClient.text_generation,
+                OP.GEN_AI_GENERATE_TEXT,
+            )
+        )
+        huggingface_hub.inference._client.InferenceClient.chat_completion = (
+            _wrap_huggingface_task(
+                huggingface_hub.inference._client.InferenceClient.chat_completion,
+                OP.GEN_AI_CHAT,
             )
         )
 
@@ -51,131 +60,318 @@ def _capture_exception(exc):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _wrap_text_generation(f):
-    # type: (Callable[..., Any]) -> Callable[..., Any]
+def _wrap_huggingface_task(f, op):
+    # type: (Callable[..., Any], str) -> Callable[..., Any]
     @wraps(f)
-    def new_text_generation(*args, **kwargs):
+    def new_huggingface_task(*args, **kwargs):
         # type: (*Any, **Any) -> Any
         integration = sentry_sdk.get_client().get_integration(HuggingfaceHubIntegration)
         if integration is None:
             return f(*args, **kwargs)
 
+        prompt = None
         if "prompt" in kwargs:
             prompt = kwargs["prompt"]
+        elif "messages" in kwargs:
+            prompt = kwargs["messages"]
         elif len(args) >= 2:
-            kwargs["prompt"] = args[1]
-            prompt = kwargs["prompt"]
-            args = (args[0],) + args[2:]
-        else:
-            # invalid call, let it return error
+            if isinstance(args[1], str) or isinstance(args[1], list):
+                prompt = args[1]
+
+        if prompt is None:
+            # invalid call, dont instrument, let it return error
             return f(*args, **kwargs)
 
-        model = kwargs.get("model")
-        streaming = kwargs.get("stream")
+        client = args[0]
+        model = client.model or kwargs.get("model") or ""
+        operation_name = op.split(".")[-1]
 
         span = sentry_sdk.start_span(
-            op=consts.OP.HUGGINGFACE_HUB_CHAT_COMPLETIONS_CREATE,
-            name="Text Generation",
+            op=op,
+            name=f"{operation_name} {model}",
             origin=HuggingfaceHubIntegration.origin,
         )
         span.__enter__()
+
+        span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, operation_name)
+
+        if model:
+            span.set_data(SPANDATA.GEN_AI_REQUEST_MODEL, model)
+
+        # Input attributes
+        if should_send_default_pii() and integration.include_prompts:
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_REQUEST_MESSAGES, prompt, unpack=False
+            )
+
+        attribute_mapping = {
+            "tools": SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS,
+            "frequency_penalty": SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+            "max_tokens": SPANDATA.GEN_AI_REQUEST_MAX_TOKENS,
+            "presence_penalty": SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY,
+            "temperature": SPANDATA.GEN_AI_REQUEST_TEMPERATURE,
+            "top_p": SPANDATA.GEN_AI_REQUEST_TOP_P,
+            "top_k": SPANDATA.GEN_AI_REQUEST_TOP_K,
+            "stream": SPANDATA.GEN_AI_RESPONSE_STREAMING,
+        }
+
+        for attribute, span_attribute in attribute_mapping.items():
+            value = kwargs.get(attribute, None)
+            if value is not None:
+                if isinstance(value, (int, float, bool, str)):
+                    span.set_data(span_attribute, value)
+                else:
+                    set_data_normalized(span, span_attribute, value, unpack=False)
+
+        # LLM Execution
         try:
             res = f(*args, **kwargs)
         except Exception as e:
+            # Error Handling
+            span.set_status("error")
             _capture_exception(e)
             span.__exit__(None, None, None)
             raise e from None
 
+        # Output attributes
+        finish_reason = None
+        response_model = None
+        response_text_buffer: list[str] = []
+        tokens_used = 0
+        tool_calls = None
+        usage = None
+
         with capture_internal_exceptions():
-            if should_send_default_pii() and integration.include_prompts:
-                set_data_normalized(span, SPANDATA.AI_INPUT_MESSAGES, prompt)
+            if isinstance(res, str) and res is not None:
+                response_text_buffer.append(res)
 
-            set_data_normalized(span, SPANDATA.AI_MODEL_ID, model)
-            set_data_normalized(span, SPANDATA.AI_STREAMING, streaming)
+            if hasattr(res, "generated_text") and res.generated_text is not None:
+                response_text_buffer.append(res.generated_text)
 
-            if isinstance(res, str):
-                if should_send_default_pii() and integration.include_prompts:
-                    set_data_normalized(
-                        span,
-                        SPANDATA.AI_RESPONSES,
-                        [res],
-                    )
-                span.__exit__(None, None, None)
-                return res
+            if hasattr(res, "model") and res.model is not None:
+                response_model = res.model
+
+            if hasattr(res, "details") and hasattr(res.details, "finish_reason"):
+                finish_reason = res.details.finish_reason
+
+            if (
+                hasattr(res, "details")
+                and hasattr(res.details, "generated_tokens")
+                and res.details.generated_tokens is not None
+            ):
+                tokens_used = res.details.generated_tokens
+
+            if hasattr(res, "usage") and res.usage is not None:
+                usage = res.usage
+
+            if hasattr(res, "choices") and res.choices is not None:
+                for choice in res.choices:
+                    if hasattr(choice, "finish_reason"):
+                        finish_reason = choice.finish_reason
+                    if hasattr(choice, "message") and hasattr(
+                        choice.message, "tool_calls"
+                    ):
+                        tool_calls = choice.message.tool_calls
+                    if (
+                        hasattr(choice, "message")
+                        and hasattr(choice.message, "content")
+                        and choice.message.content is not None
+                    ):
+                        response_text_buffer.append(choice.message.content)
 
-            if isinstance(res, TextGenerationOutput):
-                if should_send_default_pii() and integration.include_prompts:
+            if response_model is not None:
+                span.set_data(SPANDATA.GEN_AI_RESPONSE_MODEL, response_model)
+
+            if finish_reason is not None:
+                set_data_normalized(
+                    span,
+                    SPANDATA.GEN_AI_RESPONSE_FINISH_REASONS,
+                    finish_reason,
+                )
+
+            if should_send_default_pii() and integration.include_prompts:
+                if tool_calls is not None and len(tool_calls) > 0:
                     set_data_normalized(
                         span,
-                        SPANDATA.AI_RESPONSES,
-                        [res.generated_text],
-                    )
-                if res.details is not None and res.details.generated_tokens > 0:
-                    record_token_usage(
-                        span,
-                        total_tokens=res.details.generated_tokens,
+                        SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
+                        tool_calls,
+                        unpack=False,
                     )
-                span.__exit__(None, None, None)
-                return res
 
-            if not isinstance(res, Iterable):
-                # we only know how to deal with strings and iterables, ignore
-                set_data_normalized(span, "unknown_response", True)
+                if len(response_text_buffer) > 0:
+                    text_response = "".join(response_text_buffer)
+                    if text_response:
+                        set_data_normalized(
+                            span,
+                            SPANDATA.GEN_AI_RESPONSE_TEXT,
+                            text_response,
+                        )
+
+            if usage is not None:
+                record_token_usage(
+                    span,
+                    input_tokens=usage.prompt_tokens,
+                    output_tokens=usage.completion_tokens,
+                    total_tokens=usage.total_tokens,
+                )
+            elif tokens_used > 0:
+                record_token_usage(
+                    span,
+                    total_tokens=tokens_used,
+                )
+
+            # If the response is not a generator (meaning a streaming response)
+            # we are done and can return the response
+            if not inspect.isgenerator(res):
                 span.__exit__(None, None, None)
                 return res
 
             if kwargs.get("details", False):
-                # res is Iterable[TextGenerationStreamOutput]
+                # text-generation stream output
                 def new_details_iterator():
-                    # type: () -> Iterable[ChatCompletionStreamOutput]
+                    # type: () -> Iterable[Any]
+                    finish_reason = None
+                    response_text_buffer: list[str] = []
+                    tokens_used = 0
+
                     with capture_internal_exceptions():
-                        tokens_used = 0
-                        data_buf: list[str] = []
-                        for x in res:
-                            if hasattr(x, "token") and hasattr(x.token, "text"):
-                                data_buf.append(x.token.text)
-                            if hasattr(x, "details") and hasattr(
-                                x.details, "generated_tokens"
+                        for chunk in res:
+                            if (
+                                hasattr(chunk, "token")
+                                and hasattr(chunk.token, "text")
+                                and chunk.token.text is not None
+                            ):
+                                response_text_buffer.append(chunk.token.text)
+
+                            if hasattr(chunk, "details") and hasattr(
+                                chunk.details, "finish_reason"
+                            ):
+                                finish_reason = chunk.details.finish_reason
+
+                            if (
+                                hasattr(chunk, "details")
+                                and hasattr(chunk.details, "generated_tokens")
+                                and chunk.details.generated_tokens is not None
                             ):
-                                tokens_used = x.details.generated_tokens
-                            yield x
-                        if (
-                            len(data_buf) > 0
-                            and should_send_default_pii()
-                            and integration.include_prompts
-                        ):
+                                tokens_used = chunk.details.generated_tokens
+
+                            yield chunk
+
+                        if finish_reason is not None:
                             set_data_normalized(
-                                span, SPANDATA.AI_RESPONSES, "".join(data_buf)
+                                span,
+                                SPANDATA.GEN_AI_RESPONSE_FINISH_REASONS,
+                                finish_reason,
                             )
+
+                        if should_send_default_pii() and integration.include_prompts:
+                            if len(response_text_buffer) > 0:
+                                text_response = "".join(response_text_buffer)
+                                if text_response:
+                                    set_data_normalized(
+                                        span,
+                                        SPANDATA.GEN_AI_RESPONSE_TEXT,
+                                        text_response,
+                                    )
+
                         if tokens_used > 0:
                             record_token_usage(
                                 span,
                                 total_tokens=tokens_used,
                             )
+
                     span.__exit__(None, None, None)
 
                 return new_details_iterator()
-            else:
-                # res is Iterable[str]
 
+            else:
+                # chat-completion stream output
                 def new_iterator():
                     # type: () -> Iterable[str]
-                    data_buf: list[str] = []
+                    finish_reason = None
+                    response_model = None
+                    response_text_buffer: list[str] = []
+                    tool_calls = None
+                    usage = None
+
                     with capture_internal_exceptions():
-                        for s in res:
-                            if isinstance(s, str):
-                                data_buf.append(s)
-                            yield s
-                        if (
-                            len(data_buf) > 0
-                            and should_send_default_pii()
-                            and integration.include_prompts
-                        ):
+                        for chunk in res:
+                            if hasattr(chunk, "model") and chunk.model is not None:
+                                response_model = chunk.model
+
+                            if hasattr(chunk, "usage") and chunk.usage is not None:
+                                usage = chunk.usage
+
+                            if isinstance(chunk, str):
+                                if chunk is not None:
+                                    response_text_buffer.append(chunk)
+
+                            if hasattr(chunk, "choices") and chunk.choices is not None:
+                                for choice in chunk.choices:
+                                    if (
+                                        hasattr(choice, "delta")
+                                        and hasattr(choice.delta, "content")
+                                        and choice.delta.content is not None
+                                    ):
+                                        response_text_buffer.append(
+                                            choice.delta.content
+                                        )
+
+                                    if (
+                                        hasattr(choice, "finish_reason")
+                                        and choice.finish_reason is not None
+                                    ):
+                                        finish_reason = choice.finish_reason
+
+                                    if (
+                                        hasattr(choice, "delta")
+                                        and hasattr(choice.delta, "tool_calls")
+                                        and choice.delta.tool_calls is not None
+                                    ):
+                                        tool_calls = choice.delta.tool_calls
+
+                            yield chunk
+
+                        if response_model is not None:
+                            span.set_data(
+                                SPANDATA.GEN_AI_RESPONSE_MODEL, response_model
+                            )
+
+                        if finish_reason is not None:
                             set_data_normalized(
-                                span, SPANDATA.AI_RESPONSES, "".join(data_buf)
+                                span,
+                                SPANDATA.GEN_AI_RESPONSE_FINISH_REASONS,
+                                finish_reason,
                             )
+
+                        if should_send_default_pii() and integration.include_prompts:
+                            if tool_calls is not None and len(tool_calls) > 0:
+                                set_data_normalized(
+                                    span,
+                                    SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
+                                    tool_calls,
+                                    unpack=False,
+                                )
+
+                            if len(response_text_buffer) > 0:
+                                text_response = "".join(response_text_buffer)
+                                if text_response:
+                                    set_data_normalized(
+                                        span,
+                                        SPANDATA.GEN_AI_RESPONSE_TEXT,
+                                        text_response,
+                                    )
+
+                        if usage is not None:
+                            record_token_usage(
+                                span,
+                                input_tokens=usage.prompt_tokens,
+                                output_tokens=usage.completion_tokens,
+                                total_tokens=usage.total_tokens,
+                            )
+
                         span.__exit__(None, None, None)
 
                 return new_iterator()
 
-    return new_text_generation
+    return new_huggingface_task

sentry_sdk/integrations/langchain.py

@@ -4,7 +4,7 @@ from functools import wraps
 
 import sentry_sdk
 from sentry_sdk.ai.monitoring import set_ai_pipeline_name
-from sentry_sdk.ai.utils import set_data_normalized
+from sentry_sdk.ai.utils import set_data_normalized, get_start_span_function
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
@@ -29,7 +29,6 @@ if TYPE_CHECKING:
 
 
 try:
-    from langchain.agents import AgentExecutor
     from langchain_core.agents import AgentFinish
     from langchain_core.callbacks import (
         BaseCallbackHandler,
@@ -44,6 +43,11 @@ except ImportError:
     raise DidNotEnable("langchain not installed")
 
 
+try:
+    from langchain.agents import AgentExecutor
+except ImportError:
+    AgentExecutor = None
+
 DATA_FIELDS = {
     "frequency_penalty": SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY,
     "function_call": SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
@@ -712,8 +716,9 @@ def _wrap_agent_executor_invoke(f):
             return f(self, *args, **kwargs)
 
         agent_name, tools = _get_request_data(self, args, kwargs)
+        start_span_function = get_start_span_function()
 
-        with sentry_sdk.start_span(
+        with start_span_function(
             op=OP.GEN_AI_INVOKE_AGENT,
             name=f"invoke_agent {agent_name}" if agent_name else "invoke_agent",
             origin=LangchainIntegration.origin,
@@ -763,8 +768,9 @@ def _wrap_agent_executor_stream(f):
             return f(self, *args, **kwargs)
 
         agent_name, tools = _get_request_data(self, args, kwargs)
+        start_span_function = get_start_span_function()
 
-        span = sentry_sdk.start_span(
+        span = start_span_function(
             op=OP.GEN_AI_INVOKE_AGENT,
             name=f"invoke_agent {agent_name}".strip(),
             origin=LangchainIntegration.origin,

sentry_sdk/integrations/openai_agents/patches/agent_run.py

@@ -26,12 +26,12 @@ def _patch_agent_run():
     original_execute_handoffs = agents._run_impl.RunImpl.execute_handoffs
     original_execute_final_output = agents._run_impl.RunImpl.execute_final_output
 
-    def _start_invoke_agent_span(context_wrapper, agent):
-        # type: (agents.RunContextWrapper, agents.Agent) -> None
+    def _start_invoke_agent_span(context_wrapper, agent, kwargs):
+        # type: (agents.RunContextWrapper, agents.Agent, dict[str, Any]) -> None
         """Start an agent invocation span"""
         # Store the agent on the context wrapper so we can access it later
         context_wrapper._sentry_current_agent = agent
-        invoke_agent_span(context_wrapper, agent)
+        invoke_agent_span(context_wrapper, agent, kwargs)
 
     def _end_invoke_agent_span(context_wrapper, agent, output=None):
         # type: (agents.RunContextWrapper, agents.Agent, Optional[Any]) -> None
@@ -72,7 +72,7 @@ def _patch_agent_run():
                 if current_agent and current_agent != agent:
                     _end_invoke_agent_span(context_wrapper, current_agent)
 
-            _start_invoke_agent_span(context_wrapper, agent)
+            _start_invoke_agent_span(context_wrapper, agent, kwargs)
 
         # Call original method with all the correct parameters
         result = await original_run_single_turn(*args, **kwargs)

sentry_sdk/integrations/openai_agents/spans/agent_workflow.py

@@ -1,7 +1,7 @@
 import sentry_sdk
+from sentry_sdk.ai.utils import get_start_span_function
 
 from ..consts import SPAN_ORIGIN
-from ..utils import _get_start_span_function
 
 from typing import TYPE_CHECKING
 
@@ -13,7 +13,7 @@ def agent_workflow_span(agent):
     # type: (agents.Agent) -> sentry_sdk.tracing.Span
 
     # Create a transaction or a span if an transaction is already active
-    span = _get_start_span_function()(
+    span = get_start_span_function()(
         name=f"{agent.name} workflow",
         origin=SPAN_ORIGIN,
     )

sentry_sdk/integrations/openai_agents/spans/invoke_agent.py

@@ -1,5 +1,8 @@
 import sentry_sdk
+from sentry_sdk.ai.utils import get_start_span_function, set_data_normalized
 from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.utils import safe_serialize
 
 from ..consts import SPAN_ORIGIN
 from ..utils import _set_agent_data
@@ -11,9 +14,10 @@ if TYPE_CHECKING:
     from typing import Any
 
 
-def invoke_agent_span(context, agent):
-    # type: (agents.RunContextWrapper, agents.Agent) -> sentry_sdk.tracing.Span
-    span = sentry_sdk.start_span(
+def invoke_agent_span(context, agent, kwargs):
+    # type: (agents.RunContextWrapper, agents.Agent, dict[str, Any]) -> sentry_sdk.tracing.Span
+    start_span_function = get_start_span_function()
+    span = start_span_function(
         op=OP.GEN_AI_INVOKE_AGENT,
         name=f"invoke_agent {agent.name}",
         origin=SPAN_ORIGIN,
@@ -22,6 +26,40 @@ def invoke_agent_span(context, agent):
 
     span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "invoke_agent")
 
+    if should_send_default_pii():
+        messages = []
+        if agent.instructions:
+            message = (
+                agent.instructions
+                if isinstance(agent.instructions, str)
+                else safe_serialize(agent.instructions)
+            )
+            messages.append(
+                {
+                    "content": [{"text": message, "type": "text"}],
+                    "role": "system",
+                }
+            )
+
+        original_input = kwargs.get("original_input")
+        if original_input is not None:
+            message = (
+                original_input
+                if isinstance(original_input, str)
+                else safe_serialize(original_input)
+            )
+            messages.append(
+                {
+                    "content": [{"text": message, "type": "text"}],
+                    "role": "user",
+                }
+            )
+
+        if len(messages) > 0:
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_REQUEST_MESSAGES, messages, unpack=False
+            )
+
     _set_agent_data(span, agent)
 
     return span
@@ -29,6 +67,12 @@ def invoke_agent_span(context, agent):
 
 def update_invoke_agent_span(context, agent, output):
     # type: (agents.RunContextWrapper, agents.Agent, Any) -> None
-    current_span = sentry_sdk.get_current_span()
-    if current_span:
-        current_span.__exit__(None, None, None)
+    span = sentry_sdk.get_current_span()
+
+    if span:
+        if should_send_default_pii():
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_RESPONSE_TEXT, output, unpack=False
+            )
+
+        span.__exit__(None, None, None)

sentry_sdk/integrations/openai_agents/utils.py

@@ -9,7 +9,6 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any
-    from typing import Callable
     from agents import Usage
 
 try:
@@ -29,15 +28,6 @@ def _capture_exception(exc):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _get_start_span_function():
-    # type: () -> Callable[..., Any]
-    current_span = sentry_sdk.get_current_span()
-    transaction_exists = (
-        current_span is not None and current_span.containing_transaction == current_span
-    )
-    return sentry_sdk.start_span if transaction_exists else sentry_sdk.start_transaction
-
-
 def _set_agent_data(span, agent):
     # type: (sentry_sdk.tracing.Span, agents.Agent) -> None
     span.set_data(

sentry_sdk/integrations/threading.py

@@ -52,7 +52,7 @@ class ThreadingIntegration(Integration):
 
         try:
             from django import VERSION as django_version  # noqa: N811
-            import channels  # type: ignore[import-not-found]
+            import channels  # type: ignore[import-untyped]
 
             channels_version = channels.__version__
         except ImportError:

sentry_sdk/profiler/continuous_profiler.py

@@ -75,9 +75,11 @@ def setup_continuous_profiler(options, sdk_info, capture_func):
     # type: (Dict[str, Any], SDKInfo, Callable[[Envelope], None]) -> bool
     global _scheduler
 
-    if _scheduler is not None:
+    already_initialized = _scheduler is not None
+
+    if already_initialized:
         logger.debug("[Profiling] Continuous Profiler is already setup")
-        return False
+        teardown_continuous_profiler()
 
     if is_gevent():
         # If gevent has patched the threading modules then we cannot rely on
@@ -117,11 +119,19 @@ def setup_continuous_profiler(options, sdk_info, capture_func):
         )
     )
 
-    atexit.register(teardown_continuous_profiler)
+    if not already_initialized:
+        atexit.register(teardown_continuous_profiler)
 
     return True
 
 
+def is_profile_session_sampled():
+    # type: () -> bool
+    if _scheduler is None:
+        return False
+    return _scheduler.sampled
+
+
 def try_autostart_continuous_profiler():
     # type: () -> None
 

sentry_sdk/tracing.py

@@ -1,4 +1,3 @@
-from decimal import Decimal
 import uuid
 import warnings
 from datetime import datetime, timedelta, timezone
@@ -1251,7 +1250,7 @@ class Transaction(Span):
             return
 
         # Now we roll the dice.
-        self.sampled = self._sample_rand < Decimal.from_float(self.sample_rate)
+        self.sampled = self._sample_rand < self.sample_rate
 
         if self.sampled:
             logger.debug(

sentry_sdk/tracing_utils.py

@@ -6,7 +6,6 @@ import re
 import sys
 from collections.abc import Mapping
 from datetime import timedelta
-from decimal import ROUND_DOWN, Decimal, DefaultContext, localcontext
 from random import Random
 from urllib.parse import quote, unquote
 import uuid
@@ -502,7 +501,7 @@ class PropagationContext:
             return
 
         sample_rand = try_convert(
-            Decimal, self.dynamic_sampling_context.get("sample_rand")
+            float, self.dynamic_sampling_context.get("sample_rand")
         )
         if sample_rand is not None and 0 <= sample_rand < 1:
             # sample_rand is present and valid, so don't overwrite it
@@ -650,7 +649,7 @@ class Baggage:
         options = client.options or {}
 
         sentry_items["trace_id"] = transaction.trace_id
-        sentry_items["sample_rand"] = str(transaction._sample_rand)
+        sentry_items["sample_rand"] = f"{transaction._sample_rand:.6f}"  # noqa: E231
 
         if options.get("environment"):
             sentry_items["environment"] = options["environment"]
@@ -724,15 +723,15 @@ class Baggage:
         )
 
     def _sample_rand(self):
-        # type: () -> Optional[Decimal]
+        # type: () -> Optional[float]
         """Convenience method to get the sample_rand value from the sentry_items.
 
-        We validate the value and parse it as a Decimal before returning it. The value is considered
-        valid if it is a Decimal in the range [0, 1).
+        We validate the value and parse it as a float before returning it. The value is considered
+        valid if it is a float in the range [0, 1).
         """
-        sample_rand = try_convert(Decimal, self.sentry_items.get("sample_rand"))
+        sample_rand = try_convert(float, self.sentry_items.get("sample_rand"))
 
-        if sample_rand is not None and Decimal(0) <= sample_rand < Decimal(1):
+        if sample_rand is not None and 0.0 <= sample_rand < 1.0:
             return sample_rand
 
         return None
@@ -898,7 +897,7 @@ def _generate_sample_rand(
     *,
     interval=(0.0, 1.0),  # type: tuple[float, float]
 ):
-    # type: (...) -> Decimal
+    # type: (...) -> float
     """Generate a sample_rand value from a trace ID.
 
     The generated value will be pseudorandomly chosen from the provided
@@ -913,19 +912,16 @@ def _generate_sample_rand(
         raise ValueError("Invalid interval: lower must be less than upper")
 
     rng = Random(trace_id)
-    sample_rand = upper
-    while sample_rand >= upper:
-        sample_rand = rng.uniform(lower, upper)
-
-    # Round down to exactly six decimal-digit precision.
-    # Setting the context is needed to avoid an InvalidOperation exception
-    # in case the user has changed the default precision or set traps.
-    with localcontext(DefaultContext) as ctx:
-        ctx.prec = 6
-        return Decimal(sample_rand).quantize(
-            Decimal("0.000001"),
-            rounding=ROUND_DOWN,
-        )
+    lower_scaled = int(lower * 1_000_000)
+    upper_scaled = int(upper * 1_000_000)
+    try:
+        sample_rand_scaled = rng.randrange(lower_scaled, upper_scaled)
+    except ValueError:
+        # In some corner cases it might happen that the range is too small
+        # In that case, just take the lower bound
+        sample_rand_scaled = lower_scaled
+
+    return sample_rand_scaled / 1_000_000
 
 
 def _sample_rand_range(parent_sampled, sample_rate):

sentry_sdk/utils.py

@@ -1934,6 +1934,12 @@ def try_convert(convert_func, value):
     given function. Return None if the conversion fails, i.e. if the function
     raises an exception.
     """
+    try:
+        if isinstance(value, convert_func):  # type: ignore
+            return value
+    except TypeError:
+        pass
+
     try:
         return convert_func(value)
     except Exception:

{sentry_sdk-2.37.0.dist-info → sentry_sdk-2.38.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.37.0
+Version: 2.38.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.37.0.dist-info → sentry_sdk-2.38.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-sentry_sdk/__init__.py,sha256=WaDm18HlX8BC_JAApork8LhiUBqPeJSXcMZDv3ACcWs,1310
+sentry_sdk/__init__.py,sha256=-jRAO-EG4LBj5L20sK01fdMlbtvGf_idy54Eb46EiKQ,1364
 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
 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/_types.py,sha256=Gw9Pn0mIHZP23B8C2iM1g07NzxnAkpgRAGR5MrKA2Es,10487
 sentry_sdk/_werkzeug.py,sha256=m3GPf-jHd8v3eVOfBHaKw5f0uHoLkXrSO1EcY-8EisY,3734
 sentry_sdk/api.py,sha256=OkwQ2tA5YASJ77wLOteUdv_woPF4wL_JTOAMxe9z8k4,15282
 sentry_sdk/attachments.py,sha256=0Dylhm065O6hNFjB40fWCd5Hg4qWSXndmi1TPWglZkI,3109
 sentry_sdk/client.py,sha256=oQcolwFdLvuX4huUaCcpgABy3M5Yb4IhzymlzyrqfkE,38860
-sentry_sdk/consts.py,sha256=zikq23bebhFyfrsj65Yi8y_7VSP_HMiyXFdWtbM0zUA,49815
+sentry_sdk/consts.py,sha256=z-QZyKPzeM4-ZYB4wOmNZ_3CnS7QcTjXZ49nuMAr9H4,49865
 sentry_sdk/debug.py,sha256=ddBehQlAuQC1sg1XO-N4N3diZ0x0iT5RWJwFdrtcsjw,1019
-sentry_sdk/envelope.py,sha256=Mgcib0uLm_5tSVzOrznRLdK9B3CjQ6TEgM1ZIZIfjWo,10355
+sentry_sdk/envelope.py,sha256=nCUvqVWIVWV-RoVvMgrTNUDfo7h_Z5jU8g90T30wdXE,10360
 sentry_sdk/feature_flags.py,sha256=99JRig6TBkrkBzVCKqYcmVgjsuA_Hk-ul7jFHGhJplc,2233
 sentry_sdk/hub.py,sha256=2QLvEtIYSYV04r8h7VBmQjookILaiBZxZBGTtQKNAWg,25675
 sentry_sdk/logger.py,sha256=HnmkMmOf1hwvxIcPW2qOvIOSnFZ9yRNDBae_eriGsoY,2471
@@ -24,29 +24,29 @@ sentry_sdk/serializer.py,sha256=xUw3xjSsGF0cWRHL9ofe0nmWEtZvzPOHSQ6IHvo6UAc,1323
 sentry_sdk/session.py,sha256=TqDVmRKKHUDSmZb4jQR-s8wDt7Fwb6QaG21hawUGWEs,5571
 sentry_sdk/sessions.py,sha256=UZ2jfrqhYvZzTxCDGc1MLD6P_aHLJnTFetSUROIaPaA,9154
 sentry_sdk/spotlight.py,sha256=93kdd8KxdLfcPaxFnFuqHgYAAL4FCfpK1hiiPoD7Ac4,8678
-sentry_sdk/tracing.py,sha256=FHL6u9SHGfyFCDnSbOwZiQYStTcuf8-YvV47DO4Q9DI,51578
-sentry_sdk/tracing_utils.py,sha256=0RjENkigpVHydBIk_CqOTRZ8GJQHslgHveatvelZA1c,39040
+sentry_sdk/tracing.py,sha256=ecnuM0Y8ueX110M4iXfOV8ay4nWiHuvCiNQMPrNzaBM,51530
+sentry_sdk/tracing_utils.py,sha256=EM2e3UHkOUNoWhs0gaFjaJZDAyHKCw2KB0fOwWlZF0w,38862
 sentry_sdk/transport.py,sha256=A0uux7XnniDJuExLudLyyFDYnS5C6r7zozGbkveUM7E,32469
 sentry_sdk/types.py,sha256=NLbnRzww2K3_oGz2GzcC8TdX5L2DXYso1-H1uCv2Hwc,1222
-sentry_sdk/utils.py,sha256=Ys7lnnvXZMIR9dcoT30CVxpUx2NnZifSy-TUNrCtMQA,61575
+sentry_sdk/utils.py,sha256=KubsR-No80YTJ1FYwNQxavYU4hOQyBixevnPsXxNCBc,61705
 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=bS_KneWCAL9ehml5XiyficoPVx4DUUG6acbH3cjP3I8,5057
-sentry_sdk/ai/utils.py,sha256=JPK6EM0ZcjWJU1IP2k40Jxf0yD_-ox_FlYxVIn7LVR4,1351
+sentry_sdk/ai/utils.py,sha256=CsPNw-N2utLhUfXbT8cCBPlDIyTBNzJQ5aIF18gPdhk,1705
 sentry_sdk/crons/__init__.py,sha256=3Zt6g1-pZZ12uRKKsC8QLm3XgJ4K1VYxgVpNNUygOZY,221
 sentry_sdk/crons/api.py,sha256=mk-UB8Im2LU2rJFdE-TV302EaKnf8kAjwEL0bIV0Hzc,1767
 sentry_sdk/crons/consts.py,sha256=dXqJk5meBSu5rjlGpqAOlkpACnuUi7svQnAFoy1ZNUU,87
 sentry_sdk/crons/decorator.py,sha256=UrjeIqBCbvsuKrfjGkKJbbLBvjw2TQvDWcTO7WwAmrI,3913
-sentry_sdk/integrations/__init__.py,sha256=NNRTFZUcQacKGRCWT8IuVZk2wtifEhnQ34-6mHuekvw,10339
+sentry_sdk/integrations/__init__.py,sha256=tWC8ujNg8r8Sc4bk8L5NMeAJQgbPYtvWdnbWwBlVVbQ,10342
 sentry_sdk/integrations/_asgi_common.py,sha256=Ypg7IctB3iPPY60ebVlzChzgT8GeGpZ0YH8VvJNDlEY,3187
 sentry_sdk/integrations/_wsgi_common.py,sha256=A1-X7l1pZCcrbUhRHkmdKiK_EemEZjn7xToJIvlEuFM,7558
 sentry_sdk/integrations/aiohttp.py,sha256=_rfDKx1arvVQwcC20vh7HG80p8XtgzqKB3iBuPYZy8A,12895
-sentry_sdk/integrations/anthropic.py,sha256=8KnFdRNeaaB_rB9Bmi0FbYQrw1TUX535t2uSRI8Pv9o,11726
+sentry_sdk/integrations/anthropic.py,sha256=7MqIgZLOD3fOw14F9BxHFr9VpLpy44QtZgaPyYVKFi4,13169
 sentry_sdk/integrations/argv.py,sha256=GIY7TBFETF8Z0fDzqTXEJldt5XXCDdFNZxpGxP7EPaU,911
 sentry_sdk/integrations/ariadne.py,sha256=C-zKlOrU7jvTWmQHZx0M0tAZNkPPo7Z5-5jXDD92LiU,5834
 sentry_sdk/integrations/arq.py,sha256=yDPdWJa3ZgnGLwFzavIylIafEVN0qqSSgL4kUHxQF70,7881
 sentry_sdk/integrations/asgi.py,sha256=zjoOOA5bHlTptRsP3ZU4X5UsluyHFqebsUt3lRfiGtE,12738
-sentry_sdk/integrations/asyncio.py,sha256=KdQs5dd_jY2cmBTGeG_jwEgfrPntC4lH71vTBXI670k,4034
+sentry_sdk/integrations/asyncio.py,sha256=DEoXAwk8oVl_1Sbmm2TthpruaLO7p4WZBTh9K-mch_g,4136
 sentry_sdk/integrations/asyncpg.py,sha256=fbBTi5bEERK3c9o43LBLtS5wPaSVq_qIl3Y50NPmr5Y,6521
 sentry_sdk/integrations/atexit.py,sha256=sY46N2hEvtGuT1DBQhirUXHbjgXjXAm7R_sgiectVKw,1652
 sentry_sdk/integrations/aws_lambda.py,sha256=WveHWnB_nBsnfLTbaUxih79Ra3Qjv4Jjh-7m2v-gSJs,17954
@@ -57,7 +57,7 @@ sentry_sdk/integrations/chalice.py,sha256=A4K_9FmNUu131El0ctkTmjtyYd184I4hQTlidZ
 sentry_sdk/integrations/clickhouse_driver.py,sha256=2qpRznwSNuRSzrCA1R5bmpgiehDmzbG7yZe6hN-61Wg,6098
 sentry_sdk/integrations/cloud_resource_context.py,sha256=_gFldMeVHs5pxP5sm8uP7ZKmm6s_5hw3UsnXek9Iw8A,7780
 sentry_sdk/integrations/cohere.py,sha256=iuDI1IVPE39rbsc3e9_qJS2bCjNg7F53apueCdhzr8Q,9322
-sentry_sdk/integrations/dedupe.py,sha256=usREWhtGDFyxVBlIVzyCYj_Qy7NJBJ84FK0B57z11LM,1418
+sentry_sdk/integrations/dedupe.py,sha256=nZF_Ml-5axq_Nh3AZT80Z0bNNgPbxvYn79eVeBKrIGA,1515
 sentry_sdk/integrations/dramatiq.py,sha256=I09vKWnfiuhdRFCjYYjmE9LOBQvDTPS-KFqf3iHFSsM,5583
 sentry_sdk/integrations/excepthook.py,sha256=tfwpSQuo1b_OmJbNKPPRh90EUjD_OSE4DqqgYY9PVQI,2408
 sentry_sdk/integrations/executing.py,sha256=5lxBAxO5FypY-zTV03AHncGmolmaHd327-3Vrjzskcc,1994
@@ -66,12 +66,12 @@ sentry_sdk/integrations/fastapi.py,sha256=kicdigHM3MG-GlpLUN6wwH8jOVu4dTuoQD6RBF
 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=FL7WkRfHT6idYCSLIrtFQ2G5ZTGoYudCKvBcjR5hqsI,2812
-sentry_sdk/integrations/gql.py,sha256=ppC7fjpyQ6jWST-batRt5HtebxE_9IeHbmZ-CJ1TfUU,4179
+sentry_sdk/integrations/gql.py,sha256=lN5LJNZwUHs_1BQcIrR0adIkgb9YiOh6UtoUG8vCO_Y,4801
 sentry_sdk/integrations/graphene.py,sha256=I6ZJ8Apd9dO9XPVvZY7I46-v1eXOW1C1rAkWwasF3gU,5042
 sentry_sdk/integrations/httpx.py,sha256=WwUulqzBLoGGqWUUdQg_MThwQUKzBXnA-m3g_1GOpCE,5866
 sentry_sdk/integrations/huey.py,sha256=wlyxjeWqqJp1X5S3neD5FiZjXcyznm1dl8_u1wIo76U,5443
-sentry_sdk/integrations/huggingface_hub.py,sha256=ypTn17T0vufQwi7ODXONFkB8fMjUrU5b4Q6JZ34bnA4,6717
-sentry_sdk/integrations/langchain.py,sha256=hWni8-sy8gu4mk10RE2yM92XdQUFGI9gochaK0jMlRg,29209
+sentry_sdk/integrations/huggingface_hub.py,sha256=33Z2Z0SEEQMcpoAY0y8EFfQdMaB1DacSVJ22utdHHKU,14940
+sentry_sdk/integrations/langchain.py,sha256=vO7alD-_3gLuqW3LW2gQUYgatjB9CrsI-7IpJmOy8Tc,29393
 sentry_sdk/integrations/langgraph.py,sha256=YyDDc14gFCNVuqVmKwX8GRQ17T17WOx2SqqD4IHROPs,11015
 sentry_sdk/integrations/launchdarkly.py,sha256=bvtExuj68xPXZFsQeWTDR-ZBqP087tPuVzP1bNAOZHc,1935
 sentry_sdk/integrations/litestar.py,sha256=jao0f8v5JQagkBg15dUJTdWGPxpS3LmOV301-lwGkGc,11815
@@ -97,7 +97,7 @@ 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=tV7pQB8LwR8dIju-I81rgjps4sRxSofj_2YFBL2JXWM,5396
+sentry_sdk/integrations/threading.py,sha256=yzJ2gK9cWg_-gZfAidzktVokGM9fxAijS4nMO_Ev7r0,5394
 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
@@ -124,18 +124,18 @@ 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=7OiJc2BW9yvuVZBd8o7A6sWq0jy2ri9dWwvqMjJG2cw,5571
+sentry_sdk/integrations/openai_agents/utils.py,sha256=mb8pGXZ0t_-mgbIJMh6HfVoGKp6kGqIMB7U5URQtSQA,5208
 sentry_sdk/integrations/openai_agents/patches/__init__.py,sha256=I7C9JZ70Mf8PV3wPdFsxTqvcYl4TYUgSZYfNU2Spb7Y,231
-sentry_sdk/integrations/openai_agents/patches/agent_run.py,sha256=qPmZ--UMQpExxYGEbaDJ7tY_H9VQ6gv0lpim3_impWk,5733
+sentry_sdk/integrations/openai_agents/patches/agent_run.py,sha256=GPBV-j8YnHOrJAhdhu_tphe14z7G0-riFVmjFNDgy0s,5773
 sentry_sdk/integrations/openai_agents/patches/models.py,sha256=DtwqCmSsYFlhRZquKM2jiTOnnAg97eyCTtJYZkWqdww,1405
 sentry_sdk/integrations/openai_agents/patches/runner.py,sha256=Fr5tflgadu3fnEThSZauAhrT7BbvemuZelDVGZjleqA,1483
 sentry_sdk/integrations/openai_agents/patches/tools.py,sha256=uAx1GgsiDJBP7jpYW8r_kOImdgzXlwYqK-uhkyP3icI,3255
 sentry_sdk/integrations/openai_agents/spans/__init__.py,sha256=RlVi781zGsvCJBciDO_EbBbwkakwbP9DoFQBbo4VAEE,353
-sentry_sdk/integrations/openai_agents/spans/agent_workflow.py,sha256=GIIeNKQ1rrciqkjwJWK5AMxsjWjWslR3E054jIWDoiw,459
+sentry_sdk/integrations/openai_agents/spans/agent_workflow.py,sha256=fdRSThD31TcoMXFg-2vmqK2YcSws8Yhd0oC6fxOnysM,469
 sentry_sdk/integrations/openai_agents/spans/ai_client.py,sha256=0HG5pT8a06Zgc5JUmRx8p_6bPoQFQLjDrMY_QSQd0_E,1206
 sentry_sdk/integrations/openai_agents/spans/execute_tool.py,sha256=w3QWWS4wbpteFTz4JjMCXdDpR6JVKcUVREQ-lvJOQTY,1420
 sentry_sdk/integrations/openai_agents/spans/handoff.py,sha256=MBhzy7MpvPGwQTPT5TFcOnmSPiSH_uadQ5wvksueIik,525
-sentry_sdk/integrations/openai_agents/spans/invoke_agent.py,sha256=WU7E7DoO1IXZKjXuZ1BTPqfWnm3mNl6Ao8duUGoRA9w,875
+sentry_sdk/integrations/openai_agents/spans/invoke_agent.py,sha256=yyg-wyVZaYMYbaORva_BotNxB9oyK5Dsn8KfQ3Y7OZI,2323
 sentry_sdk/integrations/opentelemetry/__init__.py,sha256=emNL5aAq_NhK0PZmfX_g4GIdvBS6nHqGrjrIgrdC5m8,229
 sentry_sdk/integrations/opentelemetry/consts.py,sha256=fYL6FIAEfnGZGBhFn5X7aRyHxihSPqAKKqMLhf5Gniw,143
 sentry_sdk/integrations/opentelemetry/integration.py,sha256=CWp6hFFMqoR7wcuwTRbRO-1iVch4A6oOB3RuHWeX9GQ,1791
@@ -157,12 +157,12 @@ sentry_sdk/integrations/spark/__init__.py,sha256=oOewMErnZk2rzNvIlZO6URxQexu9bUJ
 sentry_sdk/integrations/spark/spark_driver.py,sha256=mqGQMngDAZWM78lWK5S0FPpmjd1Q65Ta5T4bOH6mNXs,9465
 sentry_sdk/integrations/spark/spark_worker.py,sha256=FGT4yRU2X_iQCC46aasMmvJfYOKmBip8KbDF_wnhvEY,3706
 sentry_sdk/profiler/__init__.py,sha256=3PI3bHk9RSkkOXZKN84DDedk_7M65EiqqaIGo-DYs0E,1291
-sentry_sdk/profiler/continuous_profiler.py,sha256=s0DHkj3RZYRg9HnQQC0G44ku6DaFqRy30fZTMtTYvIs,22828
+sentry_sdk/profiler/continuous_profiler.py,sha256=7Qb75TaKLNYxMA97wO-qEpDVqxPQWOLUi2rnUm6_Ci0,23066
 sentry_sdk/profiler/transaction_profiler.py,sha256=e3MsUqs-YIp6-nmzpmBYGoWWIF7RyuSGu24Dj-8GXAU,27970
 sentry_sdk/profiler/utils.py,sha256=G5s4tYai9ATJqcHrQ3bOIxlK6jIaHzELrDtU5k3N4HI,6556
-sentry_sdk-2.37.0.dist-info/licenses/LICENSE,sha256=KhQNZg9GKBL6KQvHQNBGMxJsXsRdhLebVp4Sew7t3Qs,1093
-sentry_sdk-2.37.0.dist-info/METADATA,sha256=fo-BB6ui6_ktMw8ywCcwBe9RUT78Bzv4rd1DSu-ZUEw,10358
-sentry_sdk-2.37.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-sentry_sdk-2.37.0.dist-info/entry_points.txt,sha256=qacZEz40UspQZD1IukCXykx0JtImqGDOctS5KfOLTko,91
-sentry_sdk-2.37.0.dist-info/top_level.txt,sha256=XrQz30XE9FKXSY_yGLrd9bsv2Rk390GTDJOSujYaMxI,11
-sentry_sdk-2.37.0.dist-info/RECORD,,
+sentry_sdk-2.38.0.dist-info/licenses/LICENSE,sha256=KhQNZg9GKBL6KQvHQNBGMxJsXsRdhLebVp4Sew7t3Qs,1093
+sentry_sdk-2.38.0.dist-info/METADATA,sha256=cxysc3uOmG-4teAeFmBvG40-oF7DfJDO01sPlHYG8aI,10358
+sentry_sdk-2.38.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+sentry_sdk-2.38.0.dist-info/entry_points.txt,sha256=qacZEz40UspQZD1IukCXykx0JtImqGDOctS5KfOLTko,91
+sentry_sdk-2.38.0.dist-info/top_level.txt,sha256=XrQz30XE9FKXSY_yGLrd9bsv2Rk390GTDJOSujYaMxI,11
+sentry_sdk-2.38.0.dist-info/RECORD,,