sentry-sdk 2.37.0__tar.gz → 2.38.0__tar.gz

{sentry_sdk-2.37.0/sentry_sdk.egg-info → sentry_sdk-2.38.0}/PKG-INFO

@@ -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 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.0}/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-2.37.0 → sentry_sdk-2.38.0}/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-2.38.0/sentry_sdk/integrations/huggingface_hub.py

@@ -0,0 +1,377 @@
+import inspect
+from functools import wraps
+
+import sentry_sdk
+from sentry_sdk.ai.monitoring import record_token_usage
+from sentry_sdk.ai.utils import set_data_normalized
+from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.integrations import 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
+except ImportError:
+    raise DidNotEnable("Huggingface not installed")
+
+
+class HuggingfaceHubIntegration(Integration):
+    identifier = "huggingface_hub"
+    origin = f"auto.ai.{identifier}"
+
+    def __init__(self, include_prompts=True):
+        # type: (HuggingfaceHubIntegration, bool) -> None
+        self.include_prompts = include_prompts
+
+    @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_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,
+            )
+        )
+
+
+def _capture_exception(exc):
+    # type: (Any) -> None
+    event, hint = event_from_exception(
+        exc,
+        client_options=sentry_sdk.get_client().options,
+        mechanism={"type": "huggingface_hub", "handled": False},
+    )
+    sentry_sdk.capture_event(event, hint=hint)
+
+
+def _wrap_huggingface_task(f, op):
+    # type: (Callable[..., Any], str) -> Callable[..., Any]
+    @wraps(f)
+    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:
+            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)
+
+        client = args[0]
+        model = client.model or kwargs.get("model") or ""
+        operation_name = op.split(".")[-1]
+
+        span = sentry_sdk.start_span(
+            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 isinstance(res, str) and res is not None:
+                response_text_buffer.append(res)
+
+            if hasattr(res, "generated_text") and res.generated_text is not None:
+                response_text_buffer.append(res.generated_text)
+
+            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 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.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,
+                )
+            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):
+                # text-generation stream output
+                def new_details_iterator():
+                    # type: () -> Iterable[Any]
+                    finish_reason = None
+                    response_text_buffer: list[str] = []
+                    tokens_used = 0
+
+                    with capture_internal_exceptions():
+                        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 = chunk.details.generated_tokens
+
+                            yield chunk
+
+                        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 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:
+                # chat-completion stream output
+                def new_iterator():
+                    # type: () -> Iterable[str]
+                    finish_reason = None
+                    response_model = None
+                    response_text_buffer: list[str] = []
+                    tool_calls = None
+                    usage = None
+
+                    with capture_internal_exceptions():
+                        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.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_huggingface_task