sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/openai_agents/patches/runner.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from functools import wraps
+
+import sentry_sdk
+
+from ..spans import agent_workflow_span
+from ..utils import _capture_exception
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+
+def _create_run_wrapper(original_func: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Wraps the agents.Runner.run methods to create a root span for the agent workflow runs.
+
+    Note agents.Runner.run_sync() is a wrapper around agents.Runner.run(),
+    so it does not need to be wrapped separately.
+    """
+
+    @wraps(original_func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        agent = args[0]
+        with agent_workflow_span(agent):
+            result = None
+            try:
+                result = await original_func(*args, **kwargs)
+                return result
+            except Exception as exc:
+                _capture_exception(exc)
+
+                # It could be that there is a "invoke agent" span still open
+                span = sentry_sdk.get_current_span()
+                if span is not None and span.timestamp is None:
+                    span.__exit__(None, None, None)
+
+                raise exc from None
+
+    return wrapper

sentry_sdk/integrations/openai_agents/patches/tools.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from functools import wraps
+
+from sentry_sdk.integrations import DidNotEnable
+
+from ..spans import execute_tool_span, update_execute_tool_span
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+try:
+    import agents
+except ImportError:
+    raise DidNotEnable("OpenAI Agents not installed")
+
+
+def _create_get_all_tools_wrapper(
+    original_get_all_tools: Callable[..., Any],
+) -> Callable[..., Any]:
+    """
+    Wraps the agents.Runner._get_all_tools method of the Runner class to wrap all function tools with Sentry instrumentation.
+    """
+
+    @wraps(
+        original_get_all_tools.__func__
+        if hasattr(original_get_all_tools, "__func__")
+        else original_get_all_tools
+    )
+    async def wrapped_get_all_tools(
+        cls: agents.Runner,
+        agent: agents.Agent,
+        context_wrapper: agents.RunContextWrapper,
+    ) -> list[agents.Tool]:
+        # Get the original tools
+        tools = await original_get_all_tools(agent, context_wrapper)
+
+        wrapped_tools = []
+        for tool in tools:
+            # Wrap only the function tools (for now)
+            if tool.__class__.__name__ != "FunctionTool":
+                wrapped_tools.append(tool)
+                continue
+
+            # Create a new FunctionTool with our wrapped invoke method
+            original_on_invoke = tool.on_invoke_tool
+
+            def create_wrapped_invoke(
+                current_tool: agents.Tool, current_on_invoke: Callable[..., Any]
+            ) -> Callable[..., Any]:
+                @wraps(current_on_invoke)
+                async def sentry_wrapped_on_invoke_tool(
+                    *args: Any, **kwargs: Any
+                ) -> Any:
+                    with execute_tool_span(current_tool, *args, **kwargs) as span:
+                        # We can not capture exceptions in tool execution here because
+                        # `_on_invoke_tool` is swallowing the exception here:
+                        # https://github.com/openai/openai-agents-python/blob/main/src/agents/tool.py#L409-L422
+                        # And because function_tool is a decorator with `default_tool_error_function` set as a default parameter
+                        # I was unable to monkey patch it because those are evaluated at module import time
+                        # and the SDK is too late to patch it. I was also unable to patch `_on_invoke_tool_impl`
+                        # because it is nested inside this import time code. As if they made it hard to patch on purpose...
+                        result = await current_on_invoke(*args, **kwargs)
+                        update_execute_tool_span(span, agent, current_tool, result)
+
+                    return result
+
+                return sentry_wrapped_on_invoke_tool
+
+            wrapped_tool = agents.FunctionTool(
+                name=tool.name,
+                description=tool.description,
+                params_json_schema=tool.params_json_schema,
+                on_invoke_tool=create_wrapped_invoke(tool, original_on_invoke),
+                strict_json_schema=tool.strict_json_schema,
+                is_enabled=tool.is_enabled,
+            )
+            wrapped_tools.append(wrapped_tool)
+
+        return wrapped_tools
+
+    return wrapped_get_all_tools

sentry_sdk/integrations/openai_agents/spans/__init__.py

@@ -0,0 +1,5 @@
+from .agent_workflow import agent_workflow_span  # noqa: F401
+from .ai_client import ai_client_span, update_ai_client_span  # noqa: F401
+from .execute_tool import execute_tool_span, update_execute_tool_span  # noqa: F401
+from .handoff import handoff_span  # noqa: F401
+from .invoke_agent import invoke_agent_span, update_invoke_agent_span  # noqa: F401

sentry_sdk/integrations/openai_agents/spans/agent_workflow.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import sentry_sdk
+
+from ..consts import SPAN_ORIGIN
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import agents
+
+
+def agent_workflow_span(agent: agents.Agent) -> sentry_sdk.tracing.Span:
+    # Create a transaction or a span if an transaction is already active
+    span = sentry_sdk.start_span(
+        name=f"{agent.name} workflow",
+        origin=SPAN_ORIGIN,
+    )
+
+    return span

sentry_sdk/integrations/openai_agents/spans/ai_client.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import sentry_sdk
+from sentry_sdk.consts import OP, SPANDATA
+
+from ..consts import SPAN_ORIGIN
+from ..utils import (
+    _set_agent_data,
+    _set_input_data,
+    _set_output_data,
+    _set_usage_data,
+)
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from agents import Agent
+    from typing import Any
+
+
+def ai_client_span(
+    agent: Agent, get_response_kwargs: dict[str, Any]
+) -> sentry_sdk.tracing.Span:
+    model_name = agent.model.model if hasattr(agent.model, "model") else agent.model
+    # TODO-anton: implement other types of operations. Now "chat" is hardcoded.
+    span = sentry_sdk.start_span(
+        op=OP.GEN_AI_CHAT,
+        description=f"chat {model_name}",
+        origin=SPAN_ORIGIN,
+    )
+    # TODO-anton: remove hardcoded stuff and replace something that also works for embedding and so on
+    span.set_attribute(SPANDATA.GEN_AI_OPERATION_NAME, "chat")
+
+    return span
+
+
+def update_ai_client_span(
+    span: sentry_sdk.tracing.Span,
+    agent: Agent,
+    get_response_kwargs: dict[str, Any],
+    result: 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)

sentry_sdk/integrations/openai_agents/spans/execute_tool.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import sentry_sdk
+from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.scope import should_send_default_pii
+
+from ..consts import SPAN_ORIGIN
+from ..utils import _set_agent_data
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import agents
+    from typing import Any
+
+
+def execute_tool_span(
+    tool: agents.Tool, *args: Any, **kwargs: Any
+) -> sentry_sdk.tracing.Span:
+    span = sentry_sdk.start_span(
+        op=OP.GEN_AI_EXECUTE_TOOL,
+        name=f"execute_tool {tool.name}",
+        origin=SPAN_ORIGIN,
+    )
+
+    span.set_attribute(SPANDATA.GEN_AI_OPERATION_NAME, "execute_tool")
+
+    if tool.__class__.__name__ == "FunctionTool":
+        span.set_attribute(SPANDATA.GEN_AI_TOOL_TYPE, "function")
+
+    span.set_attribute(SPANDATA.GEN_AI_TOOL_NAME, tool.name)
+    span.set_attribute(SPANDATA.GEN_AI_TOOL_DESCRIPTION, tool.description)
+
+    if should_send_default_pii():
+        input = args[1]
+        span.set_attribute(SPANDATA.GEN_AI_TOOL_INPUT, input)
+
+    return span
+
+
+def update_execute_tool_span(
+    span: sentry_sdk.tracing.Span, agent: agents.Agent, tool: agents.Tool, result: Any
+) -> None:
+    _set_agent_data(span, agent)
+
+    if should_send_default_pii():
+        span.set_attribute(SPANDATA.GEN_AI_TOOL_OUTPUT, result)

sentry_sdk/integrations/openai_agents/spans/handoff.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import sentry_sdk
+from sentry_sdk.consts import OP, SPANDATA
+
+from ..consts import SPAN_ORIGIN
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import agents
+
+
+def handoff_span(
+    context_wrapper: agents.RunContextWrapper,
+    from_agent: agents.Agent,
+    to_agent_name: str,
+) -> None:
+    with sentry_sdk.start_span(
+        op=OP.GEN_AI_HANDOFF,
+        name=f"handoff from {from_agent.name} to {to_agent_name}",
+        origin=SPAN_ORIGIN,
+    ) as span:
+        span.set_attribute(SPANDATA.GEN_AI_OPERATION_NAME, "handoff")

sentry_sdk/integrations/openai_agents/spans/invoke_agent.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import sentry_sdk
+from sentry_sdk.consts import OP, SPANDATA
+
+from ..consts import SPAN_ORIGIN
+from ..utils import _set_agent_data
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import agents
+    from typing import Any
+
+
+def invoke_agent_span(
+    context_wrapper: agents.RunContextWrapper, agent: agents.Agent
+) -> sentry_sdk.tracing.Span:
+    span = sentry_sdk.start_span(
+        op=OP.GEN_AI_INVOKE_AGENT,
+        name=f"invoke_agent {agent.name}",
+        origin=SPAN_ORIGIN,
+    )
+    span.__enter__()
+
+    span.set_attribute(SPANDATA.GEN_AI_OPERATION_NAME, "invoke_agent")
+
+    _set_agent_data(span, agent)
+
+    context_wrapper._sentry_invoke_agent_span = span
+
+    return span
+
+
+def update_invoke_agent_span(
+    context_wrapper: agents.RunContextWrapper, agent: agents.Agent, output: Any
+) -> None:
+    span = getattr(context_wrapper, "_sentry_invoke_agent_span", None)
+    if span is not None:
+        span.__exit__(None, None, None)
+        del context_wrapper._sentry_invoke_agent_span

sentry_sdk/integrations/openai_agents/utils.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import json
+import sentry_sdk
+from sentry_sdk.consts import SPANDATA
+from sentry_sdk.integrations import DidNotEnable
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.utils import event_from_exception
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+    from typing import Union
+    from agents import Usage
+
+try:
+    import agents
+
+except ImportError:
+    raise DidNotEnable("OpenAI Agents not installed")
+
+
+def _capture_exception(exc: Any) -> None:
+    event, hint = event_from_exception(
+        exc,
+        client_options=sentry_sdk.get_client().options,
+        mechanism={"type": "openai_agents", "handled": False},
+    )
+    sentry_sdk.capture_event(event, hint=hint)
+
+
+def _set_agent_data(span: sentry_sdk.tracing.Span, agent: agents.Agent) -> None:
+    span.set_attribute(
+        SPANDATA.GEN_AI_SYSTEM, "openai"
+    )  # See footnote for  https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-system for explanation why.
+
+    span.set_attribute(SPANDATA.GEN_AI_AGENT_NAME, agent.name)
+
+    if agent.model_settings.max_tokens:
+        span.set_attribute(
+            SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, agent.model_settings.max_tokens
+        )
+
+    if agent.model:
+        model_name = agent.model.model if hasattr(agent.model, "model") else agent.model
+        span.set_attribute(SPANDATA.GEN_AI_REQUEST_MODEL, model_name)
+
+    if agent.model_settings.presence_penalty:
+        span.set_attribute(
+            SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY,
+            agent.model_settings.presence_penalty,
+        )
+
+    if agent.model_settings.temperature:
+        span.set_attribute(
+            SPANDATA.GEN_AI_REQUEST_TEMPERATURE, agent.model_settings.temperature
+        )
+
+    if agent.model_settings.top_p:
+        span.set_attribute(SPANDATA.GEN_AI_REQUEST_TOP_P, agent.model_settings.top_p)
+
+    if agent.model_settings.frequency_penalty:
+        span.set_attribute(
+            SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+            agent.model_settings.frequency_penalty,
+        )
+
+    if len(agent.tools) > 0:
+        span.set_attribute(
+            SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS,
+            safe_serialize([vars(tool) for tool in agent.tools]),
+        )
+
+
+def _set_usage_data(span: sentry_sdk.tracing.Span, usage: Usage) -> None:
+    span.set_attribute(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
+    span.set_attribute(
+        SPANDATA.GEN_AI_USAGE_INPUT_TOKENS_CACHED,
+        usage.input_tokens_details.cached_tokens,
+    )
+    span.set_attribute(SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, usage.output_tokens)
+    span.set_attribute(
+        SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS_REASONING,
+        usage.output_tokens_details.reasoning_tokens,
+    )
+    span.set_attribute(SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, usage.total_tokens)
+
+
+def _set_input_data(
+    span: sentry_sdk.tracing.Span, get_response_kwargs: dict[str, Any]
+) -> None:
+    if not should_send_default_pii():
+        return
+
+    messages_by_role: dict[str, list[Any]] = {
+        "system": [],
+        "user": [],
+        "assistant": [],
+        "tool": [],
+    }
+    system_instructions = get_response_kwargs.get("system_instructions")
+    if system_instructions:
+        messages_by_role["system"].append({"type": "text", "text": system_instructions})
+
+    for message in get_response_kwargs.get("input", []):
+        if "role" in message:
+            messages_by_role[message.get("role")].append(
+                {"type": "text", "text": message.get("content")}
+            )
+        else:
+            if message.get("type") == "function_call":
+                messages_by_role["assistant"].append(message)
+            elif message.get("type") == "function_call_output":
+                messages_by_role["tool"].append(message)
+
+    request_messages = []
+    for role, messages in messages_by_role.items():
+        if len(messages) > 0:
+            request_messages.append({"role": role, "content": messages})
+
+    span.set_attribute(
+        SPANDATA.GEN_AI_REQUEST_MESSAGES, safe_serialize(request_messages)
+    )
+
+
+def _set_output_data(span: sentry_sdk.tracing.Span, result: Any) -> None:
+    if not should_send_default_pii():
+        return
+
+    output_messages: dict[str, list[Any]] = {
+        "response": [],
+        "tool": [],
+    }
+
+    for output in result.output:
+        if output.type == "function_call":
+            output_messages["tool"].append(output.model_dump())
+        elif output.type == "message":
+            for output_message in output.content:
+                try:
+                    output_messages["response"].append(output_message.text)
+                except AttributeError:
+                    # Unknown output message type, just return the json
+                    output_messages["response"].append(output_message.dict())
+
+    if len(output_messages["tool"]) > 0:
+        span.set_attribute(
+            SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS, safe_serialize(output_messages["tool"])
+        )
+
+    if len(output_messages["response"]) > 0:
+        span.set_attribute(
+            SPANDATA.GEN_AI_RESPONSE_TEXT, safe_serialize(output_messages["response"])
+        )
+
+
+def safe_serialize(data: Any) -> str:
+    """Safely serialize to a readable string."""
+
+    def serialize_item(
+        item: Any,
+    ) -> Union[str, dict[Any, Any], list[Any], tuple[Any, ...]]:
+        if callable(item):
+            try:
+                module = getattr(item, "__module__", None)
+                qualname = getattr(item, "__qualname__", None)
+                name = getattr(item, "__name__", "anonymous")
+
+                if module and qualname:
+                    full_path = f"{module}.{qualname}"
+                elif module and name:
+                    full_path = f"{module}.{name}"
+                else:
+                    full_path = name
+
+                return f"<function {full_path}>"
+            except Exception:
+                return f"<callable {type(item).__name__}>"
+        elif isinstance(item, dict):
+            return {k: serialize_item(v) for k, v in item.items()}
+        elif isinstance(item, (list, tuple)):
+            return [serialize_item(x) for x in item]
+        elif hasattr(item, "__dict__"):
+            try:
+                attrs = {
+                    k: serialize_item(v)
+                    for k, v in vars(item).items()
+                    if not k.startswith("_")
+                }
+                return f"<{type(item).__name__} {attrs}>"
+            except Exception:
+                return repr(item)
+        else:
+            return item
+
+    try:
+        serialized = serialize_item(data)
+        return json.dumps(serialized, default=str)
+    except Exception:
+        return str(data)

sentry_sdk/integrations/openfeature.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from sentry_sdk.feature_flags import add_feature_flag
@@ -18,20 +19,24 @@ class OpenFeatureIntegration(Integration):
     identifier = "openfeature"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         # Register the hook within the global openfeature hooks list.
         api.add_hooks(hooks=[OpenFeatureHook()])
 
 
 class OpenFeatureHook(Hook):
 
-    def after(self, hook_context, details, hints):
-        # type: (HookContext, FlagEvaluationDetails[bool], HookHints) -> None
+    def after(
+        self,
+        hook_context: HookContext,
+        details: FlagEvaluationDetails[bool],
+        hints: HookHints,
+    ) -> None:
         if isinstance(details.value, bool):
             add_feature_flag(details.flag_key, details.value)
 
-    def error(self, hook_context, exception, hints):
-        # type: (HookContext, Exception, HookHints) -> None
+    def error(
+        self, hook_context: HookContext, exception: Exception, hints: HookHints
+    ) -> None:
         if isinstance(hook_context.default_value, bool):
             add_feature_flag(hook_context.flag_key, hook_context.default_value)

sentry_sdk/integrations/pure_eval.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import ast
 
 import sentry_sdk
@@ -35,12 +36,10 @@ class PureEvalIntegration(Integration):
     identifier = "pure_eval"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         @add_global_event_processor
-        def add_executing_info(event, hint):
-            # type: (Event, Optional[Hint]) -> Optional[Event]
+        def add_executing_info(event: Event, hint: Optional[Hint]) -> Optional[Event]:
             if sentry_sdk.get_client().get_integration(PureEvalIntegration) is None:
                 return event
 
@@ -81,8 +80,7 @@ class PureEvalIntegration(Integration):
             return event
 
 
-def pure_eval_frame(frame):
-    # type: (FrameType) -> Dict[str, Any]
+def pure_eval_frame(frame: FrameType) -> Dict[str, Any]:
     source = executing.Source.for_frame(frame)
     if not source.tree:
         return {}
@@ -103,16 +101,14 @@ def pure_eval_frame(frame):
     evaluator = pure_eval.Evaluator.from_frame(frame)
     expressions = evaluator.interesting_expressions_grouped(scope)
 
-    def closeness(expression):
-        # type: (Tuple[List[Any], Any]) -> Tuple[int, int]
+    def closeness(expression: Tuple[List[Any], Any]) -> Tuple[int, int]:
         # Prioritise expressions with a node closer to the statement executed
         # without being after that statement
         # A higher return value is better - the expression will appear
         # earlier in the list of values and is less likely to be trimmed
         nodes, _value = expression
 
-        def start(n):
-            # type: (ast.expr) -> Tuple[int, int]
+        def start(n: ast.expr) -> Tuple[int, int]:
             return (n.lineno, n.col_offset)
 
         nodes_before_stmt = [

sentry_sdk/integrations/pymongo.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import copy
 
 import sentry_sdk
@@ -41,8 +42,7 @@ SAFE_COMMAND_ATTRIBUTES = [
 ]
 
 
-def _strip_pii(command):
-    # type: (Dict[str, Any]) -> Dict[str, Any]
+def _strip_pii(command: Dict[str, Any]) -> Dict[str, Any]:
     for key in command:
         is_safe_field = key in SAFE_COMMAND_ATTRIBUTES
         if is_safe_field:
@@ -84,8 +84,7 @@ def _strip_pii(command):
     return command
 
 
-def _get_db_data(event):
-    # type: (Any) -> Dict[str, Any]
+def _get_db_data(event: Any) -> Dict[str, Any]:
     data = {}
 
     data[SPANDATA.DB_SYSTEM] = "mongodb"
@@ -106,16 +105,16 @@ def _get_db_data(event):
 
 
 class CommandTracer(monitoring.CommandListener):
-    def __init__(self):
-        # type: () -> None
-        self._ongoing_operations = {}  # type: Dict[int, Span]
+    def __init__(self) -> None:
+        self._ongoing_operations: Dict[int, Span] = {}
 
-    def _operation_key(self, event):
-        # type: (Union[CommandFailedEvent, CommandStartedEvent, CommandSucceededEvent]) -> int
+    def _operation_key(
+        self,
+        event: Union[CommandFailedEvent, CommandStartedEvent, CommandSucceededEvent],
+    ) -> int:
         return event.request_id
 
-    def started(self, event):
-        # type: (CommandStartedEvent) -> None
+    def started(self, event: CommandStartedEvent) -> None:
         if sentry_sdk.get_client().get_integration(PyMongoIntegration) is None:
             return
 
@@ -172,8 +171,7 @@ class CommandTracer(monitoring.CommandListener):
 
             self._ongoing_operations[self._operation_key(event)] = span.__enter__()
 
-    def failed(self, event):
-        # type: (CommandFailedEvent) -> None
+    def failed(self, event: CommandFailedEvent) -> None:
         if sentry_sdk.get_client().get_integration(PyMongoIntegration) is None:
             return
 
@@ -184,8 +182,7 @@ class CommandTracer(monitoring.CommandListener):
         except KeyError:
             return
 
-    def succeeded(self, event):
-        # type: (CommandSucceededEvent) -> None
+    def succeeded(self, event: CommandSucceededEvent) -> None:
         if sentry_sdk.get_client().get_integration(PyMongoIntegration) is None:
             return
 
@@ -202,6 +199,5 @@ class PyMongoIntegration(Integration):
     origin = f"auto.db.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         monitoring.register(CommandTracer())