sentry-sdk 3.0.0a2__py2.py3-none-any.whl → 3.0.0a4__py2.py3-none-any.whl

sentry_sdk/integrations/openai_agents/utils.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+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, safe_serialize
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+    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"])
+        )

sentry_sdk/integrations/openfeature.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
 
 from sentry_sdk.feature_flags import add_feature_flag
 from sentry_sdk.integrations import DidNotEnable, Integration
@@ -8,7 +9,6 @@ try:
     from openfeature.hook import Hook
 
     if TYPE_CHECKING:
-        from openfeature.flag_evaluation import FlagEvaluationDetails
         from openfeature.hook import HookContext, HookHints
 except ImportError:
     raise DidNotEnable("OpenFeature is not installed")
@@ -18,20 +18,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: Any,
+        details: Any,
+        hints: Any,
+    ) -> 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
 
@@ -153,7 +152,7 @@ class CommandTracer(monitoring.CommandListener):
                 op=OP.DB,
                 name=query,
                 origin=PyMongoIntegration.origin,
-                only_if_parent=True,
+                only_as_child_span=True,
             )
 
             with capture_internal_exceptions():
@@ -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())

sentry_sdk/integrations/pyramid.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import os
 import sys
@@ -40,8 +41,7 @@ if TYPE_CHECKING:
 
 if getattr(Request, "authenticated_userid", None):
 
-    def authenticated_userid(request):
-        # type: (Request) -> Optional[Any]
+    def authenticated_userid(request: Request) -> Optional[Any]:
         return request.authenticated_userid
 
 else:
@@ -58,8 +58,7 @@ class PyramidIntegration(Integration):
 
     transaction_style = ""
 
-    def __init__(self, transaction_style="route_name"):
-        # type: (str) -> None
+    def __init__(self, transaction_style: str = "route_name") -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -68,15 +67,15 @@ class PyramidIntegration(Integration):
         self.transaction_style = transaction_style
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         from pyramid import router
 
         old_call_view = router._call_view
 
         @functools.wraps(old_call_view)
-        def sentry_patched_call_view(registry, request, *args, **kwargs):
-            # type: (Any, Request, *Any, **Any) -> Response
+        def sentry_patched_call_view(
+            registry: Any, request: Request, *args: Any, **kwargs: Any
+        ) -> Response:
             integration = sentry_sdk.get_client().get_integration(PyramidIntegration)
             if integration is None:
                 return old_call_view(registry, request, *args, **kwargs)
@@ -96,8 +95,9 @@ class PyramidIntegration(Integration):
         if hasattr(Request, "invoke_exception_view"):
             old_invoke_exception_view = Request.invoke_exception_view
 
