sentry-sdk 2.39.0__py2.py3-none-any.whl → 2.40.0__py2.py3-none-any.whl

sentry_sdk/integrations/litellm.py

@@ -0,0 +1,251 @@
+from typing import TYPE_CHECKING
+
+import sentry_sdk
+from sentry_sdk import consts
+from sentry_sdk.ai.monitoring import record_token_usage
+from sentry_sdk.ai.utils import get_start_span_function, set_data_normalized
+from sentry_sdk.consts import SPANDATA
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.utils import event_from_exception
+
+if TYPE_CHECKING:
+    from typing import Any, Dict
+    from datetime import datetime
+
+try:
+    import litellm  # type: ignore[import-not-found]
+except ImportError:
+    raise DidNotEnable("LiteLLM not installed")
+
+
+def _get_metadata_dict(kwargs):
+    # type: (Dict[str, Any]) -> Dict[str, Any]
+    """Get the metadata dictionary from the kwargs."""
+    litellm_params = kwargs.setdefault("litellm_params", {})
+
+    # we need this weird little dance, as metadata might be set but may be None initially
+    metadata = litellm_params.get("metadata")
+    if metadata is None:
+        metadata = {}
+        litellm_params["metadata"] = metadata
+    return metadata
+
+
+def _input_callback(kwargs):
+    # type: (Dict[str, Any]) -> None
+    """Handle the start of a request."""
+    integration = sentry_sdk.get_client().get_integration(LiteLLMIntegration)
+
+    if integration is None:
+        return
+
+    # Get key parameters
+    full_model = kwargs.get("model", "")
+    try:
+        model, provider, _, _ = litellm.get_llm_provider(full_model)
+    except Exception:
+        model = full_model
+        provider = "unknown"
+
+    messages = kwargs.get("messages", [])
+    operation = "chat" if messages else "embeddings"
+
+    # Start a new span/transaction
+    span = get_start_span_function()(
+        op=(
+            consts.OP.GEN_AI_CHAT
+            if operation == "chat"
+            else consts.OP.GEN_AI_EMBEDDINGS
+        ),
+        name=f"{operation} {model}",
+        origin=LiteLLMIntegration.origin,
+    )
+    span.__enter__()
+
+    # Store span for later
+    _get_metadata_dict(kwargs)["_sentry_span"] = span
+
+    # Set basic data
+    set_data_normalized(span, SPANDATA.GEN_AI_SYSTEM, provider)
+    set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, operation)
+
+    # Record messages if allowed
+    if messages and should_send_default_pii() and integration.include_prompts:
+        set_data_normalized(
+            span, SPANDATA.GEN_AI_REQUEST_MESSAGES, messages, unpack=False
+        )
+
+    # Record other parameters
+    params = {
+        "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 params.items():
+        value = kwargs.get(key)
+        if value is not None:
+            set_data_normalized(span, attribute, value)
+
+    # Record LiteLLM-specific parameters
+    litellm_params = {
+        "api_base": kwargs.get("api_base"),
+        "api_version": kwargs.get("api_version"),
+        "custom_llm_provider": kwargs.get("custom_llm_provider"),
+    }
+    for key, value in litellm_params.items():
+        if value is not None:
+            set_data_normalized(span, f"gen_ai.litellm.{key}", value)
+
+
+def _success_callback(kwargs, completion_response, start_time, end_time):
+    # type: (Dict[str, Any], Any, datetime, datetime) -> None
+    """Handle successful completion."""
+
+    span = _get_metadata_dict(kwargs).get("_sentry_span")
+    if span is None:
+        return
+
+    integration = sentry_sdk.get_client().get_integration(LiteLLMIntegration)
+    if integration is None:
+        return
+
+    try:
+        # Record model information
+        if hasattr(completion_response, "model"):
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_RESPONSE_MODEL, completion_response.model
+            )
+
+        # Record response content if allowed
+        if should_send_default_pii() and integration.include_prompts:
+            if hasattr(completion_response, "choices"):
+                response_messages = []
+                for choice in completion_response.choices:
+                    if hasattr(choice, "message"):
+                        if hasattr(choice.message, "model_dump"):
+                            response_messages.append(choice.message.model_dump())
+                        elif hasattr(choice.message, "dict"):
+                            response_messages.append(choice.message.dict())
+                        else:
+                            # Fallback for basic message objects
+                            msg = {}
+                            if hasattr(choice.message, "role"):
+                                msg["role"] = choice.message.role
+                            if hasattr(choice.message, "content"):
+                                msg["content"] = choice.message.content
+                            if hasattr(choice.message, "tool_calls"):
+                                msg["tool_calls"] = choice.message.tool_calls
+                            response_messages.append(msg)
+
+                if response_messages:
+                    set_data_normalized(
+                        span, SPANDATA.GEN_AI_RESPONSE_TEXT, response_messages
+                    )
+
+        # Record token usage
+        if hasattr(completion_response, "usage"):
+            usage = completion_response.usage
+            record_token_usage(
+                span,
+                input_tokens=getattr(usage, "prompt_tokens", None),
+                output_tokens=getattr(usage, "completion_tokens", None),
+                total_tokens=getattr(usage, "total_tokens", None),
+            )
+
+    finally:
+        # Always finish the span and clean up
+        span.__exit__(None, None, None)
+
+
+def _failure_callback(kwargs, exception, start_time, end_time):
+    # type: (Dict[str, Any], Exception, datetime, datetime) -> None
+    """Handle request failure."""
+    span = _get_metadata_dict(kwargs).get("_sentry_span")
+    if span is None:
+        return
+
+    try:
+        # Capture the exception
+        event, hint = event_from_exception(
+            exception,
+            client_options=sentry_sdk.get_client().options,
+            mechanism={"type": "litellm", "handled": False},
+        )
+        sentry_sdk.capture_event(event, hint=hint)
+    finally:
+        # Always finish the span and clean up
+        span.__exit__(type(exception), exception, None)
+
+
+class LiteLLMIntegration(Integration):
+    """
+    LiteLLM integration for Sentry.
+
+    This integration automatically captures LiteLLM API calls and sends them to Sentry
+    for monitoring and error tracking. It supports all 100+ LLM providers that LiteLLM
+    supports, including OpenAI, Anthropic, Google, Cohere, and many others.
+
+    Features:
+    - Automatic exception capture for all LiteLLM calls
+    - Token usage tracking across all providers
+    - Provider detection and attribution
+    - Input/output message capture (configurable)
+    - Streaming response support
+    - Cost tracking integration
+
+    Usage:
+
+    ```python
+    import litellm
+    import sentry_sdk
+
+    # Initialize Sentry with the LiteLLM integration
+    sentry_sdk.init(
+        dsn="your-dsn",
+        send_default_pii=True
+        integrations=[
+            sentry_sdk.integrations.LiteLLMIntegration(
+                include_prompts=True  # Set to False to exclude message content
+            )
+        ]
+    )
+
+    # All LiteLLM calls will now be monitored
+    response = litellm.completion(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    ```
+
+    Configuration:
+    - include_prompts (bool): Whether to include prompts and responses in spans.
+      Defaults to True. Set to False to exclude potentially sensitive data.
+    """
+
+    identifier = "litellm"
+    origin = f"auto.ai.{identifier}"
+
+    def __init__(self, include_prompts=True):
+        # type: (LiteLLMIntegration, bool) -> None
+        self.include_prompts = include_prompts
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        """Set up LiteLLM callbacks for monitoring."""
+        litellm.input_callback = litellm.input_callback or []
+        if _input_callback not in litellm.input_callback:
+            litellm.input_callback.append(_input_callback)
+
+        litellm.success_callback = litellm.success_callback or []
+        if _success_callback not in litellm.success_callback:
+            litellm.success_callback.append(_success_callback)
+
+        litellm.failure_callback = litellm.failure_callback or []
+        if _failure_callback not in litellm.failure_callback:
+            litellm.failure_callback.append(_failure_callback)

