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

openlit/instrumentation/openai_agents/processor.py

@@ -2,19 +2,14 @@
 OpenLIT OpenAI Agents Instrumentation - Native TracingProcessor Implementation
 """
 
-import json
 import time
-from datetime import datetime
-from typing import Any, Dict, Optional, TYPE_CHECKING
+from typing import Any, Dict, 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
@@ -48,553 +43,410 @@ except ImportError:
 
 class OpenLITTracingProcessor(TracingProcessor):
     """
-    OpenLIT processor that integrates with OpenAI Agents' native tracing system
-    Provides superior business intelligence while maintaining perfect hierarchy
-    """
+    OpenAI Agents tracing processor that integrates with OpenLIT observability.
 
-    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]
+    This processor enhances OpenAI Agents' native tracing system with OpenLIT's
+    comprehensive observability features including business intelligence,
+    cost tracking, and performance metrics.
+    """
 
+    def __init__(self, tracer, version, environment, application_name,
+                 pricing_info, capture_message_content, metrics,
+                 disable_metrics, detailed_tracing, **kwargs):
+        """Initialize the OpenLIT tracing processor."""
+        super().__init__()
+
+        # Core configuration
+        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
+
+        # Internal tracking
+        self.active_spans = {}
+        self.span_stack = []
+
+    def start_trace(self, trace_id: str, name: str, **kwargs):
+        """
+        Start a new trace with OpenLIT enhancements.
+
+        Args:
+            trace_id: Unique trace identifier
+            name: Trace name
+            **kwargs: Additional trace metadata
+        """
         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
-                )
+            # Generate span name using OpenTelemetry conventions
+            span_name = self._get_span_name(name, **kwargs)
+
+            # Start root span with OpenLIT context
+            span = self.tracer.start_as_current_span(
+                span_name,
+                kind=SpanKind.CLIENT,
+                attributes={
+                    SemanticConvention.GEN_AI_SYSTEM: "openai_agents",
+                    SemanticConvention.GEN_AI_OPERATION:
+                        SemanticConvention.GEN_AI_OPERATION_TYPE_WORKFLOW,
+                    "trace.id": trace_id,
+                    "trace.name": name,
+                }
+            )
+
+            # Create scope for common attributes
+            scope = type("GenericScope", (), {})()
+            scope._span = span  # pylint: disable=protected-access
+            scope._start_time = time.time()  # pylint: disable=protected-access
+            scope._end_time = None  # pylint: disable=protected-access
+
+            # Apply common framework attributes
+            common_framework_span_attributes(
+                scope,
+                "openai_agents",
+                "api.openai.com",
+                443,
+                self.environment,
+                self.application_name,
+                self.version,
+                name
+            )
+
+            # Track active span
+            self.active_spans[trace_id] = span
+            self.span_stack.append(span)
+
+            return span
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            # Graceful degradation
+            handle_exception(None, e)
+            return None
 
