openlit 1.34.28__py3-none-any.whl → 1.34.29__py3-none-any.whl

openlit/instrumentation/openai/utils.py

@@ -22,6 +22,14 @@ from openlit.__helpers import (
 )
 from openlit.semcov import SemanticConvention
 
+def handle_not_given(value, default=None):
+    """
+    Handle OpenAI's NotGiven values by converting them to appropriate defaults.
+    """
+    if hasattr(value, '__class__') and value.__class__.__name__ == 'NotGiven':
+        return default
+    return value
+
 def format_content(messages):
     """
     Format the messages into a string for span events.
@@ -248,9 +256,15 @@ def common_response_logic(scope, pricing_info, environment, application_name, me
         environment, application_name, is_stream, scope._tbt, scope._ttft, version)
 
     # Span Attributes for Request parameters specific to responses API
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, scope._kwargs.get("temperature", 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, scope._kwargs.get("top_p", 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, scope._kwargs.get("max_output_tokens", -1))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, handle_not_given(scope._kwargs.get("temperature"), 1.0))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_TOP_P,
+        handle_not_given(scope._kwargs.get("top_p"), 1.0)
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,
+        handle_not_given(scope._kwargs.get("max_output_tokens"), -1)
+    )
 
     # Reasoning parameters
     reasoning = scope._kwargs.get("reasoning", {})
@@ -427,20 +441,30 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
     cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)
 
     # Common Span Attributes
-    common_span_attributes(scope,
-        SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-        scope._server_address, scope._server_port, request_model, scope._response_model,
-        environment, application_name, is_stream, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+        SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+        scope._server_address, scope._server_port, request_model,
+        scope._response_model, environment, application_name,
+        is_stream, scope._tbt, scope._ttft, version
+    )
 
     # Span Attributes for Request parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, str(scope._kwargs.get("seed", "")))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY, scope._kwargs.get("frequency_penalty", 0.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, scope._kwargs.get("max_tokens", -1))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY, scope._kwargs.get("presence_penalty", 0.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, scope._kwargs.get("stop", []))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, scope._kwargs.get("temperature", 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, scope._kwargs.get("top_p", 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, scope._kwargs.get("user", ""))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, str(handle_not_given(scope._kwargs.get("seed"), "")))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+        handle_not_given(scope._kwargs.get("frequency_penalty"), 0.0)
+    )
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, handle_not_given(scope._kwargs.get("max_tokens"), -1))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,
+        handle_not_given(scope._kwargs.get("presence_penalty"), 0.0)
+    )
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, handle_not_given(scope._kwargs.get("stop"), []))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, handle_not_given(scope._kwargs.get("temperature"), 1.0))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, handle_not_given(scope._kwargs.get("top_p"), 1.0))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Span Attributes for Response parameters
     scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id)
@@ -571,8 +595,11 @@ def common_embedding_logic(scope, request_model, pricing_info, environment, appl
         environment, application_name, False, scope._tbt, scope._ttft, version)
 
     # Span Attributes for Request parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_ENCODING_FORMATS, [scope._kwargs.get("encoding_format", "float")])
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, scope._kwargs.get("user", ""))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_ENCODING_FORMATS,
+        [handle_not_given(scope._kwargs.get("encoding_format"), "float")]
+    )
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Span Attributes for Cost and Tokens
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens)
@@ -611,9 +638,12 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
         environment, application_name, False, scope._tbt, scope._ttft, version)
 
     # Span Attributes for Request parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IMAGE_SIZE, scope._kwargs.get("size", "1024x1024"))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IMAGE_QUALITY, scope._kwargs.get("quality", "standard"))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, scope._kwargs.get("user", ""))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IMAGE_SIZE, handle_not_given(scope._kwargs.get("size"), "1024x1024"))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_IMAGE_QUALITY,
+        handle_not_given(scope._kwargs.get("quality"), "standard")
+    )
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Extract response data
     response_dict = scope._response_dict
@@ -709,9 +739,12 @@ def common_audio_logic(scope, request_model, pricing_info, environment, applicat
         environment, application_name, False, scope._tbt, scope._ttft, version)
 
     # Span Attributes for Request parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE, scope._kwargs.get("voice", "alloy"))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_RESPONSE_FORMAT, scope._kwargs.get("response_format", "mp3"))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_SPEED, scope._kwargs.get("speed", 1.0))
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE, handle_not_given(scope._kwargs.get("voice"), "alloy"))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_AUDIO_RESPONSE_FORMAT,
+        handle_not_given(scope._kwargs.get("response_format"), "mp3")
+    )
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_SPEED, handle_not_given(scope._kwargs.get("speed"), 1.0))
 
     # Span Attributes for Cost
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)

openlit/instrumentation/openai_agents/__init__.py

@@ -1,42 +1,62 @@
-"""Initializer of Auto Instrumentation of OpenAI Agents Functions"""
+"""
+OpenLIT OpenAI Agents Instrumentation - Native Tracing Integration
+"""
 
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.openai_agents.openai_agents import (
-    create_agent
-)
+from openlit.instrumentation.openai_agents.processor import OpenLITTracingProcessor
 
-_instruments = ('openai-agents >= 0.0.3',)
+_instruments = ("openai-agents >= 0.0.3",)
 
 class OpenAIAgentsInstrumentor(BaseInstrumentor):
-    """
-    An instrumentor for openai-agents's client library.
-    """
+    """OpenLIT instrumentor for OpenAI Agents using native tracing system"""
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs):
-        application_name = kwargs.get('application_name', 'default')
-        environment = kwargs.get('environment', 'default')
-        tracer = kwargs.get('tracer')
-        event_provider = kwargs.get('event_provider')
-        metrics = kwargs.get('metrics_dict')
-        pricing_info = kwargs.get('pricing_info', {})
-        capture_message_content = kwargs.get('capture_message_content', False)
-        disable_metrics = kwargs.get('disable_metrics')
-        version = importlib.metadata.version('openai-agents')
-
-        wrap_function_wrapper(
-            'agents.agent',
-            'Agent.__init__',
-            create_agent(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+        version = importlib.metadata.version("openai-agents")
+        environment = kwargs.get("environment", "default")
+        application_name = kwargs.get("application_name", "default")
+        tracer = kwargs.get("tracer")
+        pricing_info = kwargs.get("pricing_info", {})
+        capture_message_content = kwargs.get("capture_message_content", False)
+        metrics = kwargs.get("metrics_dict")
+        disable_metrics = kwargs.get("disable_metrics")
+        detailed_tracing = kwargs.get("detailed_tracing", False)
+
+        # Create our processor with OpenLIT enhancements
+        processor = OpenLITTracingProcessor(
+            tracer=tracer,
+            version=version,
+            environment=environment,
+            application_name=application_name,
+            pricing_info=pricing_info,
+            capture_message_content=capture_message_content,
+            metrics=metrics,
+            disable_metrics=disable_metrics,
+            detailed_tracing=detailed_tracing
         )
 
+        # Integrate with OpenAI Agents' native tracing system
+        try:
+            from agents import set_trace_processors
+            # Replace existing processors with our enhanced processor
+            set_trace_processors([processor])
+        except ImportError:
+            # Fallback: Add our processor to existing ones
+            try:
+                from agents import add_trace_processor
+                add_trace_processor(processor)
+            except ImportError:
+                pass  # Agents package may not have tracing
+
     def _uninstrument(self, **kwargs):
-        # Proper uninstrumentation logic to revert patched methods
-        pass
+        # Clear our processors
+        try:
+            from agents import set_trace_processors
+            set_trace_processors([])
+        except ImportError:
+            pass

openlit/instrumentation/openai_agents/processor.py

@@ -0,0 +1,600 @@
+"""
+OpenLIT OpenAI Agents Instrumentation - Native TracingProcessor Implementation
+"""
+
+import json
+import time
+from datetime import datetime
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+from opentelemetry import context as context_api
+from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_context
+from opentelemetry.context import detach
+
+from openlit.__helpers import (
+    common_framework_span_attributes,
+    handle_exception,
+    record_framework_metrics,
+    get_chat_model_cost
+)
+from openlit.semcov import SemanticConvention
+
+# Try to import agents framework components with fallback
+try:
+    from agents import TracingProcessor
+    if TYPE_CHECKING:
+        from agents import Trace, Span
+    TRACING_AVAILABLE = True
+except ImportError:
+    # Create dummy class for when agents is not available
+    class TracingProcessor:
+        """Dummy TracingProcessor class for when agents is not available"""
+
+        def force_flush(self):
+            """Dummy force_flush method"""
+            return None
+
+        def shutdown(self):
+            """Dummy shutdown method"""
+            return None
+
+    if TYPE_CHECKING:
+        # Type hints only - these don't exist at runtime when agents unavailable
+        Trace = Any
+        Span = Any
+
+    TRACING_AVAILABLE = False
+
+
+class OpenLITTracingProcessor(TracingProcessor):
+    """
+    OpenLIT processor that integrates with OpenAI Agents' native tracing system
+    Provides superior business intelligence while maintaining perfect hierarchy
+    """
+
+    def __init__(self, tracer: Any, version: str, environment: str,
+                 application_name: str, pricing_info: dict, capture_message_content: bool,
+                 metrics: Optional[Any], disable_metrics: bool, detailed_tracing: bool):
+        if not TRACING_AVAILABLE:
+            return
+
+        self._tracer = tracer
+        self._version = version
+        self._environment = environment
+        self._application_name = application_name
+        self._pricing_info = pricing_info
+        self._capture_message_content = capture_message_content
+        self._metrics = metrics
+        self._disable_metrics = disable_metrics
+        self._detailed_tracing = detailed_tracing
+
+        # Track spans for hierarchy
+        self._root_spans: Dict[str, Any] = {}
+        self._otel_spans: Dict[str, Any] = {}
+        self._tokens: Dict[str, object] = {}
+        self._span_start_times: Dict[str, float] = {}
+
+        # Track handoff context for better span naming
+        self._last_handoff_from: Optional[str] = None
+
+    def on_trace_start(self, trace: "Trace") -> None:
+        """Called when a trace is started - creates root workflow span"""
+        if not TRACING_AVAILABLE:
+            return
+
+        # Create root workflow span with {operation_type} {operation_name} format
+        workflow_name = getattr(trace, 'name', 'workflow')
+        span_name = f"agent {workflow_name}"  # Follow {operation_type} {operation_name} pattern
+
+        # Use tracer.start_span for TracingProcessor pattern with proper context
+        otel_span = self._tracer.start_span(
+            name=span_name,
+            kind=SpanKind.CLIENT
+        )
+
+        # Set common framework attributes for root span
+        self._set_common_attributes(otel_span, trace.trace_id)
+
+        # Set agent name for root span using semantic conventions
+        if hasattr(trace, 'name') and trace.name:
+            otel_span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, trace.name)
+
+        # Set default model for root span
+        otel_span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, "gpt-4o")
+
+        self._root_spans[trace.trace_id] = otel_span
+        self._span_start_times[trace.trace_id] = time.time()
+
+    def on_span_start(self, span: "Span[Any]") -> None:
+        """Called when a span is started - creates child spans with proper hierarchy"""
+        if not TRACING_AVAILABLE or not hasattr(span, 'started_at') or not span.started_at:
+            return
+
+        start_time = self._parse_timestamp(span.started_at)
+
+        # Determine parent span for proper hierarchy
+        parent_span = None
+        if span.parent_id and span.parent_id in self._otel_spans:
+            parent_span = self._otel_spans[span.parent_id]
+        elif span.trace_id in self._root_spans:
+            parent_span = self._root_spans[span.trace_id]
+
+        # Set context for parent-child relationship
+        context = set_span_in_context(parent_span) if parent_span else None
+
+        # Get semantic span name and operation type
+        span_name = self._get_span_name(span)
+        operation_type = self._get_operation_type(span.span_data)
+
+        # Create span with proper context
+        otel_span = self._tracer.start_span(
+            name=span_name,
+            context=context,
+            start_time=self._as_utc_nano(start_time),
+            kind=SpanKind.CLIENT
+        )
+
+        # Set common framework attributes for all spans
+        self._set_common_framework_attributes(otel_span, operation_type)
+
+        # Set span-specific attributes
+        self._set_span_attributes(otel_span, span)
+
+        # Track span and context
+        self._otel_spans[span.span_id] = otel_span
+        self._tokens[span.span_id] = context_api.attach(set_span_in_context(otel_span))
+        self._span_start_times[span.span_id] = time.time()
+
+    def on_span_end(self, span: "Span[Any]") -> None:
+        """Called when a span is finished - adds business intelligence and ends span"""
+        if not TRACING_AVAILABLE or span.span_id not in self._otel_spans:
+            return
+
+        otel_span = self._otel_spans[span.span_id]
+
+        try:
+            # Add response data and business intelligence
+            self._process_span_completion(otel_span, span)
+
+            # Set successful status
+            otel_span.set_status(Status(StatusCode.OK))
+
+            # Record metrics if enabled
+            if not self._disable_metrics and self._metrics and span.span_id in self._span_start_times:
+                start_time = self._span_start_times[span.span_id]
+                end_time = time.time()
+                operation_type = self._get_operation_type(span.span_data)
+                record_framework_metrics(
+                    self._metrics, operation_type, SemanticConvention.GEN_AI_SYSTEM_OPENAI_AGENTS,
+                    "localhost", 80, self._environment, self._application_name,
+                    start_time, end_time
+                )
+
+        except Exception as e:
+            handle_exception(otel_span, e)
+        finally:
+            # End span and cleanup
+            otel_span.end()
+
+            # Cleanup context
+            if span.span_id in self._tokens:
+                detach(self._tokens[span.span_id])
+                del self._tokens[span.span_id]
+
+            # Cleanup tracking
+            if span.span_id in self._otel_spans:
+                del self._otel_spans[span.span_id]
+            if span.span_id in self._span_start_times:
+                del self._span_start_times[span.span_id]
+
+    def on_trace_end(self, trace: "Trace") -> None:
+        """Called when a trace is finished - ends root span with business intelligence"""
+        if not TRACING_AVAILABLE or trace.trace_id not in self._root_spans:
+            return
+
+        root_span = self._root_spans[trace.trace_id]
+
+        try:
+            # Add trace-level business intelligence
+            self._process_trace_completion(root_span, trace)
+            root_span.set_status(Status(StatusCode.OK))
+        except Exception as e:
+            handle_exception(root_span, e)
+        finally:
+            root_span.end()
+
+            # Cleanup
+            if trace.trace_id in self._root_spans:
+                del self._root_spans[trace.trace_id]
+            if trace.trace_id in self._span_start_times:
+                del self._span_start_times[trace.trace_id]
+
+    def _get_span_name(self, span: "Span[Any]") -> str:
+        """Get semantic span name using {operation_type} {operation_name} format"""
+        data = span.span_data
+        operation_type = self._get_operation_type(data)
+
+        # Extract operation name based on span type
+        operation_name = "unknown"
+
+        # Special handling for handoffs
+        if hasattr(data, '__class__') and data.__class__.__name__ == 'HandoffSpanData':
+            if hasattr(data, 'to_agent') and data.to_agent:
+                operation_name = f"to {data.to_agent}"
+            else:
+                operation_name = "handoff"
+
+        # Use agent name for agent spans
+        elif hasattr(data, '__class__') and data.__class__.__name__ == 'AgentSpanData':
+            # Try multiple possible attribute names for agent name
+            agent_name = None
+
+            for attr in ['agent_name', 'name', 'agent', 'agent_id']:
+                if hasattr(data, attr):
+                    agent_name = getattr(data, attr)
+                    if agent_name and isinstance(agent_name, str):
+                        break
+
+            # If still no agent name, try looking in context or other attributes
+            if not agent_name:
+                # Try context or other nested attributes
+                if hasattr(data, 'context') and hasattr(data.context, 'agent'):
+                    agent_name = getattr(data.context.agent, 'name', None)
+                elif hasattr(data, 'metadata') and hasattr(data.metadata, 'agent_name'):
+                    agent_name = data.metadata.agent_name
+
+            if agent_name:
+                operation_name = agent_name
+            else:
+                # If no agent name found, use a more descriptive fallback
+                operation_name = "execution"
+
+        # Use name if available for other spans
+        elif hasattr(data, 'name') and isinstance(data.name, str):
+            operation_name = data.name
+
+        # Fallback to type-based names
+        else:
+            operation_name = getattr(data, 'type', 'operation')
+
+        # Return formatted name: {operation_type} {operation_name}
+        return f"{operation_type} {operation_name}"
+
+    def _get_operation_type(self, data: Any) -> str:
+        """Map span data to operation types"""
+        class_name = data.__class__.__name__ if hasattr(data, '__class__') else str(type(data))
+
+        mapping = {
+            'AgentSpanData': SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+            'GenerationSpanData': SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+            'FunctionSpanData': SemanticConvention.GEN_AI_OPERATION_TYPE_TOOLS,
+            'HandoffSpanData': SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+            'ResponseSpanData': SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+        }
+
+        return mapping.get(class_name, SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)
+
+    def _set_common_framework_attributes(self, span: Any, operation_type: str) -> None:
+        """Set common framework attributes using semantic conventions"""
+        # Create scope object for common_framework_span_attributes
+        scope = type("GenericScope", (), {})()
+        scope._span = span
+        scope._start_time = time.time()
+        scope._end_time = time.time()
+
+        # Use common framework attributes helper
+        # For framework operations, use localhost like other agent frameworks (AG2, Pydantic AI)
+        common_framework_span_attributes(
+            scope, SemanticConvention.GEN_AI_SYSTEM_OPENAI_AGENTS,
+            "localhost", 80, self._environment, self._application_name,
+            self._version, operation_type, None
+        )
+
+    def _set_common_attributes(self, span: Any, trace_id: str) -> None:
+        """Set common framework attributes for root spans"""
+        self._set_common_framework_attributes(span, SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)
+
+    def _set_span_attributes(self, span: Any, agent_span: "Span[Any]") -> None:
+        """Set span-specific attributes based on span data using semantic conventions"""
+        data = agent_span.span_data
+
+        # Agent-specific attributes using semantic conventions
+        if hasattr(data, 'agent_name') and data.agent_name:
+            span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, data.agent_name)
+        elif hasattr(data, 'name') and data.name:
+            span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, data.name)
+
+        # Enhanced model information extraction
+        model = self._extract_model_info(data, agent_span)
+        if model:
+            span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, str(model))
+
+        # Enhanced input/output capture with MIME types (OpenLIT enhancement)
+        if self._capture_message_content:
+            self._capture_input_output(span, data)
+
+        # Enhanced token usage details (inspired by OpenInference)
+        self._capture_detailed_token_usage(span, data)
+
+        # Model invocation parameters as JSON (new feature from OpenInference)
+        self._capture_model_parameters(span, data)
+
+        # Tool/function information for tool calls
+        if hasattr(data, '__class__') and 'Function' in data.__class__.__name__:
+            if hasattr(data, 'function_name'):
+                span.set_attribute(SemanticConvention.GEN_AI_TOOL_NAME, data.function_name)
+            if hasattr(data, 'arguments'):
+                span.set_attribute(SemanticConvention.GEN_AI_TOOL_ARGS, str(data.arguments))
+
+        # Enhanced handoff information extraction
+        if hasattr(data, '__class__') and 'Handoff' in data.__class__.__name__:
+            target_agent = self._extract_handoff_target(data, agent_span)
+            if target_agent:
+                span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, target_agent)
+            else:
+                # Fallback for handoff spans without clear target
+                span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, "agent handoff")
+
+        # Request/response IDs if available
+        if hasattr(data, 'request_id'):
+            span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, data.request_id)
+        elif hasattr(data, 'response_id'):
+            span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, data.response_id)
+
+    def _extract_model_info(self, data: Any, agent_span: "Span[Any]") -> Optional[str]:
+        """Extract model information from span data or agent configuration"""
+        # Try direct model attributes first
+        model_attrs = ['model', 'model_name', 'model_id', 'llm_model', 'openai_model']
+
+        model = self._check_model_attrs(data, model_attrs)
+        if model:
+            return model
+
+        # Try nested configuration objects
+        config_attrs = ['config', 'configuration', 'client_config', 'llm_config']
+        model = self._check_config_model_attrs(data, config_attrs, model_attrs)
+        if model:
+            return model
+
+        # Try looking in the agent span itself
+        if hasattr(agent_span, 'model'):
+            return str(agent_span.model)
+
+        # Try agent_config if available
+        if hasattr(agent_span, 'agent_config'):
+            model = self._check_model_attrs(agent_span.agent_config, model_attrs)
+            if model:
+                return model
+
+        # Default fallback
+        return "gpt-4o"
+
+    def _check_model_attrs(self, obj: Any, model_attrs: list) -> Optional[str]:
+        """Helper method to check model attributes on an object"""
+        for attr in model_attrs:
+            if not hasattr(obj, attr):
+                continue
+            model_value = getattr(obj, attr)
+            if model_value and isinstance(model_value, str):
+                return model_value
+        return None
+
+    def _check_config_model_attrs(self, data: Any, config_attrs: list, model_attrs: list) -> Optional[str]:
+        """Helper method to check model attributes in nested configuration objects"""
+        for config_attr in config_attrs:
+            if not hasattr(data, config_attr):
+                continue
+            config = getattr(data, config_attr)
+            if not config:
+                continue
+            model = self._check_model_attrs(config, model_attrs)
+            if model:
+                return model
+        return None
+
+    def _extract_handoff_target(self, data: Any, agent_span: "Span[Any]") -> Optional[str]:
+        """Extract handoff target information with enhanced logic"""
+        # Try direct target attributes
+        target_attrs = ['to_agent', 'target_agent', 'destination_agent', 'next_agent']
+        for attr in target_attrs:
+            if hasattr(data, attr):
+                target = getattr(data, attr)
+                if target and isinstance(target, str):
+                    return f"to {target}"
+
+        # Try from_agent for better handoff description
+        from_attrs = ['from_agent', 'source_agent', 'previous_agent']
+        for attr in from_attrs:
+            if hasattr(data, attr):
+                source = getattr(data, attr)
+                if source and isinstance(source, str):
+                    return f"from {source}"
+
+        # Try nested objects
+        if hasattr(data, 'handoff_info'):
+            info = data.handoff_info
+            for attr in target_attrs + from_attrs:
+                if hasattr(info, attr):
+                    value = getattr(info, attr)
+                    if value and isinstance(value, str):
+                        prefix = "to" if attr in target_attrs else "from"
+                        return f"{prefix} {value}"
+
+        return None
+
+    def _capture_input_output(self, span: Any, data: Any) -> None:
+        """Capture input/output content with MIME type detection (OpenLIT enhancement)"""
+        try:
+            # Capture input content
+            if hasattr(data, 'input') and data.input is not None:
+                content = str(data.input)
+                span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, content)
+                # Set MIME type based on content structure
+                if content.startswith('{') or content.startswith('['):
+                    span.set_attribute("gen_ai.content.prompt.mime_type", "application/json")
+                else:
+                    span.set_attribute("gen_ai.content.prompt.mime_type", "text/plain")
+
+            # Capture output/response content
+            if hasattr(data, 'response') and data.response is not None:
+                content = str(data.response)
+                span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, content)
+                # Set MIME type based on content structure
+                if content.startswith('{') or content.startswith('['):
+                    span.set_attribute("gen_ai.content.completion.mime_type", "application/json")
+                else:
+                    span.set_attribute("gen_ai.content.completion.mime_type", "text/plain")
+
+        except Exception:
+            pass  # Ignore export errors
+
+    def _capture_detailed_token_usage(self, span: Any, data: Any) -> None:
+        """Capture detailed token usage information (inspired by OpenInference)"""
+        try:
+            if hasattr(data, 'usage'):
+                usage = data.usage
+
+                # Standard token usage
+                if hasattr(usage, 'input_tokens'):
+                    span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
+                if hasattr(usage, 'output_tokens'):
+                    span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, usage.output_tokens)
+
+                # Enhanced token details (when available)
+                if hasattr(usage, 'input_tokens_details'):
+                    details = usage.input_tokens_details
+                    if hasattr(details, 'cached_tokens'):
+                        span.set_attribute("gen_ai.usage.input_tokens.cached", details.cached_tokens)
+                    if hasattr(details, 'reasoning_tokens'):
+                        span.set_attribute("gen_ai.usage.input_tokens.reasoning", details.reasoning_tokens)
+
+                if hasattr(usage, 'output_tokens_details'):
+                    details = usage.output_tokens_details
+                    if hasattr(details, 'reasoning_tokens'):
+                        span.set_attribute("gen_ai.usage.output_tokens.reasoning", details.reasoning_tokens)
+
+        except Exception:
+            pass  # Ignore export errors
+
+    def _capture_model_parameters(self, span: Any, data: Any) -> None:
+        """Capture model invocation parameters as JSON (new feature from OpenInference)"""
+        try:
+            # Look for model configuration parameters
+            params = {}
+
+            # Common parameter attributes
+            param_attrs = ['temperature', 'max_tokens', 'top_p', 'frequency_penalty', 'presence_penalty']
+            for attr in param_attrs:
+                if hasattr(data, attr):
+                    params[attr] = getattr(data, attr)
+
+            # Try nested config objects
+            if hasattr(data, 'config'):
+                config = data.config
+                for attr in param_attrs:
+                    if hasattr(config, attr):
+                        params[attr] = getattr(config, attr)
+
+            # Try response object if available
+            if hasattr(data, 'response') and hasattr(data.response, 'model_dump'):
+                try:
+                    response_dict = data.response.model_dump()
+                    if response_dict and isinstance(response_dict, dict):
+                        # Extract model parameters from response
+                        if 'model' in response_dict:
+                            params['model'] = response_dict['model']
+                        if 'usage' in response_dict:
+                            params['usage'] = response_dict['usage']
+                except Exception:
+                    pass
+
+            # Set as JSON if we found any parameters
+            if params:
+                span.set_attribute("gen_ai.request.parameters", json.dumps(params))
+
+        except Exception:
+            pass  # Ignore export errors
+
+    def _process_span_completion(self, span: Any, agent_span: "Span[Any]") -> None:
+        """Process span completion with enhanced business intelligence"""
+        data = agent_span.span_data
+
+        # Process response data if available
+        self._process_response_data(span, data)
+
+        # Extract and set token usage for business intelligence
+        self._extract_token_usage(span, data)
+
+    def _extract_token_usage(self, span: Any, data: Any) -> None:
+        """Extract token usage and calculate costs (OpenLIT's business intelligence)"""
+        try:
+            # Try to extract token usage from various possible locations
+            input_tokens = 0
+            output_tokens = 0
+
+            # Check direct usage attributes
+            if hasattr(data, 'usage'):
+                usage = data.usage
+                input_tokens = getattr(usage, 'input_tokens', 0) or getattr(usage, 'prompt_tokens', 0)
+                output_tokens = getattr(usage, 'output_tokens', 0) or getattr(usage, 'completion_tokens', 0)
+
+            # Check response object
+            elif hasattr(data, 'response') and hasattr(data.response, 'usage'):
+                usage = data.response.usage
+                input_tokens = getattr(usage, 'input_tokens', 0) or getattr(usage, 'prompt_tokens', 0)
+                output_tokens = getattr(usage, 'output_tokens', 0) or getattr(usage, 'completion_tokens', 0)
+
+            # Set token attributes
+            span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+            span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+            span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens)
+
+            # Calculate cost (OpenLIT's business intelligence advantage)
+            model = getattr(data, 'model', 'gpt-4o')
+            cost = get_chat_model_cost(model, self._pricing_info, input_tokens, output_tokens)
+            span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
+
+        except Exception:
+            pass  # Ignore errors in token usage extraction
+
+    def _process_response_data(self, span: Any, data: Any) -> None:
+        """Process response data with content capture"""
+        if self._capture_message_content:
+            self._capture_input_output(span, data)
+
+    def _process_trace_completion(self, span: Any, trace: "Trace") -> None:
+        """Process trace completion with business intelligence aggregation"""
+        # Add trace-level metadata
+        span.set_attribute(SemanticConvention.GEN_AI_OPERATION_NAME, "workflow")
+
+        # Calculate total duration
+        if trace.trace_id in self._span_start_times:
+            start_time = self._span_start_times[trace.trace_id]
+            duration = time.time() - start_time
+            span.set_attribute(SemanticConvention.GEN_AI_CLIENT_OPERATION_DURATION, duration)
+
+    def _parse_timestamp(self, timestamp: Any) -> float:
+        """Parse timestamp from various formats"""
+        if isinstance(timestamp, (int, float)):
+            return float(timestamp)
+        elif isinstance(timestamp, str):
+            try:
+                # Try parsing ISO format
+                dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                return dt.timestamp()
+            except ValueError:
+                return time.time()
+        else:
+            return time.time()
+
+    def _as_utc_nano(self, timestamp: float) -> int:
+        """Convert timestamp to UTC nanoseconds for OpenTelemetry"""
+        return int(timestamp * 1_000_000_000)
+
+    def force_flush(self) -> bool:
+        """Force flush any pending spans (required by TracingProcessor)"""
+        return True
+
+    def shutdown(self) -> bool:
+        """Shutdown the processor (required by TracingProcessor)"""
+        return True