sentry_sdk/integrations/litestar.py

@@ -1,4 +1,6 @@
 from collections.abc import Set
+from copy import deepcopy
+
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import (
@@ -222,9 +224,7 @@ def patch_http_route_handle():
             return await old_handle(self, scope, receive, send)
 
         sentry_scope = sentry_sdk.get_isolation_scope()
-        request = scope["app"].request_class(
-            scope=scope, receive=receive, send=send
-        )  # type: Request[Any, Any]
+        request = scope["app"].request_class(scope=scope, receive=receive, send=send)  # type: Request[Any, Any]
         extracted_request_data = ConnectionDataExtractor(
             parse_body=True, parse_query=True
         )(request)
@@ -262,7 +262,7 @@ def patch_http_route_handle():
 
             event.update(
                 {
-                    "request": request_info,
+                    "request": deepcopy(request_info),
                     "transaction": tx_name,
                     "transaction_info": tx_info,
                 }

sentry_sdk/integrations/openai_agents/spans/ai_client.py

@@ -7,6 +7,7 @@ from ..utils import (
     _set_input_data,
     _set_output_data,
     _set_usage_data,
+    _create_mcp_execute_tool_spans,
 )
 
 from typing import TYPE_CHECKING
@@ -28,12 +29,14 @@ def ai_client_span(agent, get_response_kwargs):
     # TODO-anton: remove hardcoded stuff and replace something that also works for embedding and so on
     span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "chat")
 
+    _set_agent_data(span, agent)
+
     return span
 
 
 def update_ai_client_span(span, agent, get_response_kwargs, result):
     # type: (sentry_sdk.tracing.Span, Agent, dict[str, Any], Any) -> None
-    _set_agent_data(span, agent)
     _set_usage_data(span, result.usage)
     _set_input_data(span, get_response_kwargs)
     _set_output_data(span, result)
+    _create_mcp_execute_tool_spans(span, result)

sentry_sdk/integrations/openai_agents/utils.py

@@ -1,6 +1,6 @@
 import sentry_sdk
 from sentry_sdk.ai.utils import set_data_normalized
-from sentry_sdk.consts import SPANDATA
+from sentry_sdk.consts import SPANDATA, SPANSTATUS, OP
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.tracing_utils import set_span_errored
@@ -156,3 +156,27 @@ def _set_output_data(span, result):
         set_data_normalized(
             span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
         )
+
+
+def _create_mcp_execute_tool_spans(span, result):
+    # type: (sentry_sdk.tracing.Span, agents.Result) -> None
+    for output in result.output:
+        if output.__class__.__name__ == "McpCall":
+            with sentry_sdk.start_span(
+                op=OP.GEN_AI_EXECUTE_TOOL,
+                description=f"execute_tool {output.name}",
+                start_timestamp=span.start_timestamp,
+            ) as execute_tool_span:
+                set_data_normalized(execute_tool_span, SPANDATA.GEN_AI_TOOL_TYPE, "mcp")
+                set_data_normalized(
+                    execute_tool_span, SPANDATA.GEN_AI_TOOL_NAME, output.name
+                )
+                if should_send_default_pii():
+                    execute_tool_span.set_data(
+                        SPANDATA.GEN_AI_TOOL_INPUT, output.arguments
+                    )
+                    execute_tool_span.set_data(
+                        SPANDATA.GEN_AI_TOOL_OUTPUT, output.output
+                    )
+                if output.error:
+                    execute_tool_span.set_status(SPANSTATUS.ERROR)

sentry_sdk/integrations/pure_eval.py

@@ -116,7 +116,9 @@ def pure_eval_frame(frame):
             return (n.lineno, n.col_offset)
 
         nodes_before_stmt = [
-            node for node in nodes if start(node) < stmt.last_token.end  # type: ignore
+            node
+            for node in nodes
+            if start(node) < stmt.last_token.end  # type: ignore
         ]
         if nodes_before_stmt:
             # The position of the last node before or in the statement

sentry_sdk/integrations/spark/spark_driver.py

@@ -158,7 +158,8 @@ class SparkListener:
         pass
 
     def onExecutorBlacklistedForStage(  # noqa: N802
-        self, executorBlacklistedForStage  # noqa: N803
+        self,
+        executorBlacklistedForStage,  # noqa: N803
     ):
         # type: (Any) -> None
         pass

sentry_sdk/integrations/sqlalchemy.py

@@ -64,9 +64,7 @@ def _before_cursor_execute(
 @ensure_integration_enabled(SqlalchemyIntegration)
 def _after_cursor_execute(conn, cursor, statement, parameters, context, *args):
     # type: (Any, Any, Any, Any, Any, *Any) -> None
-    ctx_mgr = getattr(
-        context, "_sentry_sql_span_manager", None
-    )  # type: Optional[ContextManager[Any]]
+    ctx_mgr = getattr(context, "_sentry_sql_span_manager", None)  # type: Optional[ContextManager[Any]]
 
     if ctx_mgr is not None:
         context._sentry_sql_span_manager = None
@@ -92,9 +90,7 @@ def _handle_error(context, *args):
     # _after_cursor_execute does not get called for crashing SQL stmts. Judging
     # from SQLAlchemy codebase it does seem like any error coming into this
     # handler is going to be fatal.
-    ctx_mgr = getattr(
-        execution_context, "_sentry_sql_span_manager", None
-    )  # type: Optional[ContextManager[Any]]
+    ctx_mgr = getattr(execution_context, "_sentry_sql_span_manager", None)  # type: Optional[ContextManager[Any]]
 
     if ctx_mgr is not None:
         execution_context._sentry_sql_span_manager = None

sentry_sdk/integrations/starlette.py

@@ -103,9 +103,7 @@ class StarletteIntegration(Integration):
         self.http_methods_to_capture = tuple(map(str.upper, http_methods_to_capture))
 
         if isinstance(failed_request_status_codes, Set):
-            self.failed_request_status_codes = (
-                failed_request_status_codes
-            )  # type: Container[int]
+            self.failed_request_status_codes = failed_request_status_codes  # type: Container[int]
         else:
             warnings.warn(
                 "Passing a list or None for failed_request_status_codes is deprecated. "

sentry_sdk/integrations/starlite.py

@@ -1,3 +1,5 @@
+from copy import deepcopy
+
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import DidNotEnable, Integration
@@ -200,9 +202,7 @@ def patch_http_route_handle():
             return await old_handle(self, scope, receive, send)
 
         sentry_scope = sentry_sdk.get_isolation_scope()
-        request = scope["app"].request_class(
-            scope=scope, receive=receive, send=send
-        )  # type: Request[Any, Any]
+        request = scope["app"].request_class(scope=scope, receive=receive, send=send)  # type: Request[Any, Any]
         extracted_request_data = ConnectionDataExtractor(
             parse_body=True, parse_query=True
         )(request)
@@ -239,7 +239,7 @@ def patch_http_route_handle():
 
             event.update(
                 {
-                    "request": request_info,
+                    "request": deepcopy(request_info),
                     "transaction": tx_name,
                     "transaction_info": tx_info,
                 }

sentry_sdk/integrations/wsgi.py

@@ -119,14 +119,15 @@ class SentryWsgiMiddleware:
                             origin=self.span_origin,
                         )
 
-                    with (
+                    transaction_context = (
                         sentry_sdk.start_transaction(
                             transaction,
                             custom_sampling_context={"wsgi_environ": environ},
                         )
                         if transaction is not None
                         else nullcontext()
-                    ):
+                    )
+                    with transaction_context:
                         try:
                             response = self.app(
                                 environ,

sentry_sdk/metrics.py

@@ -159,7 +159,8 @@ class CounterMetric(Metric):
     __slots__ = ("value",)
 
     def __init__(
-        self, first  # type: MetricValue
+        self,
+        first,  # type: MetricValue
     ):
         # type: (...) -> None
         self.value = float(first)
@@ -170,7 +171,8 @@ class CounterMetric(Metric):
         return 1
 
     def add(
-        self, value  # type: MetricValue
+        self,
+        value,  # type: MetricValue
     ):
         # type: (...) -> None
         self.value += float(value)
@@ -190,7 +192,8 @@ class GaugeMetric(Metric):
     )
 
     def __init__(
-        self, first  # type: MetricValue
+        self,
+        first,  # type: MetricValue
     ):
         # type: (...) -> None
         first = float(first)
@@ -207,7 +210,8 @@ class GaugeMetric(Metric):
         return 5
 
     def add(
-        self, value  # type: MetricValue
+        self,
+        value,  # type: MetricValue
     ):
         # type: (...) -> None
         value = float(value)
@@ -232,7 +236,8 @@ class DistributionMetric(Metric):
     __slots__ = ("value",)
 
     def __init__(
-        self, first  # type: MetricValue
+        self,
+        first,  # type: MetricValue
     ):
         # type(...) -> None
         self.value = [float(first)]
@@ -243,7 +248,8 @@ class DistributionMetric(Metric):
         return len(self.value)
 
     def add(
-        self, value  # type: MetricValue
+        self,
+        value,  # type: MetricValue
     ):
         # type: (...) -> None
         self.value.append(float(value))
@@ -257,7 +263,8 @@ class SetMetric(Metric):
     __slots__ = ("value",)
 
     def __init__(
-        self, first  # type: MetricValue
+        self,
+        first,  # type: MetricValue
     ):
         # type: (...) -> None
         self.value = {first}
@@ -268,7 +275,8 @@ class SetMetric(Metric):
         return len(self.value)
 
     def add(
-        self, value  # type: MetricValue
+        self,
+        value,  # type: MetricValue
     ):
         # type: (...) -> None
         self.value.add(value)
@@ -373,9 +381,7 @@ class LocalAggregator:
 
     def __init__(self):
         # type: (...) -> None
-        self._measurements = (
-            {}
-        )  # type: Dict[Tuple[str, MetricTagsInternal], Tuple[float, float, int, float]]
+        self._measurements = {}  # type: Dict[Tuple[str, MetricTagsInternal], Tuple[float, float, int, float]]
 
     def add(
         self,

sentry_sdk/profiler/utils.py

@@ -85,9 +85,7 @@ else:
             if (
                 # the co_varnames start with the frame's positional arguments
                 # and we expect the first to be `self` if its an instance method
-                co_varnames
-                and co_varnames[0] == "self"
-                and "self" in frame.f_locals
+                co_varnames and co_varnames[0] == "self" and "self" in frame.f_locals
             ):
                 for cls in type(frame.f_locals["self"]).__mro__:
                     if name in cls.__dict__:
@@ -101,9 +99,7 @@ else:
             if (
                 # the co_varnames start with the frame's positional arguments
                 # and we expect the first to be `cls` if its a class method
-                co_varnames
-                and co_varnames[0] == "cls"
-                and "cls" in frame.f_locals
+                co_varnames and co_varnames[0] == "cls" and "cls" in frame.f_locals
             ):
                 for cls in frame.f_locals["cls"].__mro__:
                     if name in cls.__dict__:

sentry_sdk/scope.py

@@ -894,7 +894,8 @@ class Scope:
         self._contexts[key] = value
 
     def remove_context(
-        self, key  # type: str
+        self,
+        key,  # type: str
     ):
         # type: (...) -> None
         """Removes a context."""
@@ -910,7 +911,8 @@ class Scope:
         self._extras[key] = value
 
     def remove_extra(
-        self, key  # type: str
+        self,
+        key,  # type: str
     ):
         # type: (...) -> None
         """Removes a specific extra key."""
@@ -1321,7 +1323,8 @@ class Scope:
         self._force_auto_session_tracking = None
 
     def add_event_processor(
-        self, func  # type: EventProcessor
+        self,
+        func,  # type: EventProcessor
     ):
         # type: (...) -> None
         """Register a scope local event processor on the scope.

sentry_sdk/serializer.py

@@ -128,9 +128,7 @@ def serialize(event, **kwargs):
     path = []  # type: List[Segment]
     meta_stack = []  # type: List[Dict[str, Any]]
 
-    keep_request_bodies = (
-        kwargs.pop("max_request_body_size", None) == "always"
-    )  # type: bool
+    keep_request_bodies = kwargs.pop("max_request_body_size", None) == "always"  # type: bool
     max_value_length = kwargs.pop("max_value_length", None)  # type: Optional[int]
     is_vars = kwargs.pop("is_vars", False)
     custom_repr = kwargs.pop("custom_repr", None)  # type: Callable[..., Optional[str]]

sentry_sdk/session.py

@@ -130,7 +130,8 @@ class Session:
             self.status = status
 
     def close(
-        self, status=None  # type: Optional[SessionStatus]
+        self,
+        status=None,  # type: Optional[SessionStatus]
     ):
         # type: (...) -> Any
         if status is None and self.status == "ok":
@@ -139,7 +140,8 @@ class Session:
             self.update(status=status)
 
     def get_json_attrs(
-        self, with_user_info=True  # type: Optional[bool]
+        self,
+        with_user_info=True,  # type: Optional[bool]
     ):
         # type: (...) -> Any
         attrs = {}

sentry_sdk/sessions.py

@@ -228,7 +228,8 @@ class SessionFlusher:
         return None
 
     def add_aggregate_session(
-        self, session  # type: Session
+        self,
+        session,  # type: Session
     ):
         # type: (...) -> None
         # NOTE on `session.did`:
@@ -259,7 +260,8 @@ class SessionFlusher:
                 state["exited"] = state.get("exited", 0) + 1
 
     def add_session(
-        self, session  # type: Session
+        self,
+        session,  # type: Session
     ):
         # type: (...) -> None
         if session.session_mode == "request":