-            def sentry_patched_invoke_exception_view(self, *args, **kwargs):
-                # type: (Request, *Any, **Any) -> Any
+            def sentry_patched_invoke_exception_view(
+                self: Request, *args: Any, **kwargs: Any
+            ) -> Any:
                 rv = old_invoke_exception_view(self, *args, **kwargs)
 
                 if (
@@ -116,10 +116,12 @@ class PyramidIntegration(Integration):
         old_wsgi_call = router.Router.__call__
 
         @ensure_integration_enabled(PyramidIntegration, old_wsgi_call)
-        def sentry_patched_wsgi_call(self, environ, start_response):
-            # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
-            def sentry_patched_inner_wsgi_call(environ, start_response):
-                # type: (Dict[str, Any], Callable[..., Any]) -> Any
+        def sentry_patched_wsgi_call(
+            self: Any, environ: Dict[str, str], start_response: Callable[..., Any]
+        ) -> _ScopedResponse:
+            def sentry_patched_inner_wsgi_call(
+                environ: Dict[str, Any], start_response: Callable[..., Any]
+            ) -> Any:
                 try:
                     return old_wsgi_call(self, environ, start_response)
                 except Exception:
@@ -137,8 +139,7 @@ class PyramidIntegration(Integration):
 
 
 @ensure_integration_enabled(PyramidIntegration)
-def _capture_exception(exc_info):
-    # type: (ExcInfo) -> None
+def _capture_exception(exc_info: ExcInfo) -> None:
     if exc_info[0] is None or issubclass(exc_info[0], HTTPException):
         return
 
@@ -151,8 +152,9 @@ def _capture_exception(exc_info):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Request) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Request
+) -> None:
     try:
         name_for_style = {
             "route_name": request.matched_route.name,
@@ -167,40 +169,33 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
 
 
 class PyramidRequestExtractor(RequestExtractor):
-    def url(self):
-        # type: () -> str
+    def url(self) -> str:
         return self.request.path_url
 
-    def env(self):
-        # type: () -> Dict[str, str]
+    def env(self) -> Dict[str, str]:
         return self.request.environ
 
-    def cookies(self):
-        # type: () -> RequestCookies
+    def cookies(self) -> RequestCookies:
         return self.request.cookies
 
-    def raw_data(self):
-        # type: () -> str
+    def raw_data(self) -> str:
         return self.request.text
 
-    def form(self):
-        # type: () -> Dict[str, str]
+    def form(self) -> Dict[str, str]:
         return {
             key: value
             for key, value in self.request.POST.items()
             if not getattr(value, "filename", None)
         }
 
-    def files(self):
-        # type: () -> Dict[str, _FieldStorageWithFile]
+    def files(self) -> Dict[str, _FieldStorageWithFile]:
         return {
             key: value
             for key, value in self.request.POST.items()
             if getattr(value, "filename", None)
         }
 
-    def size_of_file(self, postdata):
-        # type: (_FieldStorageWithFile) -> int
+    def size_of_file(self, postdata: _FieldStorageWithFile) -> int:
         file = postdata.file
         try:
             return os.fstat(file.fileno()).st_size
@@ -208,10 +203,10 @@ class PyramidRequestExtractor(RequestExtractor):
             return 0
 
 
-def _make_event_processor(weak_request, integration):
-    # type: (Callable[[], Request], PyramidIntegration) -> EventProcessor
-    def pyramid_event_processor(event, hint):
-        # type: (Event, Dict[str, Any]) -> Event
+def _make_event_processor(
+    weak_request: Callable[[], Request], integration: PyramidIntegration
+) -> EventProcessor:
+    def pyramid_event_processor(event: Event, hint: Dict[str, Any]) -> Event:
         request = weak_request()
         if request is None:
             return event

sentry_sdk/integrations/quart.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import asyncio
 import inspect
 from functools import wraps
@@ -60,8 +61,7 @@ class QuartIntegration(Integration):
 
     transaction_style = ""
 
-    def __init__(self, transaction_style="endpoint"):
-        # type: (str) -> None
+    def __init__(self, transaction_style: str = "endpoint") -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -70,8 +70,7 @@ class QuartIntegration(Integration):
         self.transaction_style = transaction_style
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         request_started.connect(_request_websocket_started)
         websocket_started.connect(_request_websocket_started)
@@ -83,12 +82,12 @@ class QuartIntegration(Integration):
         patch_scaffold_route()
 
 
-def patch_asgi_app():
-    # type: () -> None
+def patch_asgi_app() -> None:
     old_app = Quart.__call__
 
-    async def sentry_patched_asgi_app(self, scope, receive, send):
-        # type: (Any, Any, Any, Any) -> Any
+    async def sentry_patched_asgi_app(
+        self: Any, scope: Any, receive: Any, send: Any
+    ) -> Any:
         if sentry_sdk.get_client().get_integration(QuartIntegration) is None:
             return await old_app(self, scope, receive, send)
 
@@ -102,16 +101,13 @@ def patch_asgi_app():
     Quart.__call__ = sentry_patched_asgi_app
 
 
-def patch_scaffold_route():
-    # type: () -> None
+def patch_scaffold_route() -> None:
     old_route = Scaffold.route
 
-    def _sentry_route(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _sentry_route(*args: Any, **kwargs: Any) -> Any:
         old_decorator = old_route(*args, **kwargs)
 
-        def decorator(old_func):
-            # type: (Any) -> Any
+        def decorator(old_func: Any) -> Any:
 
             if inspect.isfunction(old_func) and not asyncio.iscoroutinefunction(
                 old_func
@@ -119,8 +115,7 @@ def patch_scaffold_route():
 
                 @wraps(old_func)
                 @ensure_integration_enabled(QuartIntegration, old_func)
-                def _sentry_func(*args, **kwargs):
-                    # type: (*Any, **Any) -> Any
+                def _sentry_func(*args: Any, **kwargs: Any) -> Any:
                     current_scope = sentry_sdk.get_current_scope()
                     if current_scope.root_span is not None:
                         current_scope.root_span.update_active_thread()
@@ -140,8 +135,9 @@ def patch_scaffold_route():
     Scaffold.route = _sentry_route
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Request) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Request
+) -> None:
 
     try:
         name_for_style = {
@@ -156,8 +152,7 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         pass
 
 
-async def _request_websocket_started(app, **kwargs):
-    # type: (Quart, **Any) -> None
+async def _request_websocket_started(app: Quart, **kwargs: Any) -> None:
     integration = sentry_sdk.get_client().get_integration(QuartIntegration)
     if integration is None:
         return
@@ -178,10 +173,10 @@ async def _request_websocket_started(app, **kwargs):
     scope.add_event_processor(evt_processor)
 
 
-def _make_request_event_processor(app, request, integration):
-    # type: (Quart, Request, QuartIntegration) -> EventProcessor
-    def inner(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_request_event_processor(
+    app: Quart, request: Request, integration: QuartIntegration
+) -> EventProcessor:
+    def inner(event: Event, hint: dict[str, Any]) -> Event:
         # if the request is gone we are fine not logging the data from
         # it.  This might happen if the processor is pushed away to
         # another thread.
@@ -207,8 +202,9 @@ def _make_request_event_processor(app, request, integration):
     return inner
 
 
-async def _capture_exception(sender, exception, **kwargs):
-    # type: (Quart, Union[ValueError, BaseException], **Any) -> None
+async def _capture_exception(
+    sender: Quart, exception: Union[ValueError, BaseException], **kwargs: Any
+) -> None:
     integration = sentry_sdk.get_client().get_integration(QuartIntegration)
     if integration is None:
         return
@@ -222,8 +218,7 @@ async def _capture_exception(sender, exception, **kwargs):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _add_user_to_event(event):
-    # type: (Event) -> None
+def _add_user_to_event(event: Event) -> None:
     if quart_auth is None:
         return