-        except Exception as e:
-            handle_exception(otel_span, e)
-        finally:
-            # End span and cleanup
-            otel_span.end()
+    def end_trace(self, trace_id: str, **kwargs):
+        """
+        End an active trace.
 
-            # Cleanup context
-            if span.span_id in self._tokens:
-                detach(self._tokens[span.span_id])
-                del self._tokens[span.span_id]
+        Args:
+            trace_id: Trace identifier to end
+            **kwargs: Additional metadata
+        """
+        try:
+            span = self.active_spans.get(trace_id)
+            if span:
+                # Set final attributes and status
+                span.set_status(Status(StatusCode.OK))
+
+                # End span
+                span.end()
+
+                # Cleanup tracking
+                if trace_id in self.active_spans:
+                    del self.active_spans[trace_id]
+                if span in self.span_stack:
+                    self.span_stack.remove(span)
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            handle_exception(span if span else None, e)
+
+    def _get_span_name(self, operation_name: str, **metadata) -> str:
+        """
+        Generate OpenTelemetry-compliant span names.
+
+        Args:
+            operation_name: Base operation name
+            **metadata: Additional context for naming
+
+        Returns:
+            Formatted span name following semantic conventions
+        """
+        # Extract context for naming
+        agent_name = metadata.get('agent_name', '')
+        model_name = metadata.get('model_name', '')
+        tool_name = metadata.get('tool_name', '')
+        workflow_name = metadata.get('workflow_name', '')
+
+        # Apply OpenTelemetry semantic conventions for GenAI agents
+        if 'agent' in operation_name.lower():
+            if agent_name:
+                return f"invoke_agent {agent_name}"
+            return "invoke_agent"
+        if 'chat' in operation_name.lower():
+            if model_name:
+                return f"chat {model_name}"
+            return "chat response"
+        if 'tool' in operation_name.lower():
+            if tool_name:
+                return f"execute_tool {tool_name}"
+            return "execute_tool"
+        if 'handoff' in operation_name.lower():
+            target_agent = metadata.get('target_agent', 'unknown')
+            return f"invoke_agent {target_agent}"
+        if 'workflow' in operation_name.lower():
+            if workflow_name:
+                return f"workflow {workflow_name}"
+            return "workflow"
+
+        # Default case
+        return operation_name
+
+    def span_start(self, span_data, trace_id: str):
+        """
+        Handle span start events from OpenAI Agents.
+
+        Args:
+            span_data: Span data from agents framework
+            trace_id: Associated trace identifier
+        """
+        try:
+            # Extract span information
+            span_name = getattr(span_data, 'name', 'unknown_operation')
+            span_type = getattr(span_data, 'type', 'unknown')
+
+            # Generate enhanced span name
+            enhanced_name = self._get_span_name(
+                span_name,
+                agent_name=getattr(span_data, 'agent_name', None),
+                model_name=getattr(span_data, 'model_name', None),
+                tool_name=getattr(span_data, 'tool_name', None)
+            )
+
+            # Determine span operation type
+            operation_type = self._get_operation_type(span_type, span_name)
+
+            # Start span with proper context
+            parent_span = self.span_stack[-1] if self.span_stack else None
+            context = set_span_in_context(parent_span) if parent_span else None
+
+            span = self.tracer.start_as_current_span(
+                enhanced_name,
+                kind=SpanKind.CLIENT,
+                context=context,
+                attributes={
+                    SemanticConvention.GEN_AI_SYSTEM: "openai_agents",
+                    SemanticConvention.GEN_AI_OPERATION: operation_type,
+                    "span.type": span_type,
+                    "span.id": getattr(span_data, 'span_id', ''),
+                }
+            )
+
+            # Process specific span types
+            self._process_span_attributes(span, span_data, span_type)
+
+            # Track span
+            span_id = getattr(span_data, 'span_id', len(self.span_stack))
+            self.active_spans[f"{trace_id}:{span_id}"] = span
+            self.span_stack.append(span)
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            handle_exception(None, e)
+
+    def _get_operation_type(self, span_type: str, span_name: str) -> str:
+        """Get operation type based on span characteristics."""
+        type_mapping = {
+            'agent': SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+            'generation': SemanticConvention.GEN_AI_OPERATION_CHAT,
+            'function': SemanticConvention.GEN_AI_OPERATION_CHAT,
+            'tool': SemanticConvention.GEN_AI_OPERATION_CHAT,
+            'handoff': SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+        }
 
-            # 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]
+        # Check span type first
+        for key, operation in type_mapping.items():
+            if key in span_type.lower():
+                return operation
 
-    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
+        # Check span name
+        for key, operation in type_mapping.items():
+            if key in span_name.lower():
+                return operation
 
-        root_span = self._root_spans[trace.trace_id]
+        return SemanticConvention.GEN_AI_OPERATION_CHAT
 
+    def _process_span_attributes(self, span, span_data, span_type: str):
+        """Process and set span attributes based on span type."""
         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
+            # Common attributes
+            if hasattr(span_data, 'agent_name'):
+                span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME,
+                                  span_data.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,
-        }
+            if hasattr(span_data, 'model_name'):
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
+                                  span_data.model_name)
+
+            # Agent-specific attributes
+            if span_type == 'agent':
+                self._process_agent_span(span, span_data)
+
+            # Generation-specific attributes
+            elif span_type == 'generation':
+                self._process_generation_span(span, span_data)
+
+            # Function/Tool-specific attributes
+            elif span_type in ['function', 'tool']:
+                self._process_function_span(span, span_data)
+
+            # Handoff-specific attributes
+            elif span_type == 'handoff':
+                self._process_handoff_span(span, span_data)
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            handle_exception(span, e)
+
+    def _process_agent_span(self, span, agent_span):
+        """Process agent span data (unused parameter)."""
+        # Agent-specific processing
+        if hasattr(agent_span, 'instructions'):
+            span.set_attribute(SemanticConvention.GEN_AI_AGENT_DESCRIPTION,
+                              str(agent_span.instructions)[:500])
 