openlit/semcov/__init__.py

@@ -135,6 +135,7 @@ class SemanticConvention:
     GEN_AI_SYSTEM_FIRECRAWL = "firecrawl"
     GEN_AI_SYSTEM_LETTA = "letta"
     GEN_AI_SYSTEM_TOGETHER = "together"
+    GEN_AI_SYSTEM_OPENAI_AGENTS = "openai_agents"
     GEN_AI_SYSTEM_PYDANTIC_AI = "pydantic_ai"
 
     # GenAI Framework Component Attributes (Standard)

{openlit-1.34.28.dist-info → openlit-1.34.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openlit
-Version: 1.34.28
+Version: 1.34.29
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects
 License: Apache-2.0
 Keywords: OpenTelemetry,otel,otlp,llm,tracing,openai,anthropic,claude,cohere,llm monitoring,observability,monitoring,gpt,Generative AI,chatGPT,gpu
@@ -18,6 +18,7 @@ Requires-Dist: anthropic (>=0.42.0,<1.0.0)
 Requires-Dist: boto3 (>=1.34.0,<2.0.0)
 Requires-Dist: botocore (>=1.34.0,<2.0.0)
 Requires-Dist: openai (>=1.1.1,<2.0.0)
+Requires-Dist: openai-agents (>=0.0.3)
 Requires-Dist: opentelemetry-api (>=1.30.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp (>=1.30.0,<2.0.0)
 Requires-Dist: opentelemetry-instrumentation (>=0.52b0,<1.0.0)

{openlit-1.34.28.dist-info → openlit-1.34.29.dist-info}/RECORD

@@ -119,9 +119,9 @@ openlit/instrumentation/ollama/utils.py,sha256=TIE3_ur2U-iyCclna7TzwjDIFC9PZjRnZ
 openlit/instrumentation/openai/__init__.py,sha256=4RWRhrRa589jiwvFf8_fLBW6UB5Btrd17mcDKv5VhJk,5546
 openlit/instrumentation/openai/async_openai.py,sha256=QvEEKZnZYl9Vf-wsX1voTMMZed1eNhRI9aUT8CtFJi0,18003
 openlit/instrumentation/openai/openai.py,sha256=34_FqOwSroNOm_mmLzZb8Y7xtr5StwnUyRQmHP6HHJc,17698
-openlit/instrumentation/openai/utils.py,sha256=dd57s93nBSbl4OUjkkoC6QuEGXVC_2XOf2C7Hs1eEww,35555
-openlit/instrumentation/openai_agents/__init__.py,sha256=tRTSIrUtkXc_lfQnVanXmQLd2Sy9RqBNTHF5FhhZx7o,1530
-openlit/instrumentation/openai_agents/openai_agents.py,sha256=kRWPgjofcOviMi3w7CsRvJO3SCjqPmuq-PM800vIM7g,2678
+openlit/instrumentation/openai/utils.py,sha256=um8ReamuvmgpKDd6Xr32PGjeWejD8M8e7yzL5P_soBM,36340
+openlit/instrumentation/openai_agents/__init__.py,sha256=0CkxeGyUJcucDegogDtw_lKsA0drQogzwtgyBVmasIE,2351
+openlit/instrumentation/openai_agents/processor.py,sha256=7hHM8OuIwLwfCfEBZQlqaHKXUdTkiiZz23JppwsnXxw,25860
 openlit/instrumentation/phidata/__init__.py,sha256=tqls5-UI6FzbjxYgq_qqAfALhWJm8dHn2NtgqiQA4f8,1557
 openlit/instrumentation/phidata/phidata.py,sha256=ohrxs6i0Oik75P2BrjNGbK71tdZg94ZMmaXixrXwV5M,4834
 openlit/instrumentation/pinecone/__init__.py,sha256=-3wD35oCnwjwBQV3-gZs2XgpZ2wT9jmiMGjalpF9BhI,3683
@@ -159,8 +159,8 @@ openlit/instrumentation/vllm/vllm.py,sha256=VzazF2f4LLwjZDO_G8lIN_d622oSJM0fIO9w
 openlit/otel/events.py,sha256=VrMjTpvnLtYRBHCiFwJojTQqqNpRCxoD4yJYeQrtPsk,3560
 openlit/otel/metrics.py,sha256=GM2PDloBGRhBTkHHkYaqmOwIAQkY124ZhW4sEqW1Fgk,7086
 openlit/otel/tracing.py,sha256=tjV2bEbEDPUB1Z46gE-UsJsb04sRdFrfbhIDkxViZc0,3103
-openlit/semcov/__init__.py,sha256=2yvcsK4l9fs7QL8pOqogg0O-KDTEfb5lFd6J6ySlpjM,18657
-openlit-1.34.28.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.34.28.dist-info/METADATA,sha256=q5cGfMlB4KgoPFDOLlevkxaMizvCr2zfBx_4b4-epN4,23470
-openlit-1.34.28.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-openlit-1.34.28.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=V1nmtUWyXVydBzCRUYknwpVlPxThZIP64VKiedd9e8A,18707
+openlit-1.34.29.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.34.29.dist-info/METADATA,sha256=MTEXtKUMyUJ6AjDFY7MQMx_r75J38RaTSj7uWdG0G9E,23509
+openlit-1.34.29.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+openlit-1.34.29.dist-info/RECORD,,

openlit/instrumentation/openai_agents/openai_agents.py

@@ -1,65 +0,0 @@
-"""
-Module for monitoring AG2 API calls.
-"""
-
-import logging
-from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
-from openlit.__helpers import (
-    handle_exception,
-)
-from openlit.semcov import SemanticConvention
-
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
-
-def set_span_attributes(span, version, operation_name, environment,
-        application_name, server_address, server_port, request_model):
-    """
-    Set common attributes for the span.
-    """
-
-    # Set Span attributes (OTel Semconv)
-    span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')
-    span.set_attribute(SemanticConvention.GEN_AI_OPERATION, operation_name)
-    span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_AG2)
-    span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
-    span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
-    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
-
-    # Set Span attributes (Extras)
-    span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
-    span.set_attribute(SERVICE_NAME, application_name)
-    span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
-
-def create_agent(version, environment, application_name,
-                      tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics):
-    """
-    Generates a telemetry wrapper for GenAI function call
-    """
-    def wrapper(wrapped, instance, args, kwargs):
-        server_address, server_port = '127.0.0.1', 80
-
-        agent_name = kwargs.get('name', 'openai_agent')
-        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT} {agent_name}'
-
-        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
-            try:
-                response = wrapped(*args, **kwargs)
-
-                set_span_attributes(span, version, SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT,
-                    environment, application_name, server_address, server_port, kwargs.get('model', 'gpt-4o'))
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, agent_name)
-
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_DESCRIPTION, kwargs.get('instructions', ''))
-
-                span.set_status(Status(StatusCode.OK))
-
-                return response
-
-            except Exception as e:
-                handle_exception(span, e)
-                logger.error('Error in trace creation: %s', e)
-                return response
-
-    return wrapper