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

openlit/instrumentation/openai_agents/__init__.py

@@ -10,6 +10,7 @@ from openlit.instrumentation.openai_agents.processor import OpenLITTracingProces
 
 _instruments = ("openai-agents >= 0.0.3",)
 
+
 class OpenAIAgentsInstrumentor(BaseInstrumentor):
     """OpenLIT instrumentor for OpenAI Agents using native tracing system"""
 
@@ -37,18 +38,20 @@ class OpenAIAgentsInstrumentor(BaseInstrumentor):
             capture_message_content=capture_message_content,
             metrics=metrics,
             disable_metrics=disable_metrics,
-            detailed_tracing=detailed_tracing
+            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
@@ -57,6 +60,7 @@ class OpenAIAgentsInstrumentor(BaseInstrumentor):
         # Clear our processors
         try:
             from agents import set_trace_processors
+
             set_trace_processors([])
         except ImportError:
             pass

openlit/instrumentation/openai_agents/processor.py

@@ -10,13 +10,14 @@ from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_contex
 from openlit.__helpers import (
     common_framework_span_attributes,
     handle_exception,
-    get_chat_model_cost
+    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
@@ -50,9 +51,19 @@ class OpenLITTracingProcessor(TracingProcessor):
     cost tracking, and performance metrics.
     """
 
-    def __init__(self, tracer, version, environment, application_name,
-                 pricing_info, capture_message_content, metrics,
-                 disable_metrics, detailed_tracing, **kwargs):
+    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__()
 
@@ -90,11 +101,10 @@ class OpenLITTracingProcessor(TracingProcessor):
                 kind=SpanKind.CLIENT,
                 attributes={
                     SemanticConvention.GEN_AI_SYSTEM: "openai_agents",
-                    SemanticConvention.GEN_AI_OPERATION:
-                        SemanticConvention.GEN_AI_OPERATION_TYPE_WORKFLOW,
+                    SemanticConvention.GEN_AI_OPERATION: SemanticConvention.GEN_AI_OPERATION_TYPE_WORKFLOW,
                     "trace.id": trace_id,
                     "trace.name": name,
-                }
+                },
             )
 
             # Create scope for common attributes
@@ -112,7 +122,7 @@ class OpenLITTracingProcessor(TracingProcessor):
                 self.environment,
                 self.application_name,
                 self.version,
-                name
+                name,
             )
 
             # Track active span
@@ -164,28 +174,28 @@ class OpenLITTracingProcessor(TracingProcessor):
             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', '')
+        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" in operation_name.lower():
             if agent_name:
                 return f"invoke_agent {agent_name}"
             return "invoke_agent"
-        if 'chat' in operation_name.lower():
+        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" 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')
+        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" in operation_name.lower():
             if workflow_name:
                 return f"workflow {workflow_name}"
             return "workflow"
@@ -203,15 +213,15 @@ class OpenLITTracingProcessor(TracingProcessor):
         """
         try:
             # Extract span information
-            span_name = getattr(span_data, 'name', 'unknown_operation')
-            span_type = getattr(span_data, 'type', 'unknown')
+            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)
+                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
@@ -229,15 +239,15 @@ class OpenLITTracingProcessor(TracingProcessor):
                     SemanticConvention.GEN_AI_SYSTEM: "openai_agents",
                     SemanticConvention.GEN_AI_OPERATION: operation_type,
                     "span.type": span_type,
-                    "span.id": getattr(span_data, 'span_id', ''),
-                }
+                    "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))
+            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)
 
@@ -247,11 +257,11 @@ class OpenLITTracingProcessor(TracingProcessor):
     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,
+            "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,
         }
 
         # Check span type first
@@ -270,28 +280,30 @@ class OpenLITTracingProcessor(TracingProcessor):
         """Process and set span attributes based on span type."""
         try:
             # Common attributes
-            if hasattr(span_data, 'agent_name'):
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME,
-                                  span_data.agent_name)
+            if hasattr(span_data, "agent_name"):
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_NAME, span_data.agent_name
+                )
 
-            if hasattr(span_data, 'model_name'):
-                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                  span_data.model_name)
+            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':
+            if span_type == "agent":
                 self._process_agent_span(span, span_data)
 
             # Generation-specific attributes
-            elif span_type == 'generation':
+            elif span_type == "generation":
                 self._process_generation_span(span, span_data)
 
             # Function/Tool-specific attributes
-            elif span_type in ['function', 'tool']:
+            elif span_type in ["function", "tool"]:
                 self._process_function_span(span, span_data)
 
             # Handoff-specific attributes
-            elif span_type == 'handoff':
+            elif span_type == "handoff":
                 self._process_handoff_span(span, span_data)
 
         except Exception as e:  # pylint: disable=broad-exception-caught
@@ -300,72 +312,77 @@ class OpenLITTracingProcessor(TracingProcessor):
     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])