-        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)"""
+            span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
+                              agent_span.model)
+
+    def _process_generation_span(self, span, generation_span):
+        """Process generation span data."""
+        # Set generation-specific attributes
+        if hasattr(generation_span, 'prompt'):
+            span.set_attribute(SemanticConvention.GEN_AI_PROMPT,
+                              str(generation_span.prompt)[:1000])
+
+        if hasattr(generation_span, 'completion'):
+            span.set_attribute(SemanticConvention.GEN_AI_COMPLETION,
+                              str(generation_span.completion)[:1000])
+
+        if hasattr(generation_span, 'usage'):
+            usage = generation_span.usage
+            if hasattr(usage, 'prompt_tokens'):
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_PROMPT_TOKENS,
+                                  usage.prompt_tokens)
+            if hasattr(usage, 'completion_tokens'):
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_USAGE_COMPLETION_TOKENS,
+                    usage.completion_tokens
+                )
+
+    def _process_function_span(self, span, function_span):
+        """Process function/tool span data."""
+        if hasattr(function_span, 'function_name'):
+            span.set_attribute(SemanticConvention.GEN_AI_TOOL_NAME,
+                              function_span.function_name)
+
+        if hasattr(function_span, 'arguments'):
+            span.set_attribute("gen_ai.tool.arguments",
+                              str(function_span.arguments)[:500])
+
+        if hasattr(function_span, 'result'):
+            span.set_attribute("gen_ai.tool.result",
+                              str(function_span.result)[:500])
+
+    def _process_handoff_span(self, span, handoff_span):
+        """Process handoff span data."""
+        if hasattr(handoff_span, 'target_agent'):
+            span.set_attribute("gen_ai.handoff.target_agent",
+                              handoff_span.target_agent)
+
+        if hasattr(handoff_span, 'reason'):
+            span.set_attribute("gen_ai.handoff.reason",
+                              str(handoff_span.reason)[:200])
+
+    def span_end(self, span_data, trace_id: str):
+        """Handle span end events."""
         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")
+            span_id = getattr(span_data, 'span_id', '')
+            span_key = f"{trace_id}:{span_id}"
+
+            span = self.active_spans.get(span_key)
+            if span:
+                # Set final status
+                if hasattr(span_data, 'error') and span_data.error:
+                    span.set_status(Status(StatusCode.ERROR,
+                                          str(span_data.error)))
                 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")
+                    span.set_status(Status(StatusCode.OK))
+
+                # End span
+                span.end()
 
-        except Exception:
-            pass  # Ignore export errors
+                # Cleanup
+                if span_key in self.active_spans:
+                    del self.active_spans[span_key]
+                if span in self.span_stack:
+                    self.span_stack.remove(span)
 
-    def _capture_detailed_token_usage(self, span: Any, data: Any) -> None:
-        """Capture detailed token usage information (inspired by OpenInference)"""
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            handle_exception(span if 'span' in locals() else None, e)
+
+    def force_flush(self):
+        """Force flush all pending spans."""
         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)"""
+            # End any remaining spans
+            for span in list(self.active_spans.values()):
+                span.end()
+
+            self.active_spans.clear()
+            self.span_stack.clear()
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            handle_exception(None, e)
+
+    def shutdown(self):
+        """Shutdown the processor."""
+        self.force_flush()
+
+    def _extract_model_info(self, span_data) -> Dict[str, Any]:
+        """Extract model information from span data."""
+        model_info = {}
+
+        if hasattr(span_data, 'model'):
+            model_info['model'] = span_data.model
+        if hasattr(span_data, 'model_name'):
+            model_info['model'] = span_data.model_name
+
+        return model_info
+
+    def _calculate_cost(self, model: str, prompt_tokens: int,
+                       completion_tokens: int) -> float:
+        """Calculate cost based on token usage."""
         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)"""
+            return get_chat_model_cost(
+                model, self.pricing_info, prompt_tokens, completion_tokens
+            )
+        except Exception:  # pylint: disable=broad-exception-caught
+            return 0.0
+
+    # Abstract method implementations required by OpenAI Agents framework
+    def on_trace_start(self, trace):
+        """Called when a trace starts - required by OpenAI Agents framework"""
+        try:
+            self.start_trace(getattr(trace, 'trace_id', 'unknown'),
+                           getattr(trace, 'name', 'workflow'))
+        except Exception:  # pylint: disable=broad-exception-caught
+            pass
+
+    def on_trace_end(self, trace):
+        """Called when a trace ends - required by OpenAI Agents framework"""
+        try:
+            self.end_trace(getattr(trace, 'trace_id', 'unknown'))
+        except Exception:  # pylint: disable=broad-exception-caught
+            pass
+
+    def on_span_start(self, span):
+        """Called when a span starts - required by OpenAI Agents framework"""
+        try:
+            trace_id = getattr(span, 'trace_id', 'unknown')
+            self.span_start(span, trace_id)
+        except Exception:  # pylint: disable=broad-exception-caught
+            pass
+
+    def on_span_end(self, span):
+        """Called when a span ends - required by OpenAI Agents framework"""
         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
+            trace_id = getattr(span, 'trace_id', 'unknown')
+            self.span_end(span, trace_id)
+        except Exception:  # pylint: disable=broad-exception-caught
+            pass