attributes on chat completion

Author: antonpirker

sentry_sdk/consts.py

@@ -417,7 +417,7 @@ class SPANDATA:
     GEN_AI_REQUEST_MODEL = "gen_ai.request.model"
     """
     The model identifier being used for the request.
-    Example: "gpt-4-turbo-preview"
+    Example: "gpt-4-turbo"
     """
 
     GEN_AI_REQUEST_PRESENCE_PENALTY = "gen_ai.request.presence_penalty"

sentry_sdk/integrations/openai.py

@@ -11,6 +11,7 @@
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
+    safe_serialize,
 )
 
 from typing import TYPE_CHECKING
@@ -183,24 +184,50 @@ def _new_chat_completion_common(f, *args, **kwargs):
     )
     span.__enter__()
 
+    # Common attributes
+    set_data_normalized(span, SPANDATA.GEN_AI_SYSTEM, "openai")
+    set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_MODEL, model)
+    set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, "chat")
+    set_data_normalized(span, SPANDATA.AI_STREAMING, streaming)
+
+    # Optional attributes
+    max_tokens = kwargs.get("max_tokens")
+    if max_tokens is not None:
+        set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, max_tokens)
+
+    presence_penalty = kwargs.get("presence_penalty")
+    if presence_penalty is not None:
+        set_data_normalized(
+            span, SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty
+        )
+
+    temperature = kwargs.get("temperature")
+    if temperature is not None:
+        set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_TEMPERATURE, temperature)
+
+    top_p = kwargs.get("top_p")
+    if top_p is not None:
+        set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_TOP_P, top_p)
+
     res = yield f, args, kwargs
 
     with capture_internal_exceptions():
         if should_send_default_pii() and integration.include_prompts:
             set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_MESSAGES, messages)
 
-        set_data_normalized(span, SPANDATA.GEN_AI_SYSTEM, "openai")
-        set_data_normalized(span, SPANDATA.GEN_AI_REQUEST_MODEL, model)
-        set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, "chat")
-        set_data_normalized(span, SPANDATA.AI_STREAMING, streaming)
+        if hasattr(res, "model"):
+            set_data_normalized(span, SPANDATA.GEN_AI_RESPONSE_MODEL, res.model)
 
         if hasattr(res, "choices"):
             if should_send_default_pii() and integration.include_prompts:
-                set_data_normalized(
-                    span,
-                    SPANDATA.GEN_AI_RESPONSE_TEXT,
-                    list(map(lambda x: x.message, res.choices)),
-                )
+                response_text = [choice.message.dict() for choice in res.choices]
+                if len(response_text) > 0:
+                    set_data_normalized(
+                        span,
+                        SPANDATA.GEN_AI_RESPONSE_TEXT,
+                        safe_serialize(response_text),
+                    )
+
             _calculate_token_usage(messages, res, span, None, integration.count_tokens)
             span.__exit__(None, None, None)
         elif hasattr(res, "_iterator"):

sentry_sdk/integrations/openai_agents/utils.py

@@ -1,16 +1,14 @@
-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 sentry_sdk.utils import event_from_exception, safe_serialize
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any
     from typing import Callable
-    from typing import Union
     from agents import Usage
 
 try:
@@ -162,49 +160,3 @@ def _set_output_data(span, result):
         span.set_data(
             SPANDATA.GEN_AI_RESPONSE_TEXT, safe_serialize(output_messages["response"])
         )
-
-
-def safe_serialize(data):
-    # type: (Any) -> str
-    """Safely serialize to a readable string."""
-
-    def serialize_item(item):
-        # type: (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/utils.py

@@ -1938,3 +1938,49 @@ def try_convert(convert_func, value):
         return convert_func(value)
     except Exception:
         return None
+
+
+def safe_serialize(data):
+    # type: (Any) -> str
+    """Safely serialize to a readable string."""
+
+    def serialize_item(item):
+        # type: (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)