+        if hasattr(agent_span, "instructions"):
+            span.set_attribute(
+                SemanticConvention.GEN_AI_AGENT_DESCRIPTION,
+                str(agent_span.instructions)[:500],
+            )
 
-        if hasattr(agent_span, 'model'):
-            span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                              agent_span.model)
+        if hasattr(agent_span, "model"):
+            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, "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, "completion"):
+            span.set_attribute(
+                SemanticConvention.GEN_AI_COMPLETION,
+                str(generation_span.completion)[:1000],
+            )
 
-        if hasattr(generation_span, 'usage'):
+        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'):
+            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
+                    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, "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, "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])
+        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, "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])
+        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:
-            span_id = getattr(span_data, 'span_id', '')
+            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)))
+                if hasattr(span_data, "error") and span_data.error:
+                    span.set_status(Status(StatusCode.ERROR, str(span_data.error)))
                 else:
                     span.set_status(Status(StatusCode.OK))
 
@@ -379,7 +396,7 @@ class OpenLITTracingProcessor(TracingProcessor):
                     self.span_stack.remove(span)
 
         except Exception as e:  # pylint: disable=broad-exception-caught
-            handle_exception(span if 'span' in locals() else None, e)
+            handle_exception(span if "span" in locals() else None, e)
 
     def force_flush(self):
         """Force flush all pending spans."""
@@ -402,15 +419,16 @@ class OpenLITTracingProcessor(TracingProcessor):
         """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
+        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:
+    def _calculate_cost(
+        self, model: str, prompt_tokens: int, completion_tokens: int
+    ) -> float:
         """Calculate cost based on token usage."""
         try:
             return get_chat_model_cost(
@@ -423,22 +441,24 @@ class OpenLITTracingProcessor(TracingProcessor):
     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'))
+            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'))
+            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')
+            trace_id = getattr(span, "trace_id", "unknown")
             self.span_start(span, trace_id)
         except Exception:  # pylint: disable=broad-exception-caught
             pass
@@ -446,7 +466,7 @@ class OpenLITTracingProcessor(TracingProcessor):
     def on_span_end(self, span):
         """Called when a span ends - required by OpenAI Agents framework"""
         try:
-            trace_id = getattr(span, 'trace_id', 'unknown')
+            trace_id = getattr(span, "trace_id", "unknown")
             self.span_end(span, trace_id)
         except Exception:  # pylint: disable=broad-exception-caught
             pass

openlit/instrumentation/phidata/__init__.py

@@ -6,12 +6,11 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.phidata.phidata import (
-    phidata_wrap
-)
+from openlit.instrumentation.phidata.phidata import phidata_wrap
 
 _instruments = ("phidata >= 2.5.32",)
 
+
 class PhidataInstrumentor(BaseInstrumentor):
     """
     An instrumentor for Phidata's client library.
@@ -33,8 +32,17 @@ class PhidataInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "phi.agent",
             "Agent.print_response",
-            phidata_wrap("phidata.print_response", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            phidata_wrap(
+                "phidata.print_response",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/phidata/phidata.py

@@ -5,7 +5,11 @@ Module for monitoring Phidata calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import (
     handle_exception,
 )
@@ -14,8 +18,18 @@ from openlit.semcov import SemanticConvention
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def phidata_wrap(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def phidata_wrap(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,40 +64,61 @@ def phidata_wrap(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_PHIDATA)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                    getattr(instance, 'agent_id', '') or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                    getattr(instance, 'name', '') or '')
-                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                    getattr(getattr(instance, 'model', None), 'id', '') or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TOOLS,
-                                    str(getattr(instance, 'tools', '')) or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_CONTEXT,
-                                    str(getattr(instance, 'knowledge', '')) or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TASK,
-                                    str(getattr(instance, 'task', '')) or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
-                                    str(getattr(instance, 'instructions', '')) or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_STORAGE,
-                                    str(getattr(instance, 'storage', '')) or '')
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ENABLE_HISTORY,
-                                    str(getattr(instance, 'add_history_to_messages', '')) or '')
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_PHIDATA,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_ID,
+                    getattr(instance, "agent_id", "") or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_ROLE,
+                    getattr(instance, "name", "") or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_REQUEST_MODEL,
+                    getattr(getattr(instance, "model", None), "id", "") or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TOOLS,
+                    str(getattr(instance, "tools", "")) or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_CONTEXT,
+                    str(getattr(instance, "knowledge", "")) or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TASK,
+                    str(getattr(instance, "task", "")) or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
+                    str(getattr(instance, "instructions", "")) or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_STORAGE,
+                    str(getattr(instance, "storage", "")) or "",
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_ENABLE_HISTORY,
+                    str(getattr(instance, "add_history_to_messages", "")) or "",
+                )
 
                 span.set_status(Status(StatusCode.OK))