Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
Add Events for OpenAI instrumentation and Evals (#999)
Ishan Jainb0e825dc91ed
diff --git a/contributors/EVENTS_MIGRATION_GUIDE.md b/contributors/EVENTS_MIGRATION_GUIDE.mdnew file mode 100644index 00000000..093b18e9--- /dev/null+++ b/contributors/EVENTS_MIGRATION_GUIDE.md@@ -0,0 +1,1064 @@+# OpenTelemetry Events Migration Guide++This guide documents the migration pattern from span events to OTel log events for LLM instrumentation, following the [OpenTelemetry Gen-AI Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md).++**Reference Implementation:** OpenAI instrumentation (completed)+**Status:** Production-ready pattern for adoption across all providers++---++## Table of Contents++1. [Overview](#overview)+2. [Architecture Decisions](#architecture-decisions)+3. [Implementation Pattern](#implementation-pattern)+4. [Code Examples](#code-examples)+5. [Testing Checklist](#testing-checklist)+6. [Provider-Specific Notes](#provider-specific-notes)++---++## Overview++### What Changed++**Before:** Prompt and response content emitted as span events using `span.add_event()`+```python+# OLD - To be removed+span.add_event(+ name="gen_ai.content.prompt",+ attributes={"gen_ai.prompt": json.dumps(messages)}+)+```++**After:** Content emitted as OTel log events using the events provider+```python+# NEW - Following OTel Gen-AI spec+event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes={+ SemanticConvention.GEN_AI_INPUT_MESSAGES: input_messages, # Structured, not JSON string+ SemanticConvention.GEN_AI_OUTPUT_MESSAGES: output_messages,+ # ... other attributes+ },+ body=""+)+event_provider.emit(event)+```++### Why This Matters++1. **Compliance:** Aligns with OTel Gen-AI semantic conventions v1.29++2. **Structure:** Messages as structured objects (not JSON strings)+3. **Standardization:** Consistent event format across all providers+4. **Observability:** Better integration with OTel backends+5. **Future-proof:** Prepares for span events deprecation++---++## Architecture Decisions++### 1. Event Name++**Use:** `gen_ai.client.inference.operation.details`+**For:** All operations (chat, completions, embeddings, image, audio)++```python+SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS = "gen_ai.client.inference.operation.details"+```++### 2. Message Format++**Critical:** Use structured objects, NOT JSON strings++```python+# ✅ CORRECT - Structured objects+input_messages = [+ {+ "role": "user",+ "parts": [{"type": "text", "content": "Hello"}]+ }+]++# ❌ WRONG - JSON strings+input_messages = json.dumps([...]) # Never do this!+```++### 3. Event Emission Timing++**When:** After receiving complete response (including streaming)++- **Non-streaming:** Emit immediately after response+- **Streaming:** Emit in StopIteration handler after all chunks collected++### 4. Attribute Mapping++**Required Attributes:**+- `gen_ai.operation` (chat, completion, embedding, etc.)+- `gen_ai.request.model`+- `gen_ai.response.model`+- `gen_ai.input.messages` (for chat/completions)+- `gen_ai.output.messages` (for chat/completions)++**Recommended Attributes:**+- `gen_ai.system_instructions` (if system messages present)+- `gen_ai.tool.definitions` (if tools/functions provided)+- `gen_ai.response.id`+- `gen_ai.response.finish_reasons[]`+- `server.address`, `server.port`++**Optional Attributes:**+- `gen_ai.request.temperature`+- `gen_ai.request.max_tokens`+- `gen_ai.request.top_p`+- `gen_ai.request.frequency_penalty`+- `gen_ai.request.presence_penalty`+- `gen_ai.request.stop_sequences[]`+- `gen_ai.request.seed`+- `gen_ai.response.choice_count`+- `gen_ai.response.output_type`+- `gen_ai.usage.input_tokens`+- `gen_ai.usage.output_tokens`++### 5. Backward Compatibility++**Keep existing span attributes** - DO NOT REMOVE:+- `gen_ai.prompt` (legacy)+- `gen_ai.completion` (legacy)+- All metrics+- All existing span attributes++**Only remove:** `span.add_event()` calls++---++## Implementation Pattern++### Step-by-Step Migration++#### Phase 1: Add Semantic Conventions++**File:** `src/openlit/semcov/__init__.py`++```python+# Add these constants after existing gen_ai constants+# GenAI Event Names (OTel Semconv v1.29+)+GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS = "gen_ai.client.inference.operation.details"++# GenAI Content Attributes (OTel Semconv v1.29+)+GEN_AI_INPUT_MESSAGES = "gen_ai.input.messages"+GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages"+GEN_AI_SYSTEM_INSTRUCTIONS = "gen_ai.system_instructions"+GEN_AI_TOOL_DEFINITIONS = "gen_ai.tool.definitions"+```++#### Phase 2: Create Message Builder Helpers++**File:** `src/openlit/instrumentation/<provider>/utils.py`++**Helper 1: Build Input Messages**+```python+def build_input_messages(messages):+ """+ Convert provider-specific messages to OTel input message structure.++ Returns:+ List of ChatMessage objects with structure:+ [+ {+ "role": "user|assistant|system|tool",+ "parts": [+ {"type": "text", "content": "..."},+ {"type": "uri", "modality": "image", "uri": "..."},+ {"type": "tool_call_response", "id": "...", "response": "..."}+ ]+ }+ ]+ """+ structured_messages = []++ for msg in messages:+ # Extract role+ role = msg.get("role", "user")++ # Build parts array+ parts = []+ content = msg.get("content", "")++ if isinstance(content, str):+ # Simple text content+ parts.append({"type": "text", "content": content})+ elif isinstance(content, list):+ # Multi-part content (text, images, etc.)+ for part in content:+ if part.get("type") == "text":+ parts.append({"type": "text", "content": part.get("text", "")})+ elif part.get("type") == "image_url":+ image_url = part.get("image_url", {}).get("url", "")+ # Skip data URIs for privacy+ if not image_url.startswith("data:"):+ parts.append({+ "type": "uri",+ "modality": "image",+ "uri": image_url+ })++ # Handle tool calls (for assistant messages)+ if "tool_calls" in msg:+ for tool_call in msg.get("tool_calls", []):+ parts.append({+ "type": "tool_call",+ "id": tool_call.get("id", ""),+ "name": tool_call.get("function", {}).get("name", ""),+ "arguments": tool_call.get("function", {}).get("arguments", {})+ })++ # Handle tool responses (for tool role)+ if role == "tool" and "tool_call_id" in msg:+ parts.append({+ "type": "tool_call_response",+ "id": msg.get("tool_call_id", ""),+ "response": content+ })++ structured_messages.append({+ "role": role,+ "parts": parts+ })++ return structured_messages+```++**Helper 2: Build Output Messages**+```python+def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert provider response to OTel output message structure.++ Returns:+ List with single OutputMessage:+ [+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "..."},+ {"type": "tool_call", "id": "...", "name": "...", "arguments": {...}}+ ],+ "finish_reason": "stop|length|tool_calls|..."+ }+ ]+ """+ parts = []++ # Add text content if present+ if response_text:+ parts.append({"type": "text", "content": response_text})++ # Add tool calls if present+ if tool_calls:+ for tool_call in tool_calls:+ parts.append({+ "type": "tool_call",+ "id": tool_call.get("id", ""),+ "name": tool_call.get("function", {}).get("name", ""),+ "arguments": tool_call.get("function", {}).get("arguments", {})+ })++ # Map provider finish reasons to OTel standard+ finish_reason_map = {+ "stop": "stop",+ "length": "max_tokens",+ "tool_calls": "tool_calls",+ "function_call": "tool_calls",+ "content_filter": "content_filter",+ # Add provider-specific mappings+ }++ otel_finish_reason = finish_reason_map.get(finish_reason, finish_reason)++ return [{+ "role": "assistant",+ "parts": parts,+ "finish_reason": otel_finish_reason+ }]+```++**Helper 3: Build Tool Definitions**+```python+def build_tool_definitions(tools):+ """+ Extract tool/function definitions from request.++ Returns:+ List of tool definition objects or None:+ [+ {+ "type": "function",+ "function": {+ "name": "...",+ "description": "...",+ "parameters": {...}+ }+ }+ ]+ """+ if not tools:+ return None++ # Tools are usually already in correct format+ # Just validate and pass through+ return tools+```++**Helper 4: Emit Inference Event (Centralized)**+```python+def emit_inference_event(+ event_provider,+ operation_name,+ request_model,+ response_model,+ input_messages=None,+ output_messages=None,+ tool_definitions=None,+ server_address=None,+ server_port=None,+ **extra_attrs+):+ """+ Centralized function to emit gen_ai.client.inference.operation.details event.++ Args:+ event_provider: The OTel event provider+ operation_name: Operation type (chat, completion, embedding, etc.)+ request_model: Model specified in request+ response_model: Model returned in response+ input_messages: Structured input messages+ output_messages: Structured output messages+ tool_definitions: Tool/function definitions+ server_address: API server address+ server_port: API server port+ **extra_attrs: Additional attributes (temperature, max_tokens, etc.)+ """+ try:+ if not event_provider:+ return++ from openlit.__helpers import otel_event+ from openlit.semcov import SemanticConvention++ # Build base attributes+ attributes = {+ SemanticConvention.GEN_AI_OPERATION: operation_name,+ }++ # Add model attributes+ if request_model:+ attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = request_model+ if response_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model++ # Add server attributes+ if server_address:+ attributes["server.address"] = server_address+ if server_port:+ attributes["server.port"] = server_port++ # Add messages (only if not None/empty)+ if input_messages:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages++ # Add tool definitions (recommended)+ if tool_definitions:+ attributes[SemanticConvention.GEN_AI_TOOL_DEFINITIONS] = tool_definitions++ # Map extra attributes to semantic conventions+ attr_mapping = {+ "temperature": SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,+ "max_tokens": SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,+ "top_p": SemanticConvention.GEN_AI_REQUEST_TOP_P,+ "frequency_penalty": SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,+ "presence_penalty": SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,+ "stop_sequences": SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES,+ "seed": SemanticConvention.GEN_AI_REQUEST_SEED,+ "response_id": SemanticConvention.GEN_AI_RESPONSE_ID,+ "finish_reasons": SemanticConvention.GEN_AI_RESPONSE_FINISH_REASONS,+ "choice_count": SemanticConvention.GEN_AI_RESPONSE_CHOICE_COUNT,+ "output_type": SemanticConvention.GEN_AI_RESPONSE_OUTPUT_TYPE,+ "input_tokens": SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,+ "output_tokens": SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,+ }++ for key, value in extra_attrs.items():+ if value is not None and key in attr_mapping:+ attributes[attr_mapping[key]] = value++ # Create and emit event+ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="" # Per spec, all data in attributes+ )++ event_provider.emit(event)++ except Exception as e:+ import logging+ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)+```++#### Phase 3: Update Processing Functions++**File:** `src/openlit/instrumentation/<provider>/utils.py`++**Pattern for common_chat_logic() or equivalent:**++```python+def common_chat_logic(+ # ... existing parameters ...+ event_provider=None, # NEW PARAMETER+):+ """Process chat/completion responses"""++ # ... existing span attribute logic (KEEP THIS) ...++ # Set legacy span attributes+ span.set_attribute(SemanticConvention.GEN_AI_PROMPT, formatted_messages)+ span.set_attribute(SemanticConvention.GEN_AI_COMPLETION, response_content)++ # REMOVE OLD SPAN EVENTS - Delete these lines:+ # span.add_event(name="gen_ai.content.prompt", attributes={...})+ # span.add_event(name="gen_ai.content.completion", attributes={...})++ # NEW: Emit log event+ if capture_message_content and event_provider:+ try:+ # Build structured messages+ input_msgs = build_input_messages(kwargs.get("messages", []))+ output_msgs = build_output_messages(+ response_text=llm_response,+ finish_reason=finish_reason,+ tool_calls=tool_calls+ )+ tool_defs = build_tool_definitions(kwargs.get("tools"))++ # Emit event with all attributes+ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ request_model=request_model,+ response_model=response_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=tool_defs,+ server_address=server_address,+ server_port=server_port,+ # Add all available request parameters+ temperature=kwargs.get("temperature"),+ max_tokens=kwargs.get("max_tokens"),+ top_p=kwargs.get("top_p"),+ frequency_penalty=kwargs.get("frequency_penalty"),+ presence_penalty=kwargs.get("presence_penalty"),+ stop_sequences=kwargs.get("stop"),+ seed=kwargs.get("seed"),+ # Add all available response attributes+ response_id=response_id,+ finish_reasons=[finish_reason],+ choice_count=len(choices),+ output_type=kwargs.get("response_format", {}).get("type"),+ input_tokens=prompt_tokens,+ output_tokens=completion_tokens,+ )+ except Exception as e:+ logger.warning("Failed to emit event: %s", e)+```++#### Phase 4: Update Wrapper Functions++**File:** `src/openlit/instrumentation/<provider>/<provider>.py` (sync)++**Pattern for chat_completions wrapper:**++```python+def chat_completions(+ # ... existing parameters ...+ event_provider=None, # NEW PARAMETER+):+ """Wrapper for chat completions"""++ def wrapper(wrapped, instance, args, kwargs):+ # ... existing setup ...++ # For streaming responses+ class TracedSyncStream:+ def __init__(self, wrapped, span, span_name, kwargs,+ server_address, server_port, event_provider=None): # NEW+ self._wrapped = wrapped+ self._span = span+ self._event_provider = event_provider # STORE IT+ # ... rest of init ...++ def __next__(self):+ try:+ chunk = next(self._wrapped)+ # ... accumulate chunks ...+ return chunk+ except StopIteration:+ # Process complete stream+ process_streaming_chat_response(+ # ... existing parameters ...+ event_provider=self._event_provider, # PASS IT+ )+ raise++ # Execute wrapped function+ response = wrapped(*args, **kwargs)++ # Handle streaming+ if isinstance(response, Stream):+ return TracedSyncStream(+ response, span, span_name, kwargs,+ server_address, server_port,+ event_provider=event_provider # PASS IT+ )++ # Handle non-streaming+ process_chat_response(+ # ... existing parameters ...+ event_provider=event_provider, # PASS IT+ )++ return response++ return wrapper+```++**File:** `src/openlit/instrumentation/<provider>/async_<provider>.py` (async)++**Mirror the sync pattern for async:**++```python+def async_chat_completions(+ # ... existing parameters ...+ event_provider=None, # NEW PARAMETER+):+ """Async wrapper for chat completions"""++ async def wrapper(wrapped, instance, args, kwargs):+ # ... same pattern as sync ...++ class TracedAsyncStream:+ def __init__(self, wrapped, span, span_name, kwargs,+ server_address, server_port, event_provider=None): # NEW+ self._event_provider = event_provider # STORE IT+ # ... rest of init ...++ async def __anext__(self):+ try:+ chunk = await self._wrapped.__anext__()+ # ... accumulate chunks ...+ return chunk+ except StopAsyncIteration:+ # Process complete stream+ process_streaming_chat_response(+ # ... existing parameters ...+ event_provider=self._event_provider, # PASS IT+ )+ raise++ # ... rest follows sync pattern ...++ return wrapper+```++#### Phase 5: Update Instrumentation Entry Point++**File:** `src/openlit/instrumentation/<provider>/__init__.py`++```python+def _instrument(self, **kwargs):+ """Instrument the provider"""++ # Extract event_provider from kwargs+ event_provider = kwargs.get("event_provider") # NEW++ # Wrap all operations+ wrap_function_wrapper(+ "provider_sdk.module",+ "ChatCompletions.create",+ chat_completions(+ # ... existing parameters ...+ event_provider=event_provider, # PASS TO WRAPPER+ ),+ )++ wrap_function_wrapper(+ "provider_sdk.module",+ "AsyncChatCompletions.create",+ async_chat_completions(+ # ... existing parameters ...+ event_provider=event_provider, # PASS TO WRAPPER+ ),+ )++ # Repeat for all operations:+ # - embeddings (sync + async)+ # - image generation (sync + async)+ # - audio/speech (sync + async)+ # - etc.+```++---++## Code Examples++### Example 1: Complete Chat Message Structure++```python+# Input messages with various content types+input_messages = [+ {+ "role": "system",+ "parts": [+ {"type": "text", "content": "You are a helpful assistant"}+ ]+ },+ {+ "role": "user",+ "parts": [+ {"type": "text", "content": "What's in this image?"},+ {"type": "uri", "modality": "image", "uri": "https://example.com/image.jpg"}+ ]+ },+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "Let me analyze it"},+ {+ "type": "tool_call",+ "id": "call_123",+ "name": "analyze_image",+ "arguments": {"image_url": "..."}+ }+ ]+ },+ {+ "role": "tool",+ "parts": [+ {+ "type": "tool_call_response",+ "id": "call_123",+ "response": "The image contains a cat"+ }+ ]+ }+]++# Output messages+output_messages = [+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "Based on the analysis, the image shows a cat."}+ ],+ "finish_reason": "stop"+ }+]+```++### Example 2: Tool Definitions++```python+tool_definitions = [+ {+ "type": "function",+ "function": {+ "name": "get_weather",+ "description": "Get current weather for a location",+ "parameters": {+ "type": "object",+ "properties": {+ "location": {+ "type": "string",+ "description": "City name"+ },+ "unit": {+ "type": "string",+ "enum": ["celsius", "fahrenheit"]+ }+ },+ "required": ["location"]+ }+ }+ }+]+```++### Example 3: Complete Event Emission++```python+emit_inference_event(+ event_provider=event_provider,+ operation_name="chat",+ request_model="gpt-4",+ response_model="gpt-4-0613",+ input_messages=input_messages,+ output_messages=output_messages,+ tool_definitions=tool_definitions,+ server_address="api.openai.com",+ server_port=443,+ temperature=0.7,+ max_tokens=1000,+ top_p=0.9,+ response_id="chatcmpl-123",+ finish_reasons=["stop"],+ choice_count=1,+ input_tokens=50,+ output_tokens=25+)+```++---++## Testing Checklist++### Pre-Migration Testing+- [ ] Identify all `span.add_event()` calls in provider code+- [ ] Document current message formats used by provider+- [ ] Verify existing span attributes are set correctly+- [ ] Run existing test suite - record baseline++### Post-Migration Testing++#### Functional Tests+- [ ] Non-streaming chat/completions with text only+- [ ] Non-streaming with images (if supported)+- [ ] Non-streaming with tool calls+- [ ] Streaming chat/completions+- [ ] Streaming with tool calls+- [ ] Embeddings operations+- [ ] Image generation operations+- [ ] Audio/speech operations++#### Event Validation+- [ ] Event name is `gen_ai.client.inference.operation.details`+- [ ] Input messages in structured format (NOT JSON strings)+- [ ] Output messages in structured format (NOT JSON strings)+- [ ] Messages follow OTel JSON schemas+- [ ] Tool definitions included when tools used+- [ ] All required attributes present+- [ ] All recommended attributes present (when available)+- [ ] Optional attributes included (when available)++#### Backward Compatibility+- [ ] Existing span attributes still set correctly+- [ ] Legacy `gen_ai.prompt` still present+- [ ] Legacy `gen_ai.completion` still present+- [ ] Metrics still recorded+- [ ] No span events present (removed)+- [ ] capture_message_content flag respected+- [ ] event_provider=None works (no events emitted)++#### Error Handling+- [ ] Event emission failure doesn't break instrumentation+- [ ] Malformed messages handled gracefully+- [ ] Missing fields don't cause crashes+- [ ] Non-serializable objects handled++#### Performance+- [ ] No significant latency increase+- [ ] No memory leaks with streaming+- [ ] Event size reasonable (not sending base64 images)++---++## Provider-Specific Notes++### Common Provider Variations++#### Message Format Differences++**OpenAI/Azure OpenAI:**+```python+messages = [+ {"role": "user", "content": "text"},+ {"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image_url", "image_url": {"url": "..."}}]}+]+```++**Anthropic:**+```python+messages = [+ {"role": "user", "content": "text"},+ {"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image", "source": {"type": "url", "url": "..."}}]}+]+```++**Google (Gemini):**+```python+contents = [+ {"role": "user", "parts": [{"text": "..."}]},+ {"role": "user", "parts": [{"text": "..."}, {"inline_data": {"mime_type": "...", "data": "..."}}]}+]+```++**Cohere:**+```python+message = "text" # Simple string+chat_history = [{"role": "USER", "message": "..."}, {"role": "CHATBOT", "message": "..."}]+```++#### Tool/Function Call Variations++**OpenAI:** `tools` with `function` type+**Anthropic:** `tools` with `function` type (similar)+**Google:** `tools` with `function_declarations`+**Cohere:** `tools` with separate format++**Solution:** Normalize to OTel format in `build_tool_definitions()`++#### Finish Reason Mapping++Each provider has different finish reason names. Create a mapping:++```python+FINISH_REASON_MAP = {+ # OpenAI+ "stop": "stop",+ "length": "max_tokens",+ "tool_calls": "tool_calls",+ "content_filter": "content_filter",++ # Anthropic+ "end_turn": "stop",+ "max_tokens": "max_tokens",+ "stop_sequence": "stop",++ "STOP": "stop",+ "MAX_TOKENS": "max_tokens",+ "SAFETY": "content_filter",++ # Cohere+ "COMPLETE": "stop",+ "MAX_TOKENS": "max_tokens",++ # Add provider-specific mappings+}+```++### Provider Migration Priority++**High Priority (Similar to OpenAI):**+1. Azure OpenAI - Nearly identical API+2. Anthropic - Very similar structure+3. Google Gemini - Similar concepts, different naming++**Medium Priority:**+4. Cohere - Different API structure+5. Mistral - Similar to OpenAI+6. Groq - Similar to OpenAI++**Lower Priority:**+7. HuggingFace - Varies by model+8. Bedrock - Varies by provider++### Common Pitfalls++#### 1. Don't JSON Stringify Messages+```python+# ❌ WRONG+attributes = {+ "gen_ai.input.messages": json.dumps(messages)+}++# ✅ CORRECT+attributes = {+ "gen_ai.input.messages": messages # Direct structured object+}+```++#### 2. Don't Skip capture_message_content Check+```python+# ❌ WRONG - Always emits+emit_inference_event(event_provider, ...)++# ✅ CORRECT - Check flag first+if capture_message_content and event_provider:+ emit_inference_event(event_provider, ...)+```++#### 3. Don't Break on Missing event_provider+```python+# ❌ WRONG - Will crash if None+event_provider.emit(event)++# ✅ CORRECT - Check first+if event_provider:+ event_provider.emit(event)+```++#### 4. Don't Include Sensitive Data+```python+# ❌ WRONG - Includes base64 image data+if image_url:+ parts.append({"type": "uri", "uri": image_url})++# ✅ CORRECT - Skip data URIs+if image_url and not image_url.startswith("data:"):+ parts.append({"type": "uri", "modality": "image", "uri": image_url})+```++#### 5. Don't Remove Existing Span Attributes+```python+# ❌ WRONG - Removes legacy attributes+# span.set_attribute("gen_ai.prompt", messages) # Commented out++# ✅ CORRECT - Keep them for backward compatibility+span.set_attribute("gen_ai.prompt", messages) # Keep this+# Add new events separately+if event_provider:+ emit_inference_event(...)+```++---++## Evaluation Events Pattern++For evaluation systems (hallucination, bias, toxicity detection):++### Event Name+`gen_ai.evaluation.result`++### Implementation Pattern++```python+# 1. Add semantic conventions+GEN_AI_EVALUATION_RESULT = "gen_ai.evaluation.result"+GEN_AI_EVALUATION_NAME = "gen_ai.evaluation.name"+GEN_AI_EVALUATION_SCORE_VALUE = "gen_ai.evaluation.score.value"+GEN_AI_EVALUATION_SCORE_LABEL = "gen_ai.evaluation.score.label"+GEN_AI_EVALUATION_EXPLANATION = "gen_ai.evaluation.explanation"++# 2. Create helper+def emit_evaluation_event(+ event_provider,+ evaluation_name,+ score_value,+ score_label,+ explanation,+ response_id=None+):+ if not event_provider:+ return++ attributes = {+ SemanticConvention.GEN_AI_EVALUATION_NAME: evaluation_name,+ SemanticConvention.GEN_AI_EVALUATION_SCORE_VALUE: float(score_value),+ SemanticConvention.GEN_AI_EVALUATION_SCORE_LABEL: score_label,+ }++ if explanation:+ attributes[SemanticConvention.GEN_AI_EVALUATION_EXPLANATION] = explanation+ if response_id:+ attributes[SemanticConvention.GEN_AI_RESPONSE_ID] = response_id++ event = otel_event(+ name=SemanticConvention.GEN_AI_EVALUATION_RESULT,+ attributes=attributes,+ body=""+ )++ event_provider.emit(event)++# 3. Update evaluator classes+class HallucinationDetector:+ def __init__(self, ..., event_provider=None):+ self.event_provider = event_provider++ def measure(self, ...):+ result = run_evaluation(...)++ # Existing counter metric+ if self.collect_metrics:+ metric_counter.add(1, attributes)++ # New event emission+ if self.event_provider:+ emit_evaluation_event(+ event_provider=self.event_provider,+ evaluation_name="hallucination",+ score_value=result.score,+ score_label=result.verdict,+ explanation=result.explanation+ )++ return result+```++---++## Reference Links++- [OTel Gen-AI Events Spec](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md)+- [OTel Input Messages Schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-input-messages.json)+- [OTel Output Messages Schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-output-messages.json)+- [OpenAI Implementation (Reference)](sdk/python/src/openlit/instrumentation/openai/)++---++## Migration Checklist Template++Use this checklist when migrating a new provider:++### Planning+- [ ] Read this guide completely+- [ ] Review provider's API documentation+- [ ] Identify all operations to migrate (chat, embeddings, etc.)+- [ ] Map provider message format to OTel structure+- [ ] Map provider parameters to OTel attributes+- [ ] Map provider finish reasons to OTel values++### Implementation+- [ ] Add semantic conventions to `semcov/__init__.py`+- [ ] Create `build_input_messages()` for provider+- [ ] Create `build_output_messages()` for provider+- [ ] Create `build_tool_definitions()` for provider+- [ ] Create `emit_inference_event()` (can reuse pattern)+- [ ] Update all processing functions with event_provider+- [ ] Update all sync wrapper functions+- [ ] Update all async wrapper functions+- [ ] Update instrumentation entry point+- [ ] Remove all `span.add_event()` calls++### Testing+- [ ] Run all tests from Testing Checklist above+- [ ] Verify events in OTel collector/console+- [ ] Validate message structures against JSON schemas+- [ ] Test with real provider API+- [ ] Load test with streaming operations++### Documentation+- [ ] Update provider README with event support+- [ ] Add examples showing event usage+- [ ] Document any provider-specific quirks+- [ ] Update changelog++---++## Questions?++If you encounter issues not covered in this guide:++1. Check the OpenAI reference implementation+2. Review the OTel Gen-AI spec+3. Look at `events.py` for event provider setup+4. Check `__helpers.py` for `otel_event()` helper++---++**Last Updated:** 2026-02-12+**Reference Implementation:** OpenAI instrumentation (Phases 1-6 complete)+**Status:** Production-ready ✅diff --git a/contributors/OTEL_ATTRIBUTE_MAPPING.md b/contributors/OTEL_ATTRIBUTE_MAPPING.mdnew file mode 100644index 00000000..8c4848e8--- /dev/null+++ b/contributors/OTEL_ATTRIBUTE_MAPPING.md@@ -0,0 +1,527 @@+# OTel Gen-AI Attribute Mapping Reference++Quick reference for mapping provider-specific parameters to OpenTelemetry Gen-AI semantic convention attributes.++---++## Event Names++| Purpose | OTel Event Name |+|---------|----------------|+| Inference operations (chat, completion, embedding, etc.) | `gen_ai.client.inference.operation.details` |+| Evaluation results (hallucination, bias, toxicity) | `gen_ai.evaluation.result` |++---++## Required Attributes (Inference)++| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.operation` | `GEN_AI_OPERATION` | string | Type of operation | `"chat"`, `"completion"`, `"embedding"` |+| `gen_ai.request.model` | `GEN_AI_REQUEST_MODEL` | string | Model requested | `"gpt-4"`, `"claude-3-opus"` |+| `gen_ai.response.model` | `GEN_AI_RESPONSE_MODEL` | string | Model that responded | `"gpt-4-0613"` |++---++## Content Attributes (Chat/Completions)++| OTel Attribute | Constant | Type | Description | Format |+|----------------|----------|------|-------------|--------|+| `gen_ai.input.messages` | `GEN_AI_INPUT_MESSAGES` | array | Structured input messages | See [Input Message Schema](#input-message-schema) |+| `gen_ai.output.messages` | `GEN_AI_OUTPUT_MESSAGES` | array | Structured output messages | See [Output Message Schema](#output-message-schema) |+| `gen_ai.system_instructions` | `GEN_AI_SYSTEM_INSTRUCTIONS` | string | System prompt (alternative to messages) | `"You are a helpful assistant"` |+| `gen_ai.tool.definitions` | `GEN_AI_TOOL_DEFINITIONS` | array | Available tool/function definitions | See [Tool Definition Schema](#tool-definition-schema) |++---++## Request Parameters (Optional)++| OTel Attribute | Constant | Type | Provider Parameter | Default |+|----------------|----------|------|-------------------|---------|+| `gen_ai.request.temperature` | `GEN_AI_REQUEST_TEMPERATURE` | double | `temperature` | Provider-specific |+| `gen_ai.request.max_tokens` | `GEN_AI_REQUEST_MAX_TOKENS` | int | `max_tokens`, `max_completion_tokens` | Provider-specific |+| `gen_ai.request.top_p` | `GEN_AI_REQUEST_TOP_P` | double | `top_p` | 1.0 |+| `gen_ai.request.top_k` | `GEN_AI_REQUEST_TOP_K` | int | `top_k` | Provider-specific |+| `gen_ai.request.frequency_penalty` | `GEN_AI_REQUEST_FREQUENCY_PENALTY` | double | `frequency_penalty` | 0.0 |+| `gen_ai.request.presence_penalty` | `GEN_AI_REQUEST_PRESENCE_PENALTY` | double | `presence_penalty` | 0.0 |+| `gen_ai.request.stop_sequences` | `GEN_AI_REQUEST_STOP_SEQUENCES` | array[string] | `stop` | `[]` |+| `gen_ai.request.seed` | `GEN_AI_REQUEST_SEED` | int | `seed` | None |++---++## Response Metadata (Recommended)++| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.response.id` | `GEN_AI_RESPONSE_ID` | string | Unique response identifier | `"chatcmpl-123"` |+| `gen_ai.response.finish_reasons` | `GEN_AI_RESPONSE_FINISH_REASONS` | array[string] | Why generation stopped | `["stop"]`, `["max_tokens"]` |+| `gen_ai.response.choice_count` | `GEN_AI_RESPONSE_CHOICE_COUNT` | int | Number of choices returned | `1` |+| `gen_ai.response.output_type` | `GEN_AI_RESPONSE_OUTPUT_TYPE` | string | Output format type | `"text"`, `"json_object"` |++---++## Usage Metrics (Recommended)++| OTel Attribute | Constant | Type | Description |+|----------------|----------|------|-------------|+| `gen_ai.usage.input_tokens` | `GEN_AI_USAGE_INPUT_TOKENS` | int | Tokens in input/prompt |+| `gen_ai.usage.output_tokens` | `GEN_AI_USAGE_OUTPUT_TOKENS` | int | Tokens in output/completion |++---++## Server Attributes (Recommended)++| OTel Attribute | Type | Description | Example |+|----------------|------|-------------|---------|+| `server.address` | string | API server hostname/IP | `"api.openai.com"`, `"api.anthropic.com"` |+| `server.port` | int | API server port | `443` |++---++## Evaluation Attributes++| OTel Attribute | Constant | Type | Required | Description | Example |+|----------------|----------|------|----------|-------------|---------|+| `gen_ai.evaluation.name` | `GEN_AI_EVALUATION_NAME` | string | Yes | Type of evaluation | `"hallucination"`, `"bias_detection"` |+| `gen_ai.evaluation.score.value` | `GEN_AI_EVALUATION_SCORE_VALUE` | double | Conditional | Numerical score (0.0-1.0) | `0.85` |+| `gen_ai.evaluation.score.label` | `GEN_AI_EVALUATION_SCORE_LABEL` | string | Conditional | Human-readable label | `"yes"`, `"no"`, `"pass"`, `"fail"` |+| `gen_ai.evaluation.explanation` | `GEN_AI_EVALUATION_EXPLANATION` | string | Recommended | Brief explanation | `"The output contains factual inaccuracies"` |+| `gen_ai.response.id` | `GEN_AI_RESPONSE_ID` | string | Recommended | Response being evaluated | `"chatcmpl-123"` |++---++## Input Message Schema++### Structure+```json+[+ {+ "role": "user|assistant|system|tool",+ "parts": [+ {"type": "text", "content": "..."},+ {"type": "uri", "modality": "image|audio|video", "uri": "https://..."},+ {"type": "tool_call", "id": "...", "name": "...", "arguments": {...}},+ {"type": "tool_call_response", "id": "...", "response": "..."}+ ]+ }+]+```++### Part Types++#### Text Part+```json+{+ "type": "text",+ "content": "What is the weather?"+}+```++#### URI Part (Image/Audio/Video)+```json+{+ "type": "uri",+ "modality": "image",+ "uri": "https://example.com/image.jpg"+}+```++**Important:** Never include data URIs (`data:image/png;base64,...`). Only HTTP/HTTPS URLs.++#### Tool Call Part (in assistant messages)+```json+{+ "type": "tool_call",+ "id": "call_123",+ "name": "get_weather",+ "arguments": {+ "location": "San Francisco",+ "unit": "celsius"+ }+}+```++#### Tool Call Response Part (in tool messages)+```json+{+ "type": "tool_call_response",+ "id": "call_123",+ "response": "The weather is 20°C and sunny"+}+```++### Example: Complete Input Messages++```python+input_messages = [+ {+ "role": "system",+ "parts": [+ {"type": "text", "content": "You are a helpful assistant"}+ ]+ },+ {+ "role": "user",+ "parts": [+ {"type": "text", "content": "What's in this image?"},+ {"type": "uri", "modality": "image", "uri": "https://example.com/photo.jpg"}+ ]+ },+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "Let me analyze it."},+ {+ "type": "tool_call",+ "id": "call_abc123",+ "name": "analyze_image",+ "arguments": {"image_url": "https://example.com/photo.jpg"}+ }+ ]+ },+ {+ "role": "tool",+ "parts": [+ {+ "type": "tool_call_response",+ "id": "call_abc123",+ "response": "The image shows a cat sitting on a couch"+ }+ ]+ },+ {+ "role": "user",+ "parts": [+ {"type": "text", "content": "What breed is it?"}+ ]+ }+]+```++---++## Output Message Schema++### Structure+```json+[+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "..."},+ {"type": "tool_call", "id": "...", "name": "...", "arguments": {...}}+ ],+ "finish_reason": "stop|max_tokens|tool_calls|content_filter|..."+ }+]+```++**Note:** Output messages array typically contains only ONE message (the assistant's response for choice 0).++### Finish Reasons++Map provider-specific finish reasons to OTel standard values:++| Provider | Provider Value | OTel Value |+|----------|---------------|------------|+| OpenAI | `"stop"` | `"stop"` |+| OpenAI | `"length"` | `"max_tokens"` |+| OpenAI | `"tool_calls"` | `"tool_calls"` |+| OpenAI | `"content_filter"` | `"content_filter"` |+| Anthropic | `"end_turn"` | `"stop"` |+| Anthropic | `"max_tokens"` | `"max_tokens"` |+| Anthropic | `"stop_sequence"` | `"stop"` |+| Google | `"STOP"` | `"stop"` |+| Google | `"MAX_TOKENS"` | `"max_tokens"` |+| Google | `"SAFETY"` | `"content_filter"` |+| Cohere | `"COMPLETE"` | `"stop"` |+| Cohere | `"MAX_TOKENS"` | `"max_tokens"` |++### Example: Output Message++```python+output_messages = [+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "Based on the image analysis, it appears to be a British Shorthair cat."}+ ],+ "finish_reason": "stop"+ }+]+```++### Example: Output with Tool Call++```python+output_messages = [+ {+ "role": "assistant",+ "parts": [+ {"type": "text", "content": "I'll check the weather for you."},+ {+ "type": "tool_call",+ "id": "call_xyz789",+ "name": "get_weather",+ "arguments": {+ "location": "San Francisco",+ "unit": "celsius"+ }+ }+ ],+ "finish_reason": "tool_calls"+ }+]+```++---++## Tool Definition Schema++### Structure+```json+[+ {+ "type": "function",+ "function": {+ "name": "function_name",+ "description": "What the function does",+ "parameters": {+ "type": "object",+ "properties": {+ "param_name": {+ "type": "string|number|boolean|object|array",+ "description": "Parameter description",+ "enum": ["optional", "list", "of", "values"]+ }+ },+ "required": ["param_name"]+ }+ }+ }+]+```++### Example: Weather Function++```python+tool_definitions = [+ {+ "type": "function",+ "function": {+ "name": "get_weather",+ "description": "Get the current weather for a location",+ "parameters": {+ "type": "object",+ "properties": {+ "location": {+ "type": "string",+ "description": "The city name, e.g., 'San Francisco'"+ },+ "unit": {+ "type": "string",+ "enum": ["celsius", "fahrenheit"],+ "description": "Temperature unit"+ }+ },+ "required": ["location"]+ }+ }+ }+]+```++---++## Provider Parameter Mapping++### OpenAI / Azure OpenAI++| OpenAI Parameter | OTel Attribute | Notes |+|------------------|----------------|-------|+| `messages` | `gen_ai.input.messages` | Transform to structured format |+| `model` | `gen_ai.request.model` | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Direct mapping |+| `max_tokens` | `gen_ai.request.max_tokens` | Direct mapping |+| `top_p` | `gen_ai.request.top_p` | Direct mapping |+| `frequency_penalty` | `gen_ai.request.frequency_penalty` | Direct mapping |+| `presence_penalty` | `gen_ai.request.presence_penalty` | Direct mapping |+| `stop` | `gen_ai.request.stop_sequences` | Direct mapping |+| `seed` | `gen_ai.request.seed` | Direct mapping |+| `tools` | `gen_ai.tool.definitions` | Direct mapping |+| `response_format.type` | `gen_ai.response.output_type` | Direct mapping |++Response mapping:+| OpenAI Field | OTel Attribute |+|--------------|----------------|+| `id` | `gen_ai.response.id` |+| `model` | `gen_ai.response.model` |+| `choices[0].message.content` | Part of `gen_ai.output.messages` |+| `choices[0].message.tool_calls` | Part of `gen_ai.output.messages` |+| `choices[0].finish_reason` | Part of `gen_ai.output.messages[0].finish_reason` |+| `usage.prompt_tokens` | `gen_ai.usage.input_tokens` |+| `usage.completion_tokens` | `gen_ai.usage.output_tokens` |++### Anthropic++| Anthropic Parameter | OTel Attribute | Notes |+|---------------------|----------------|-------|+| `messages` | `gen_ai.input.messages` | Transform to structured format |+| `system` | `gen_ai.system_instructions` | Single string (not in messages array) |+| `model` | `gen_ai.request.model` | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Direct mapping |+| `max_tokens` | `gen_ai.request.max_tokens` | Direct mapping |+| `top_p` | `gen_ai.request.top_p` | Direct mapping |+| `top_k` | `gen_ai.request.top_k` | Direct mapping |+| `stop_sequences` | `gen_ai.request.stop_sequences` | Direct mapping |+| `tools` | `gen_ai.tool.definitions` | Transform if needed |++Response mapping:+| Anthropic Field | OTel Attribute |+|-----------------|----------------|+| `id` | `gen_ai.response.id` |+| `model` | `gen_ai.response.model` |+| `content[0].text` | Part of `gen_ai.output.messages` |+| `content[*].type="tool_use"` | Part of `gen_ai.output.messages` |+| `stop_reason` | Map to `gen_ai.output.messages[0].finish_reason` |+| `usage.input_tokens` | `gen_ai.usage.input_tokens` |+| `usage.output_tokens` | `gen_ai.usage.output_tokens` |++### Google (Gemini)++| Google Parameter | OTel Attribute | Notes |+|------------------|----------------|-------|+| `contents` | `gen_ai.input.messages` | Already uses "parts" structure |+| `systemInstruction` | `gen_ai.system_instructions` | Direct mapping |+| `model` | `gen_ai.request.model` | Extract from full name |+| `generationConfig.temperature` | `gen_ai.request.temperature` | Direct mapping |+| `generationConfig.maxOutputTokens` | `gen_ai.request.max_tokens` | Direct mapping |+| `generationConfig.topP` | `gen_ai.request.top_p` | Direct mapping |+| `generationConfig.topK` | `gen_ai.request.top_k` | Direct mapping |+| `generationConfig.stopSequences` | `gen_ai.request.stop_sequences` | Direct mapping |+| `tools` | `gen_ai.tool.definitions` | Transform `function_declarations` |++Response mapping:+| Google Field | OTel Attribute |+|--------------|----------------|+| Response doesn't have ID | `gen_ai.response.id` = None |+| Extracted from request | `gen_ai.response.model` |+| `candidates[0].content.parts[0].text` | Part of `gen_ai.output.messages` |+| `candidates[0].content.parts[*].functionCall` | Part of `gen_ai.output.messages` |+| `candidates[0].finishReason` | Map to `gen_ai.output.messages[0].finish_reason` |+| `usageMetadata.promptTokenCount` | `gen_ai.usage.input_tokens` |+| `usageMetadata.candidatesTokenCount` | `gen_ai.usage.output_tokens` |++### Cohere++| Cohere Parameter | OTel Attribute | Notes |+|------------------|----------------|-------|+| `message` | `gen_ai.input.messages` | Transform to array with user role |+| `chat_history` | `gen_ai.input.messages` | Combine with message |+| `preamble` | `gen_ai.system_instructions` | Direct mapping |+| `model` | `gen_ai.request.model` | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Direct mapping |+| `max_tokens` | `gen_ai.request.max_tokens` | Direct mapping |+| `p` | `gen_ai.request.top_p` | Direct mapping |+| `k` | `gen_ai.request.top_k` | Direct mapping |+| `stop_sequences` | `gen_ai.request.stop_sequences` | Direct mapping |+| `tools` | `gen_ai.tool.definitions` | Transform format |++Response mapping:+| Cohere Field | OTel Attribute |+|--------------|----------------|+| `generation_id` | `gen_ai.response.id` |+| From request | `gen_ai.response.model` |+| `text` | Part of `gen_ai.output.messages` |+| `tool_calls` | Part of `gen_ai.output.messages` |+| `finish_reason` | Map to `gen_ai.output.messages[0].finish_reason` |+| `meta.tokens.input_tokens` | `gen_ai.usage.input_tokens` |+| `meta.tokens.output_tokens` | `gen_ai.usage.output_tokens` |++---++## Common Patterns++### Pattern 1: Extract Request Attributes++```python+def extract_request_attributes(kwargs):+ """Extract all available request parameters"""+ return {+ "temperature": kwargs.get("temperature"),+ "max_tokens": kwargs.get("max_tokens"),+ "top_p": kwargs.get("top_p"),+ "frequency_penalty": kwargs.get("frequency_penalty"),+ "presence_penalty": kwargs.get("presence_penalty"),+ "stop_sequences": kwargs.get("stop"),+ "seed": kwargs.get("seed"),+ }+```++### Pattern 2: Extract Response Attributes++```python+def extract_response_attributes(response):+ """Extract all available response metadata"""+ return {+ "response_id": response.id,+ "finish_reasons": [choice.finish_reason for choice in response.choices],+ "choice_count": len(response.choices),+ "output_type": response.object, # or from request+ "input_tokens": response.usage.prompt_tokens,+ "output_tokens": response.usage.completion_tokens,+ }+```++### Pattern 3: Combine Attributes for Event++```python+# In processing function+request_attrs = extract_request_attributes(kwargs)+response_attrs = extract_response_attributes(response)++emit_inference_event(+ event_provider=event_provider,+ operation_name=operation_type,+ request_model=request_model,+ response_model=response_model,+ input_messages=input_messages,+ output_messages=output_messages,+ tool_definitions=tool_definitions,+ server_address=server_address,+ server_port=443,+ **request_attrs,+ **response_attrs+)+```++---++## Validation Checklist++When implementing event emission:++- [ ] Event name is exactly `gen_ai.client.inference.operation.details`+- [ ] Input messages are structured objects (not JSON strings)+- [ ] Output messages are structured objects (not JSON strings)+- [ ] No data URIs in image references (only HTTP/HTTPS)+- [ ] All required attributes present+- [ ] Finish reasons mapped to OTel standard values+- [ ] Tool definitions included when tools are used+- [ ] Request parameters included when available+- [ ] Response metadata included when available+- [ ] Usage tokens included when available+- [ ] Server address/port included when known++---++## References++- [OTel Gen-AI Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md)+- [OTel Gen-AI Attributes](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/README.md)+- [Input Messages JSON Schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-input-messages.json)+- [Output Messages JSON Schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-output-messages.json)++---++**Last Updated:** 2026-02-12diff --git a/contributors/PROVIDER_MIGRATION_CHECKLIST.md b/contributors/PROVIDER_MIGRATION_CHECKLIST.mdnew file mode 100644index 00000000..f8715710--- /dev/null+++ b/contributors/PROVIDER_MIGRATION_CHECKLIST.md@@ -0,0 +1,421 @@+# Provider Events Migration Checklist++**Provider Name:** `_________________`+**Date Started:** `_________________`+**Assignee:** `_________________`+**Status:** `[ ] Not Started` `[ ] In Progress` `[ ] Testing` `[ ] Complete`++---++## Phase 1: Planning & Analysis++### Provider Research+- [ ] Reviewed provider API documentation+- [ ] Identified all supported operations:+ - [ ] Chat/Completions+ - [ ] Embeddings+ - [ ] Image Generation+ - [ ] Audio/Speech+ - [ ] Other: `________________`+- [ ] Documented message format differences+- [ ] Created parameter mapping table+- [ ] Created finish reason mapping table++### Current State Analysis+- [ ] Found all existing `span.add_event()` calls+ - Location 1: `_______________________` Line: `____`+ - Location 2: `_______________________` Line: `____`+ - Location 3: `_______________________` Line: `____`+- [ ] Documented current span attributes+- [ ] Ran existing test suite (baseline)+ - Tests passed: `____` Failed: `____`++---++## Phase 2: Semantic Conventions++### File: `src/openlit/semcov/__init__.py`++- [ ] Added `GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS`+- [ ] Added `GEN_AI_INPUT_MESSAGES`+- [ ] Added `GEN_AI_OUTPUT_MESSAGES`+- [ ] Added `GEN_AI_SYSTEM_INSTRUCTIONS` (if applicable)+- [ ] Added `GEN_AI_TOOL_DEFINITIONS` (if applicable)+- [ ] Added provider-specific constants (if needed)+ - [ ] `_______________________`++---++## Phase 3: Helper Functions++### File: `src/openlit/instrumentation/<provider>/utils.py`++#### build_input_messages()+- [ ] Created function signature+- [ ] Handles text messages+- [ ] Handles multi-part messages+- [ ] Handles images (URI only, no data URIs)+- [ ] Handles tool call responses+- [ ] Handles provider-specific message types:+ - [ ] `_______________________`+- [ ] Returns structured objects (not JSON strings)+- [ ] Added error handling+- [ ] Added unit tests++#### build_output_messages()+- [ ] Created function signature+- [ ] Handles text responses+- [ ] Handles tool calls+- [ ] Maps finish reasons correctly+- [ ] Returns structured objects (not JSON strings)+- [ ] Added error handling+- [ ] Added unit tests++#### build_tool_definitions()+- [ ] Created function signature+- [ ] Extracts tool definitions from request+- [ ] Normalizes to OTel format+- [ ] Handles provider-specific format:+ - [ ] `_______________________`+- [ ] Returns None if no tools+- [ ] Added error handling+- [ ] Added unit tests++#### emit_inference_event()+- [ ] Created centralized emission function+- [ ] Maps all required attributes+- [ ] Maps all recommended attributes+- [ ] Maps optional attributes+- [ ] Uses `otel_event()` helper+- [ ] Includes comprehensive error handling+- [ ] Never raises exceptions+- [ ] Logs warnings on failure+- [ ] Added unit tests++---++## Phase 4: Processing Functions++### Update common logic functions++#### Chat/Completions Processing+- [ ] Added `event_provider` parameter+- [ ] **KEPT** existing span attributes+- [ ] **REMOVED** `span.add_event()` calls+- [ ] Added event emission with `capture_message_content` check+- [ ] Builds input messages+- [ ] Builds output messages+- [ ] Builds tool definitions+- [ ] Passes all attributes to `emit_inference_event()`+- [ ] Added error handling++#### Embeddings Processing (if applicable)+- [ ] Added `event_provider` parameter+- [ ] Added event emission logic+- [ ] Handles single text input+- [ ] Handles array of texts+- [ ] Added error handling++#### Image Generation Processing (if applicable)+- [ ] Added `event_provider` parameter+- [ ] Added event emission logic+- [ ] Handles text prompts+- [ ] Handles revised prompts (output)+- [ ] Added error handling++#### Audio/Speech Processing (if applicable)+- [ ] Added `event_provider` parameter+- [ ] Added event emission logic+- [ ] Handles text input+- [ ] Handles audio output references+- [ ] Added error handling++---++## Phase 5: Wrapper Functions (Sync)++### File: `src/openlit/instrumentation/<provider>/<provider>.py`++#### chat_completions()+- [ ] Added `event_provider` parameter to wrapper factory+- [ ] Updated `TracedSyncStream.__init__()` to accept event_provider+- [ ] Stored event_provider in TracedSyncStream instance+- [ ] Passed event_provider in StopIteration handler+- [ ] Passed event_provider in non-streaming branch+- [ ] Tested streaming responses+- [ ] Tested non-streaming responses++#### embeddings()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested with single text+- [ ] Tested with text array++#### image_generation()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested single image+- [ ] Tested multiple images++#### audio_create()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested text-to-speech++#### Other operations:+- [ ] `_________________`: Added event_provider+- [ ] `_________________`: Added event_provider++---++## Phase 6: Wrapper Functions (Async)++### File: `src/openlit/instrumentation/<provider>/async_<provider>.py`++#### async_chat_completions()+- [ ] Added `event_provider` parameter to wrapper factory+- [ ] Updated `TracedAsyncStream.__init__()` to accept event_provider+- [ ] Stored event_provider in TracedAsyncStream instance+- [ ] Passed event_provider in StopAsyncIteration handler+- [ ] Passed event_provider in non-streaming branch+- [ ] Tested async streaming responses+- [ ] Tested async non-streaming responses++#### async_embeddings()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested async embeddings++#### async_image_generation()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested async image generation++#### async_audio_create()+- [ ] Added `event_provider` parameter+- [ ] Passed to processing function+- [ ] Tested async audio++#### Other async operations:+- [ ] `_________________`: Added event_provider+- [ ] `_________________`: Added event_provider++---++## Phase 7: Instrumentation Entry Point++### File: `src/openlit/instrumentation/<provider>/__init__.py`++- [ ] Extracted `event_provider = kwargs.get("event_provider")`+- [ ] Passed to all sync wrapper calls:+ - [ ] chat_completions+ - [ ] embeddings+ - [ ] image_generation+ - [ ] audio_create+ - [ ] Other: `_________________`+- [ ] Passed to all async wrapper calls:+ - [ ] async_chat_completions+ - [ ] async_embeddings+ - [ ] async_image_generation+ - [ ] async_audio_create+ - [ ] Other: `_________________`++---++## Phase 8: Cleanup++- [ ] Verified all `span.add_event()` calls removed+ - Remaining: `____` (should be 0)+- [ ] Verified all span attributes still present+- [ ] Removed any unused imports+- [ ] Ran linter/formatter+- [ ] Updated code comments++---++## Phase 9: Testing++### Unit Tests+- [ ] Added tests for `build_input_messages()`+ - [ ] Text messages+ - [ ] Multi-part messages+ - [ ] Images (URIs)+ - [ ] Tool responses+ - [ ] Edge cases+- [ ] Added tests for `build_output_messages()`+ - [ ] Text responses+ - [ ] Tool calls+ - [ ] Finish reasons+ - [ ] Edge cases+- [ ] Added tests for `build_tool_definitions()`+ - [ ] Function definitions+ - [ ] None/empty tools+- [ ] Added tests for `emit_inference_event()`+ - [ ] All attributes present+ - [ ] Error handling++### Integration Tests++#### Chat/Completions+- [ ] Non-streaming text only+- [ ] Non-streaming with images (if supported)+- [ ] Non-streaming with tools+- [ ] Non-streaming with tool responses+- [ ] Streaming text+- [ ] Streaming with tools+- [ ] Multi-message conversation+- [ ] System messages++#### Embeddings (if applicable)+- [ ] Single text+- [ ] Multiple texts+- [ ] Token array input++#### Image Generation (if applicable)+- [ ] Single image+- [ ] Multiple images+- [ ] With revised prompts++#### Audio (if applicable)+- [ ] Text-to-speech+- [ ] Different voices/models++### Event Validation+- [ ] Event name is `gen_ai.client.inference.operation.details`+- [ ] Input messages are structured (not JSON strings)+- [ ] Output messages are structured (not JSON strings)+- [ ] Messages follow OTel JSON schema format+- [ ] Tool definitions included when present+- [ ] All required attributes present:+ - [ ] `gen_ai.operation`+ - [ ] `gen_ai.request.model`+ - [ ] `gen_ai.response.model`+- [ ] All recommended attributes present (when available):+ - [ ] `gen_ai.system_instructions`+ - [ ] `gen_ai.tool.definitions`+ - [ ] `gen_ai.response.id`+ - [ ] `gen_ai.response.finish_reasons`+ - [ ] `server.address`+ - [ ] `server.port`+- [ ] Optional attributes included (when available):+ - [ ] Request parameters (temperature, max_tokens, etc.)+ - [ ] Response metadata (choice_count, output_type)+ - [ ] Usage tokens (input_tokens, output_tokens)++### Backward Compatibility+- [ ] Existing span attributes still set:+ - [ ] `gen_ai.prompt`+ - [ ] `gen_ai.completion`+ - [ ] All provider-specific attributes+- [ ] Metrics still recorded correctly+- [ ] No span events present (all removed)+- [ ] `capture_message_content=False` skips events+- [ ] `event_provider=None` skips events+- [ ] Existing functionality unchanged++### Error Handling+- [ ] Event emission failure doesn't break instrumentation+- [ ] Malformed messages handled gracefully+- [ ] Missing fields don't cause crashes+- [ ] Non-serializable objects handled+- [ ] Exceptions logged but not raised++### Performance Testing+- [ ] No significant latency increase+ - Baseline: `____ms` New: `____ms`+- [ ] No memory leaks with streaming+- [ ] Event size reasonable (<100KB per event)+- [ ] No base64 images in events++### Manual Verification+- [ ] Events visible in console exporter+- [ ] Events visible in OTLP collector+- [ ] Message structure validated against JSON schema+- [ ] Tested with real provider API+- [ ] Tested with rate limits/errors++---++## Phase 10: Documentation++- [ ] Updated provider README with event support+- [ ] Added example code showing event usage+- [ ] Documented provider-specific message format differences+- [ ] Documented finish reason mappings+- [ ] Added troubleshooting section+- [ ] Updated CHANGELOG.md+- [ ] Added migration notes (if breaking changes)++---++## Phase 11: Code Review++- [ ] Self-review completed+- [ ] Peer review requested+- [ ] All review comments addressed+- [ ] CI/CD pipeline passing+- [ ] Test coverage maintained/improved+ - Previous: `____%` New: `____%`++---++## Phase 12: Deployment++- [ ] Merged to main branch+- [ ] Version bumped (if applicable)+- [ ] Release notes prepared+- [ ] Released to production+- [ ] Monitoring dashboards updated+- [ ] Announced to team/users++---++## Notes & Issues++### Provider-Specific Quirks+```+Document any unusual behavior, workarounds, or special handling required:++1.++2.++3.+```++### Open Questions+```+List any unresolved questions or items needing clarification:++1.++2.++3.+```++### Known Issues+```+Document any known issues or limitations:++1.++2.++3.+```++---++## Sign-Off++- [ ] Developer: `_________________` Date: `_________`+- [ ] Reviewer: `_________________` Date: `_________`+- [ ] QA: `_________________` Date: `_________`++---++**Reference Documentation:**+- [Events Migration Guide](./EVENTS_MIGRATION_GUIDE.md)+- [OTel Gen-AI Events Spec](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md)+- [OpenAI Reference Implementation](./src/openlit/instrumentation/openai/)diff --git a/sdk/python/src/openlit/__init__.py b/sdk/python/src/openlit/__init__.pyindex 0cb992f8..6b814aac 100644--- a/sdk/python/src/openlit/__init__.py+++ b/sdk/python/src/openlit/__init__.py@@ -17,8 +17,6 @@ import requestsfrom opentelemetry import trace as tfrom opentelemetry.trace import SpanKind, Status, StatusCode, Spanfrom opentelemetry.sdk.resources import SERVICE_NAME, DEPLOYMENT_ENVIRONMENT--from openlit.semcov import SemanticConventionfrom openlit.otel.tracing import setup_tracingfrom openlit.otel.metrics import setup_meter@@ -36,9 +34,6 @@ import openlit.evals# Set up logging for error and information messages.logger = logging.getLogger(__name__)-tracer = t.get_tracer(__name__)--class OpenlitConfig:"""@@ -93,7 +88,7 @@ class OpenlitConfig:cls,environment,application_name,- otel_tracer,+ tracer,event_provider,otlp_endpoint,otlp_headers,@@ -112,7 +107,7 @@ class OpenlitConfig:Args:environment (str): Deployment environment.application_name (str): Application name.- otel_tracer: Tracer instance.+ tracer: Tracer instance.event_provider: Event logger provider instance.meter: Metric Instanceotlp_endpoint (str): OTLP endpoint.@@ -129,7 +124,7 @@ class OpenlitConfig:cls.environment = environmentcls.application_name = application_namecls.pricing_info = fetch_pricing_info(pricing_json)- cls.tracer = otel_tracer+ cls.tracer = tracercls.event_provider = event_providercls.metrics_dict = metrics_dictcls.otlp_endpoint = otlp_endpoint@@ -219,7 +214,7 @@ def init(environment="default",application_name="default",service_name="default",- otel_tracer=None,+ tracer=None,event_logger=None,otlp_endpoint=None,otlp_headers=None,@@ -244,7 +239,7 @@ def init(Args:environment (str): Deployment environment.application_name (str): Application name.- otel_tracer: Tracer instance (Optional).+ tracer: Tracer instance (Optional).event_logger: EventLoggerProvider instance (Optional).meter: OpenTelemetry Metrics Instance (Optional).otlp_endpoint (str): OTLP endpoint for exporter (Optional).@@ -332,16 +327,16 @@ def init(config = OpenlitConfig()# Setup tracing based on the provided or default configuration.- configured_tracer = setup_tracing(+ tracer = setup_tracing(application_name=final_service_name,environment=environment,- tracer=otel_tracer,+ tracer=tracer,otlp_endpoint=otlp_endpoint,otlp_headers=otlp_headers,disable_batch=disable_batch,)- if not configured_tracer:+ if not tracer:logger.error("OpenLIT tracing setup failed. Tracing will not be available.")return@@ -385,7 +380,7 @@ def init(config.update_config(environment,final_service_name,- otel_tracer,+ tracer,event_provider,otlp_endpoint,otlp_headers,@@ -538,37 +533,25 @@ def get_secrets(url=None, api_key=None, key=None, tags=None, should_set_env=None# Prepare headersheaders = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}- with tracer.start_as_current_span("promptflow.request") as span:- span.set_attribute("http.method", "POST")- span.set_attribute("http.url", endpoint)-- try:- response = requests.post(- endpoint,- json=payload,- headers=headers,- timeout=120- )-- span.set_attribute("http.status_code", response.status_code)-- response.raise_for_status()- vault_response = response.json()-- res = vault_response.get("res", [])+ try:+ # Make the POST request to the API with headers+ response = requests.post(endpoint, json=payload, headers=headers, timeout=120)- if should_set_env is True:- for token, value in res.items():- os.environ[token] = str(value)+ # Check if the response is successful+ response.raise_for_status()- return vault_response+ # Return the JSON response+ vault_response = response.json()- except requests.RequestException as error:- span.record_exception(error)- span.set_status(Status(StatusCode.ERROR))- logger.error("Error fetching secrets: '%s'", error)- return None+ res = vault_response.get("res", [])+ if should_set_env is True:+ for token, value in res.items():+ os.environ[token] = str(value)+ return vault_response+ except requests.RequestException as error:+ logger.error("Error fetching secrets: '%s'", error)+ return Nonedef trace(wrapped):@@ -582,7 +565,7 @@ def trace(wrapped):try:__trace = t.get_tracer_provider()- otel_tracer = __trace.get_tracer(__name__)+ tracer = __trace.get_tracer(__name__)except Exception as tracer_exception:logging.error("Failed to initialize tracer: %s", tracer_exception, exc_info=True@@ -591,7 +574,7 @@ def trace(wrapped):@wraps(wrapped)def wrapper(*args, **kwargs):- with otel_tracer.start_as_current_span(+ with tracer.start_as_current_span(name=wrapped.__name__,kind=SpanKind.CLIENT,) as span:diff --git a/sdk/python/src/openlit/evals/__init__.py b/sdk/python/src/openlit/evals/__init__.pyindex 537852fb..633a3959 100644--- a/sdk/python/src/openlit/evals/__init__.py+++ b/sdk/python/src/openlit/evals/__init__.py@@ -10,3 +10,4 @@ from openlit.evals.hallucination import Hallucinationfrom openlit.evals.bias_detection import BiasDetectorfrom openlit.evals.toxicity import ToxicityDetectorfrom openlit.evals.all import All+from openlit.evals.utils import emit_evaluation_eventdiff --git a/sdk/python/src/openlit/evals/all.py b/sdk/python/src/openlit/evals/all.pyindex 73ff9113..f3763c91 100644--- a/sdk/python/src/openlit/evals/all.py+++ b/sdk/python/src/openlit/evals/all.py@@ -125,6 +125,7 @@ class All:custom_categories: Optional[Dict[str, str]] = None,collect_metrics: Optional[bool] = False,threshold_score: Optional[float] = 0.5,+ event_provider=None,):"""Initializes the All Evals detector with specified LLM settings, custom rules, and categories.@@ -149,6 +150,7 @@ class All:self.collect_metrics = collect_metricsself.custom_categories = custom_categoriesself.threshold_score = threshold_score+ self.event_provider = event_providerself.system_prompt = get_system_prompt(self.custom_categories, self.threshold_score)@@ -195,4 +197,17 @@ class All:)eval_counter.add(1, attributes)+ # Emit evaluation event+ if self.event_provider:+ from openlit.evals.utils import emit_evaluation_event++ emit_evaluation_event(+ event_provider=self.event_provider,+ evaluation_name=result.evaluation,+ score_value=result.score,+ score_label=result_verdict,+ explanation=result.explanation,+ response_id=None,+ )+return resultdiff --git a/sdk/python/src/openlit/evals/bias_detection.py b/sdk/python/src/openlit/evals/bias_detection.pyindex cfae70c3..b68eec95 100644--- a/sdk/python/src/openlit/evals/bias_detection.py+++ b/sdk/python/src/openlit/evals/bias_detection.py@@ -127,6 +127,7 @@ class BiasDetector:custom_categories: Optional[Dict[str, str]] = None,collect_metrics: Optional[bool] = False,threshold_score: Optional[float] = 0.5,+ event_provider=None,):"""Initializes the Bias detector with specified LLM settings, custom rules, and categories.@@ -151,6 +152,7 @@ class BiasDetector:self.collect_metrics = collect_metricsself.custom_categories = custom_categoriesself.threshold_score = threshold_score+ self.event_provider = event_providerself.system_prompt = get_system_prompt(self.custom_categories, self.threshold_score)@@ -197,4 +199,17 @@ class BiasDetector:)eval_counter.add(1, attributes)+ # Emit evaluation event+ if self.event_provider:+ from openlit.evals.utils import emit_evaluation_event++ emit_evaluation_event(+ event_provider=self.event_provider,+ evaluation_name=result.evaluation,+ score_value=result.score,+ score_label=result_verdict,+ explanation=result.explanation,+ response_id=None,+ )+return resultdiff --git a/sdk/python/src/openlit/evals/hallucination.py b/sdk/python/src/openlit/evals/hallucination.pyindex 5ba406d5..7b11388f 100644--- a/sdk/python/src/openlit/evals/hallucination.py+++ b/sdk/python/src/openlit/evals/hallucination.py@@ -127,6 +127,7 @@ class Hallucination:custom_categories: Optional[Dict[str, str]] = None,collect_metrics: Optional[bool] = False,threshold_score: Optional[float] = 0.5,+ event_provider=None,):"""Initializes the Hallucination detector with specified LLM settings, custom rules, and categories.@@ -153,6 +154,7 @@ class Hallucination:self.collect_metrics = collect_metricsself.custom_categories = custom_categoriesself.threshold_score = threshold_score+ self.event_provider = event_providerself.system_prompt = get_system_prompt(self.custom_categories, self.threshold_score)@@ -198,4 +200,17 @@ class Hallucination:)eval_counter.add(1, attributes)+ # Emit evaluation event+ if self.event_provider:+ from openlit.evals.utils import emit_evaluation_event++ emit_evaluation_event(+ event_provider=self.event_provider,+ evaluation_name=result.evaluation,+ score_value=result.score,+ score_label=result_verdict,+ explanation=result.explanation,+ response_id=None,+ )+return resultdiff --git a/sdk/python/src/openlit/evals/toxicity.py b/sdk/python/src/openlit/evals/toxicity.pyindex 6d90acd9..98d1acd3 100644--- a/sdk/python/src/openlit/evals/toxicity.py+++ b/sdk/python/src/openlit/evals/toxicity.py@@ -122,6 +122,7 @@ class ToxicityDetector:custom_categories: Optional[Dict[str, str]] = None,collect_metrics: Optional[bool] = False,threshold_score: Optional[float] = 0.5,+ event_provider=None,):"""Initializes the toxicity detector with specified LLM settings, custom rules, and categories.@@ -148,6 +149,7 @@ class ToxicityDetector:self.collect_metrics = collect_metricsself.custom_categories = custom_categoriesself.threshold_score = threshold_score+ self.event_provider = event_providerself.system_prompt = get_system_prompt(self.custom_categories, self.threshold_score)@@ -194,4 +196,17 @@ class ToxicityDetector:)eval_counter.add(1, attributes)+ # Emit evaluation event+ if self.event_provider:+ from openlit.evals.utils import emit_evaluation_event++ emit_evaluation_event(+ event_provider=self.event_provider,+ evaluation_name=result.evaluation,+ score_value=result.score,+ score_label=result_verdict,+ explanation=result.explanation,+ response_id=None,+ )+return resultdiff --git a/sdk/python/src/openlit/evals/utils.py b/sdk/python/src/openlit/evals/utils.pyindex 8792d359..5e6954aa 100644--- a/sdk/python/src/openlit/evals/utils.py+++ b/sdk/python/src/openlit/evals/utils.py@@ -297,3 +297,54 @@ def eval_metric_attributes(verdict, score, validator, classification, explanatioSemanticConvention.EVAL_CLASSIFICATION: classification,SemanticConvention.EVAL_EXPLANATION: explanation,}+++def emit_evaluation_event(+ event_provider,+ evaluation_name,+ score_value,+ score_label,+ explanation,+ response_id=None,+):+ """+ Emit gen_ai.evaluation.result event.++ Args:+ event_provider: The OTel event provider+ evaluation_name: Name of evaluation (hallucination, bias_detection, toxicity_detection)+ score_value: Numerical score 0.0-1.0+ score_label: Human-readable label (yes/no or pass/fail)+ explanation: Brief explanation of evaluation result+ response_id: Optional response ID for correlation+ """+ try:+ if not event_provider:+ return++ from openlit.__helpers import otel_event++ # Build event attributes per OTel spec+ attributes = {+ SemanticConvention.GEN_AI_EVALUATION_NAME: evaluation_name,+ SemanticConvention.GEN_AI_EVALUATION_SCORE_VALUE: float(score_value),+ SemanticConvention.GEN_AI_EVALUATION_SCORE_LABEL: score_label,+ }++ # Add recommended attributes+ if explanation:+ attributes[SemanticConvention.GEN_AI_EVALUATION_EXPLANATION] = explanation+ if response_id:+ attributes[SemanticConvention.GEN_AI_RESPONSE_ID] = response_id++ # Create and emit event+ event = otel_event(+ name=SemanticConvention.GEN_AI_EVALUATION_RESULT,+ attributes=attributes,+ body="", # Per spec, all data in attributes+ )++ event_provider.emit(event)++ except Exception as e:+ logger.warning("Failed to emit evaluation event: %s", e, exc_info=True)diff --git a/sdk/python/src/openlit/instrumentation/agno/agno.py b/sdk/python/src/openlit/instrumentation/agno/agno.pyindex b4643f01..12d8e288 100644--- a/sdk/python/src/openlit/instrumentation/agno/agno.py+++ b/sdk/python/src/openlit/instrumentation/agno/agno.py@@ -45,10 +45,6 @@ def agent_run_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract agent name for span naming with fallback to agent_idagent_name = (getattr(instance, "name", None)@@ -114,10 +110,6 @@ def agent_run_tool_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract tool information for span namingtool = args[1] if len(args) > 1 else None # tool: ToolExecutiontool_name = "unknown_tool"@@ -182,10 +174,6 @@ def agent_continue_run_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-agent_name = getattr(instance, "name", "unknown")span_name = f"continue {agent_name}"@@ -243,10 +231,6 @@ def agent_add_tool_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-agent_name = getattr(instance, "name", "unknown")span_name = f"agent {agent_name}"@@ -304,10 +288,6 @@ def session_memory_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract method name from endpointmethod_name = gen_ai_endpoint.split(".")[-1]span_name = f"memory {method_name.replace('get_', '').replace('_', ' ')}"@@ -370,10 +350,6 @@ def model_run_function_call_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract function call information for span namingfunction_call = args[0] if args else kwargs.get("function_call", None)function_name = None@@ -448,10 +424,6 @@ def function_call_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract function informationfunction_name = getattr(instance, "name", getattr(instance, "__name__", "unknown_function")@@ -513,10 +485,6 @@ def toolkit_run_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract toolkit informationtoolkit_name = getattr(instance,@@ -581,10 +549,6 @@ def function_entrypoint_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract function information for span namingfunction_name = getattr(instance, "name", None) or getattr(instance, "__name__", "unknown_function"@@ -646,10 +610,6 @@ def function_execute_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract function informationfunction_name = getattr(instance.function, "name", "unknown_function")span_name = f"tool {function_name}"@@ -781,10 +741,6 @@ def reasoning_tool_wrap(if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):return wrapped(*args, **kwargs)- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-# Extract tool name from endpointtool_name = gen_ai_endpoint.split(".")[-1]span_name = f"reasoning {tool_name}"diff --git a/sdk/python/src/openlit/instrumentation/agno/async_agno.py b/sdk/python/src/openlit/instrumentation/agno/async_agno.pyindex 79ea9a78..8155c900 100644--- a/sdk/python/src/openlit/instrumentation/agno/async_agno.py+++ b/sdk/python/src/openlit/instrumentation/agno/async_agno.py@@ -40,10 +40,6 @@ def async_agent_run_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-# Extract agent name for span naming with fallback to agent_idagent_name = (getattr(instance, "name", None)@@ -104,10 +100,6 @@ def async_agent_continue_run_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-agent_name = getattr(instance, "name", "unknown")span_name = f"continue {agent_name}"@@ -162,10 +154,6 @@ def async_model_run_function_call_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-# Extract function call information for span namingfunction_call = args[0] if args else kwargs.get("function_call", None)function_name = None@@ -237,12 +225,6 @@ def async_agent_run_stream_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- async for item in wrapped(*args, **kwargs):- yield item- return-# Extract agent name for span naming with fallback to agent_idagent_name = (getattr(instance, "name", None)@@ -337,12 +319,6 @@ def async_model_run_function_calls_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- async for item in wrapped(*args, **kwargs):- yield item- return-# Extract function calls information for span namingfunction_calls = args[0] if args else []function_names = []@@ -423,10 +399,6 @@ def async_function_entrypoint_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-# Extract function information for span namingfunction_name = getattr(instance, "name", None) or getattr(instance, "__name__", "unknown_function"@@ -484,10 +456,6 @@ def async_function_call_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-# Extract function informationfunction_name = getattr(instance, "name", getattr(instance, "__name__", "unknown_function")@@ -546,9 +514,6 @@ def async_memory_add_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)span_name = "memory add"with tracer.start_as_current_span(span_name, kind=SpanKind.INTERNAL) as span:@@ -601,9 +566,6 @@ def async_memory_search_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)span_name = "memory search"with tracer.start_as_current_span(span_name, kind=SpanKind.INTERNAL) as span:@@ -657,9 +619,6 @@ def async_vectordb_search_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)span_name = "vectordb search"with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:@@ -713,9 +672,6 @@ def async_knowledge_search_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)span_name = "knowledge search"with tracer.start_as_current_span(span_name, kind=SpanKind.INTERNAL) as span:@@ -772,17 +728,6 @@ def async_workflow_run_wrap("""async def wrapper(wrapped, instance, args, kwargs):- # Check if tracer is available- if not tracer:- # Just call and handle async iterator if needed- result = wrapped(*args, **kwargs)- if hasattr(result, "__aiter__"):- async for event in result:- yield event- else:- return await result- return-workflow_name = getattr(instance, "name", "unknown_workflow")span_name = f"workflow {workflow_name}"diff --git a/sdk/python/src/openlit/instrumentation/openai/__init__.py b/sdk/python/src/openlit/instrumentation/openai/__init__.pyindex 0fa40600..bd9c2e0e 100644--- a/sdk/python/src/openlit/instrumentation/openai/__init__.py+++ b/sdk/python/src/openlit/instrumentation/openai/__init__.py@@ -44,6 +44,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content = kwargs.get("capture_message_content", False)metrics = kwargs.get("metrics_dict")disable_metrics = kwargs.get("disable_metrics")+ event_provider = kwargs.get("event_provider")# chat completionswrap_function_wrapper(@@ -58,6 +59,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -73,6 +75,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -89,6 +92,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -104,6 +108,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -120,6 +125,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -135,6 +141,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -151,6 +158,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -166,6 +174,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -182,6 +191,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -197,6 +207,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -213,6 +224,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -228,6 +240,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -244,6 +257,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -259,6 +273,7 @@ class OpenAIInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/openai/async_openai.py b/sdk/python/src/openlit/instrumentation/openai/async_openai.pyindex d7a41d37..e8bf22f8 100644--- a/sdk/python/src/openlit/instrumentation/openai/async_openai.py+++ b/sdk/python/src/openlit/instrumentation/openai/async_openai.py@@ -28,6 +28,7 @@ def async_chat_completions(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async chat completions.@@ -46,6 +47,7 @@ def async_chat_completions(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -65,6 +67,7 @@ def async_chat_completions(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -97,6 +100,7 @@ def async_chat_completions(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:handle_exception(self._span, e)@@ -108,10 +112,6 @@ def async_chat_completions("""streaming = kwargs.get("stream", False)-- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -124,7 +124,13 @@ def async_chat_completions(span = tracer.start_span(span_name, kind=SpanKind.CLIENT)return TracedAsyncStream(- awaited_wrapped, span, span_name, kwargs, server_address, server_port+ awaited_wrapped,+ span,+ span_name,+ kwargs,+ server_address,+ server_port,+ event_provider,)else:@@ -147,6 +153,7 @@ def async_chat_completions(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -167,6 +174,7 @@ def async_responses(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async responses API.@@ -185,6 +193,7 @@ def async_responses(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -208,6 +217,7 @@ def async_responses(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -240,6 +250,7 @@ def async_responses(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:handle_exception(self._span, e)@@ -251,10 +262,6 @@ def async_responses("""streaming = kwargs.get("stream", False)-- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -267,7 +274,13 @@ def async_responses(span = tracer.start_span(span_name, kind=SpanKind.CLIENT)return TracedAsyncStream(- awaited_wrapped, span, span_name, kwargs, server_address, server_port+ awaited_wrapped,+ span,+ span_name,+ kwargs,+ server_address,+ server_port,+ event_provider,)else:@@ -290,6 +303,7 @@ def async_responses(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -310,6 +324,7 @@ def async_chat_completions_parse(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async chat completions parse.@@ -320,10 +335,6 @@ def async_chat_completions_parse(Wraps the OpenAI async chat completions parse call."""- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -350,6 +361,7 @@ def async_chat_completions_parse(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -370,6 +382,7 @@ def async_embedding(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async embeddings.@@ -380,10 +393,6 @@ def async_embedding(Wraps the OpenAI async embeddings call."""- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -432,6 +441,7 @@ def async_image_generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async image generation.@@ -442,10 +452,6 @@ def async_image_generate(Wraps the OpenAI async image generation call."""- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -494,6 +500,7 @@ def async_image_variations(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async image variations.@@ -504,10 +511,6 @@ def async_image_variations(Wraps the OpenAI async image variations call."""- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -556,6 +559,7 @@ def async_audio_create(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI async audio creation.@@ -566,10 +570,6 @@ def async_audio_create(Wraps the OpenAI async audio creation call."""- # Check if tracer is available- if not tracer:- return await wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)diff --git a/sdk/python/src/openlit/instrumentation/openai/openai.py b/sdk/python/src/openlit/instrumentation/openai/openai.pyindex 96bae118..83f03a81 100644--- a/sdk/python/src/openlit/instrumentation/openai/openai.py+++ b/sdk/python/src/openlit/instrumentation/openai/openai.py@@ -28,6 +28,7 @@ def chat_completions(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI chat completions.@@ -46,6 +47,7 @@ def chat_completions(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -65,6 +67,7 @@ def chat_completions(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -97,6 +100,7 @@ def chat_completions(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:handle_exception(self._span, e)@@ -108,10 +112,6 @@ def chat_completions("""streaming = kwargs.get("stream", False)-- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -124,7 +124,13 @@ def chat_completions(span = tracer.start_span(span_name, kind=SpanKind.CLIENT)return TracedSyncStream(- awaited_wrapped, span, span_name, kwargs, server_address, server_port+ awaited_wrapped,+ span,+ span_name,+ kwargs,+ server_address,+ server_port,+ event_provider,)else:@@ -147,6 +153,7 @@ def chat_completions(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -167,6 +174,7 @@ def responses(capture_message_content,metrics,disable_metrics,+ event_provider=None,**kwargs,):"""@@ -186,6 +194,7 @@ def responses(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -209,6 +218,7 @@ def responses(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -241,6 +251,7 @@ def responses(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:handle_exception(self._span, e)@@ -252,10 +263,6 @@ def responses("""streaming = kwargs.get("stream", False)-- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -268,7 +275,13 @@ def responses(span = tracer.start_span(span_name, kind=SpanKind.CLIENT)return TracedSyncStream(- awaited_wrapped, span, span_name, kwargs, server_address, server_port+ awaited_wrapped,+ span,+ span_name,+ kwargs,+ server_address,+ server_port,+ event_provider,)else:@@ -291,6 +304,7 @@ def responses(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -311,6 +325,7 @@ def chat_completions_parse(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI chat completions parse.@@ -321,10 +336,6 @@ def chat_completions_parse(Wraps the OpenAI chat completions parse call."""- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -351,6 +362,7 @@ def chat_completions_parse(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -371,6 +383,7 @@ def embedding(capture_message_content,metrics,disable_metrics,+ event_provider=None,**kwargs,):"""@@ -382,10 +395,6 @@ def embedding(Wraps the OpenAI embeddings call."""- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -414,6 +423,7 @@ def embedding(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -434,6 +444,7 @@ def image_generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,**kwargs,):"""@@ -445,10 +456,6 @@ def image_generate(Wraps the OpenAI image generation call."""- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -477,6 +484,7 @@ def image_generate(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -497,6 +505,7 @@ def image_variatons(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI image variations.@@ -507,10 +516,6 @@ def image_variatons(Wraps the OpenAI image variations call."""- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -539,6 +544,7 @@ def image_variatons(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -559,6 +565,7 @@ def audio_create(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for OpenAI audio creation.@@ -569,10 +576,6 @@ def audio_create(Wraps the OpenAI audio creation call."""- # Check if tracer is available- if not tracer:- return wrapped(*args, **kwargs)-server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)@@ -601,6 +604,7 @@ def audio_create(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)diff --git a/sdk/python/src/openlit/instrumentation/openai/utils.py b/sdk/python/src/openlit/instrumentation/openai/utils.pyindex 5836a86a..ab0fdee6 100644--- a/sdk/python/src/openlit/instrumentation/openai/utils.py+++ b/sdk/python/src/openlit/instrumentation/openai/utils.py@@ -3,6 +3,7 @@ OpenAI OpenTelemetry instrumentation utility functions"""import time+import loggingfrom opentelemetry.trace import Status, StatusCode@@ -20,9 +21,12 @@ from openlit.__helpers import (record_audio_metrics,record_image_metrics,common_span_attributes,+ otel_event,)from openlit.semcov import SemanticConvention+logger = logging.getLogger(__name__)+def handle_not_given(value, default=None):"""@@ -87,6 +91,423 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages):+ """+ Convert OpenAI request messages to OTel input message structure.+ Follows https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-input-messages.json++ Args:+ messages: OpenAI messages array from request++ Returns:+ List of ChatMessage objects with role and parts+ """+ if not messages:+ return []++ # Handle string input (simple case)+ if isinstance(messages, str):+ return [{"role": "user", "parts": [{"type": "text", "content": messages}]}]++ otel_messages = []++ for message in messages:+ try:+ # Extract role+ role = (+ message.get("role", "user")+ if isinstance(message, dict)+ else getattr(message, "role", "user")+ )++ # Extract content+ content = (+ message.get("content", "")+ if isinstance(message, dict)+ else getattr(message, "content", "")+ )++ # Build parts array+ parts = []++ if isinstance(content, list):+ # Multi-part content+ for item in content:+ item_type = (+ item.get("type")+ if isinstance(item, dict)+ else getattr(item, "type", None)+ )++ # Chat completions format+ if item_type == "text":+ text_content = (+ item.get("text", "")+ if isinstance(item, dict)+ else getattr(item, "text", "")+ )+ if text_content:+ parts.append({"type": "text", "content": text_content})++ elif item_type == "image_url":+ image_url_obj = (+ item.get("image_url", {})+ if isinstance(item, dict)+ else getattr(item, "image_url", {})+ )+ if isinstance(image_url_obj, dict):+ url = image_url_obj.get("url", "")+ else:+ url = getattr(image_url_obj, "url", "")++ # Skip data URIs+ if url and not url.startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": url}+ )++ # Responses API format+ elif item_type == "input_text":+ text_content = (+ item.get("text", "")+ if isinstance(item, dict)+ else getattr(item, "text", "")+ )+ if text_content:+ parts.append({"type": "text", "content": text_content})++ elif item_type == "input_image":+ image_url = (+ item.get("image_url", "")+ if isinstance(item, dict)+ else getattr(item, "image_url", "")+ )+ if image_url and not image_url.startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": image_url}+ )++ # Tool call response (assistant sending tool results)+ elif item_type == "tool_call":+ tool_call_obj = (+ item+ if isinstance(item, dict)+ else {+ "id": getattr(item, "id", ""),+ "name": getattr(item, "name", ""),+ "arguments": getattr(item, "arguments", {}),+ }+ )+ parts.append(+ {+ "type": "tool_call",+ "id": tool_call_obj.get("id", ""),+ "name": tool_call_obj.get("name", ""),+ "arguments": tool_call_obj.get("arguments", {}),+ }+ )++ elif isinstance(content, str) and content:+ # Simple string content+ parts.append({"type": "text", "content": content})++ # Handle tool_call_id for tool role messages+ if role == "tool":+ tool_call_id = (+ message.get("tool_call_id", "")+ if isinstance(message, dict)+ else getattr(message, "tool_call_id", "")+ )+ tool_content = content if isinstance(content, str) else str(content)+ # For tool responses, use tool_call_response part type+ parts = [+ {+ "type": "tool_call_response",+ "id": tool_call_id,+ "response": tool_content,+ }+ ]++ if parts: # Only add message if it has content+ otel_message = {"role": role, "parts": parts}++ # Add optional name if present+ name = (+ message.get("name")+ if isinstance(message, dict)+ else getattr(message, "name", None)+ )+ if name:+ otel_message["name"] = name++ otel_messages.append(otel_message)++ except Exception as e:+ logger.warning("Failed to process input message: %s", e, exc_info=True)+ continue++ return otel_messages+++def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert OpenAI response to OTel output message structure.+ Follows https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-output-messages.json++ Args:+ response_text: Response text from model+ finish_reason: Finish reason from OpenAI+ tool_calls: Optional tool calls from response++ Returns:+ List with single OutputMessage (for choice 0)+ """+ parts = []++ try:+ # Add text content if present+ if response_text:+ parts.append({"type": "text", "content": response_text})++ # Add tool calls if present+ if tool_calls:+ if isinstance(tool_calls, list):+ for tool_call in tool_calls:+ try:+ # Extract tool call data+ if isinstance(tool_call, dict):+ tool_id = tool_call.get("id", "")+ tool_name = tool_call.get("name", "")+ tool_args = tool_call.get("arguments", {})+ else:+ tool_id = getattr(tool_call, "id", "")+ tool_name = getattr(tool_call, "name", "")+ tool_args = getattr(tool_call, "arguments", {})++ # Parse arguments if it's a string+ if isinstance(tool_args, str):+ try:+ import json++ tool_args = json.loads(tool_args)+ except:+ tool_args = {"raw": tool_args}++ parts.append(+ {+ "type": "tool_call",+ "id": tool_id,+ "name": tool_name,+ "arguments": tool_args,+ }+ )+ except Exception as e:+ logger.warning(+ "Failed to process tool call: %s", e, exc_info=True+ )+ continue+ elif isinstance(tool_calls, str):+ # Tool calls stored as string (comma-separated names)+ # Just add as text note+ pass++ # Map OpenAI finish reasons to OTel finish reasons+ finish_reason_map = {+ "stop": "stop",+ "length": "length",+ "content_filter": "content_filter",+ "tool_calls": "tool_call",+ "function_call": "tool_call",+ }++ otel_finish_reason = finish_reason_map.get(+ finish_reason, finish_reason or "stop"+ )++ return [+ {"role": "assistant", "parts": parts, "finish_reason": otel_finish_reason}+ ]++ except Exception as e:+ logger.warning("Failed to build output messages: %s", e, exc_info=True)+ # Return minimal valid structure+ return [{"role": "assistant", "parts": [], "finish_reason": "stop"}]+++def build_tool_definitions(tools):+ """+ Extract tool/function definitions from request.++ Args:+ tools: Tools array from OpenAI request++ Returns:+ List of tool definition objects or None+ """+ if not tools:+ return None++ try:+ tool_definitions = []++ for tool in tools:+ try:+ if isinstance(tool, dict):+ # Extract function definition+ if tool.get("type") == "function" and "function" in tool:+ func = tool["function"]+ tool_definitions.append(+ {+ "type": "function",+ "name": func.get("name", ""),+ "description": func.get("description", ""),+ "parameters": func.get("parameters", {}),+ }+ )+ else:+ # Handle object format+ if getattr(tool, "type", None) == "function":+ func = getattr(tool, "function", None)+ if func:+ tool_definitions.append(+ {+ "type": "function",+ "name": getattr(func, "name", ""),+ "description": getattr(func, "description", ""),+ "parameters": getattr(func, "parameters", {}),+ }+ )+ except Exception as e:+ logger.warning(+ "Failed to process tool definition: %s", e, exc_info=True+ )+ continue++ return tool_definitions if tool_definitions else None++ except Exception as e:+ logger.warning("Failed to build tool definitions: %s", e, exc_info=True)+ return None+++def emit_inference_event(+ event_provider,+ operation_name,+ request_model,+ response_model,+ input_messages=None,+ output_messages=None,+ tool_definitions=None,+ server_address=None,+ server_port=None,+ **extra_attrs,+):+ """+ Emit gen_ai.client.inference.operation.details event.++ Args:+ event_provider: The OTel event provider+ operation_name: Operation type (chat, embeddings, etc.)+ request_model: Model from request+ response_model: Model from response+ input_messages: Structured input messages (optional)+ output_messages: Structured output messages (optional)+ tool_definitions: Tool definitions (optional)+ server_address: Server address (optional)+ server_port: Server port (optional)+ **extra_attrs: Additional attributes (response_id, finish_reasons, etc.)+ """+ try:+ if not event_provider:+ return++ # Build event attributes+ attributes = {+ SemanticConvention.GEN_AI_OPERATION: operation_name,+ }++ # Add model attributes+ if request_model:+ attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = request_model+ if response_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model++ # Add server attributes+ if server_address:+ attributes[SemanticConvention.SERVER_ADDRESS] = server_address+ if server_port:+ attributes[SemanticConvention.SERVER_PORT] = server_port++ # Add message attributes (structured format required for events per OTel spec)+ if input_messages is not None:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages is not None:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages++ # Add tool definitions+ if tool_definitions is not None:+ attributes[SemanticConvention.GEN_AI_TOOL_DEFINITIONS] = tool_definitions++ # Add extra attributes with proper mapping to semantic conventions+ for key, value in extra_attrs.items():+ if value is not None:+ # Map common keys to semantic conventions+ if key == "response_id":+ attributes[SemanticConvention.GEN_AI_RESPONSE_ID] = value+ elif key == "finish_reasons":+ attributes[SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON] = value+ elif key == "output_type":+ attributes[SemanticConvention.GEN_AI_OUTPUT_TYPE] = value+ elif key == "conversation_id":+ # Note: OpenAI doesn't provide conversation_id, but included for completeness+ attributes["gen_ai.conversation.id"] = value+ elif key == "temperature":+ attributes[SemanticConvention.GEN_AI_REQUEST_TEMPERATURE] = value+ elif key == "max_tokens":+ attributes[SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS] = value+ elif key == "top_p":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_P] = value+ elif key == "frequency_penalty":+ attributes[SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY] = (+ value+ )+ elif key == "presence_penalty":+ attributes[SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY] = (+ value+ )+ elif key == "stop_sequences":+ attributes[SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES] = value+ elif key == "seed":+ attributes[SemanticConvention.GEN_AI_REQUEST_SEED] = value+ elif key in ("choice_count", "n"):+ # Only add if not 1 (per spec: conditionally required if ≠1)+ if value != 1:+ attributes["gen_ai.request.choice.count"] = value+ elif key == "input_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] = value+ elif key == "output_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] = value+ elif key == "cache_creation_input_tokens":+ attributes["gen_ai.usage.cache_creation.input_tokens"] = value+ elif key == "cache_read_input_tokens":+ attributes["gen_ai.usage.cache_read.input_tokens"] = value+ else:+ # Pass through any other attributes as-is+ attributes[key] = value++ # Create and emit event+ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="", # Per spec, all data in attributes+ )++ event_provider.emit(event)++ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)++def process_chat_chunk(scope, chunk):"""Process a chunk of chat response data and update state.@@ -262,6 +683,7 @@ def common_response_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process responses API request and generate Telemetry@@ -400,19 +822,41 @@ def common_response_logic(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)- # To be removed once the change to span_attributes (from span events) is complete- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,- },- )- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,- },- )+ # Emit inference event+ if event_provider:+ try:+ input_msgs = build_input_messages(input_data)+ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ scope._response_tools+ if hasattr(scope, "_response_tools")+ else None,+ )++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ request_model=request_model,+ response_model=scope._response_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=None, # Responses API doesn't expose tools upfront+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=scope._response_id,+ finish_reasons=[scope._finish_reason],+ output_type="text",+ temperature=handle_not_given(scope._kwargs.get("temperature"), 1.0),+ max_tokens=handle_not_given(+ scope._kwargs.get("max_output_tokens"), -1+ ),+ top_p=handle_not_given(scope._kwargs.get("top_p"), 1.0),+ input_tokens=input_tokens,+ output_tokens=output_tokens,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -447,6 +891,7 @@ def process_streaming_response_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming responses API response and generate telemetry.@@ -462,6 +907,7 @@ def process_streaming_response_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -479,6 +925,7 @@ def process_response_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -551,6 +998,7 @@ def process_response_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return response@@ -566,6 +1014,7 @@ def common_chat_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -720,19 +1169,58 @@ def common_chat_logic(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)- # To be removed once the change to span_attributes (from span events) is complete- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,- },- )- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,- },- )+ # Emit inference event+ if event_provider:+ try:+ # Get messages from kwargs (could be chat completions or responses API)+ if (+ hasattr(scope, "_operation_type")+ and scope._operation_type == "responses"+ ):+ input_data = scope._kwargs.get("input", "")+ input_msgs = build_input_messages(input_data)+ else:+ input_msgs = build_input_messages(scope._kwargs.get("messages", []))++ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ scope._tools if hasattr(scope, "_tools") else None,+ )+ tool_defs = build_tool_definitions(scope._kwargs.get("tools"))++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ request_model=request_model,+ response_model=scope._response_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=tool_defs,+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=scope._response_id,+ finish_reasons=[scope._finish_reason],+ output_type="text"+ if isinstance(scope._llmresponse, str)+ else "json",+ temperature=handle_not_given(scope._kwargs.get("temperature"), 1.0),+ max_tokens=handle_not_given(scope._kwargs.get("max_tokens"), -1),+ top_p=handle_not_given(scope._kwargs.get("top_p"), 1.0),+ frequency_penalty=handle_not_given(+ scope._kwargs.get("frequency_penalty"), 0.0+ ),+ presence_penalty=handle_not_given(+ scope._kwargs.get("presence_penalty"), 0.0+ ),+ stop_sequences=handle_not_given(scope._kwargs.get("stop"), []),+ seed=str(handle_not_given(scope._kwargs.get("seed"), "")),+ choice_count=scope._kwargs.get("n", 1),+ input_tokens=input_tokens,+ output_tokens=output_tokens,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -767,6 +1255,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming chat response and generate telemetry.@@ -782,6 +1271,7 @@ def process_streaming_chat_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -799,6 +1289,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -853,6 +1344,7 @@ def process_chat_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return response@@ -868,6 +1360,7 @@ def common_embedding_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Common logic for processing embedding operations.@@ -924,6 +1417,41 @@ def common_embedding_logic(SemanticConvention.GEN_AI_CONTENT_PROMPT, formatted_content)+ # Emit inference event+ if event_provider:+ try:+ # Build input messages with text content+ if isinstance(input_data, list):+ input_msgs = [+ {+ "role": "user",+ "parts": [{"type": "text", "content": str(item)}],+ }+ for item in input_data+ ]+ else:+ input_msgs = [+ {+ "role": "user",+ "parts": [{"type": "text", "content": str(input_data)}],+ }+ ]++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ request_model=request_model,+ response_model=request_model,+ input_messages=input_msgs,+ output_messages=None, # Embeddings don't have text output+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ input_tokens=scope._input_tokens,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)+scope._span.set_status(Status(StatusCode.OK))# Record metrics@@ -955,6 +1483,7 @@ def common_image_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Common logic for processing image operations.@@ -1065,18 +1594,61 @@ def common_image_logic(SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT, revised_prompts)- # Add revised prompt events for detailed tracking- for i, image in enumerate(images_data):- if image.get("revised_prompt"):- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT,- attributes={- SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT: image[- "revised_prompt"- ],- "image_index": i,- },- )+ # Emit inference event+ if event_provider:+ try:+ # Build input messages with text prompt+ input_msgs = (+ [{"role": "user", "parts": [{"type": "text", "content": prompt}]}]+ if prompt+ else []+ )++ # Build output messages with revised prompts as text parts+ output_msgs = []+ if images_data:+ for image in images_data:+ parts = []+ # Add revised prompt if available+ if image.get("revised_prompt"):+ parts.append(+ {"type": "text", "content": image["revised_prompt"]}+ )+ # Add image URL if available (not base64)+ if image.get("url"):+ parts.append(+ {+ "type": "uri",+ "modality": "image",+ "uri": image["url"],+ }+ )++ if parts:+ output_msgs.append(+ {+ "role": "assistant",+ "parts": parts,+ "finish_reason": "stop",+ }+ )++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_IMAGE,+ request_model=request_model,+ response_model=request_model,+ input_messages=input_msgs,+ output_messages=output_msgs if output_msgs else None,+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=str(response_created) if response_created else None,+ output_type="image",+ choice_count=scope._kwargs.get("n", 1),+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -1108,6 +1680,7 @@ def common_audio_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Common logic for processing audio operations.@@ -1156,6 +1729,44 @@ def common_audio_logic(input_text = scope._kwargs.get("input", "")scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, input_text)+ # Emit inference event+ if event_provider:+ try:+ # Build input messages with text content+ input_msgs = (+ [+ {+ "role": "user",+ "parts": [{"type": "text", "content": input_text}],+ }+ ]+ if input_text+ else []+ )++ # Audio output doesn't have text response, just indicate audio generation+ output_msgs = [+ {+ "role": "assistant",+ "parts": [{"type": "text", "content": "[audio generated]"}],+ "finish_reason": "stop",+ }+ ]++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,+ request_model=request_model,+ response_model=request_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)+scope._span.set_status(Status(StatusCode.OK))# Record metrics@@ -1191,6 +1802,7 @@ def process_audio_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -1217,6 +1829,7 @@ def process_audio_response(capture_message_content,disable_metrics,version,+ event_provider=event_provider,)return response@@ -1236,6 +1849,7 @@ def process_embedding_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -1264,6 +1878,7 @@ def process_embedding_response(capture_message_content,disable_metrics,version,+ event_provider=event_provider,)return response@@ -1284,6 +1899,7 @@ def process_image_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -1312,6 +1928,7 @@ def process_image_response(capture_message_content,disable_metrics,version,+ event_provider=event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/psycopg/__init__.py b/sdk/python/src/openlit/instrumentation/psycopg/__init__.pyindex 80ed3886..d23ad9e2 100644--- a/sdk/python/src/openlit/instrumentation/psycopg/__init__.py+++ b/sdk/python/src/openlit/instrumentation/psycopg/__init__.py@@ -404,14 +404,18 @@ class PsycopgInstrumentor(BaseInstrumentor):# Create a bound wrapper for this instancedef make_bound_wrapper(orig, wrap, conn, async_mode):if async_mode:+@functools.wraps(orig)async def bound_wrapper(*args, **kw):return await wrap(orig, conn, args, kw)+return bound_wrapperelse:+@functools.wraps(orig)def bound_wrapper(*args, **kw):return wrap(orig, conn, args, kw)+return bound_wrappersetattr(@@ -518,14 +522,18 @@ class PsycopgInstrumentor(BaseInstrumentor):# Create a bound wrapper for this cursor instancedef make_cursor_wrapper(orig, wrap, cur, async_mode):if async_mode:+@functools.wraps(orig)async def bound_wrapper(*args, **kw):return await wrap(orig, cur, args, kw)+return bound_wrapperelse:+@functools.wraps(orig)def bound_wrapper(*args, **kw):return wrap(orig, cur, args, kw)+return bound_wrappersetattr(diff --git a/sdk/python/src/openlit/semcov/__init__.py b/sdk/python/src/openlit/semcov/__init__.pyindex b3687f5a..079a3917 100644--- a/sdk/python/src/openlit/semcov/__init__.py+++ b/sdk/python/src/openlit/semcov/__init__.py@@ -38,6 +38,17 @@ class SemanticConvention:GEN_AI_TOOL_MESSAGE = "gen_ai.tools.message"GEN_AI_CHOICE = "gen_ai.choice"+ # GenAI Event Names (OTel Semconv v1.29+)+ GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS = (+ "gen_ai.client.inference.operation.details"+ )++ # GenAI Content Attributes (OTel Semconv v1.29+)+ GEN_AI_INPUT_MESSAGES = "gen_ai.input.messages"+ GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages"+ GEN_AI_SYSTEM_INSTRUCTIONS = "gen_ai.system_instructions"+ GEN_AI_TOOL_DEFINITIONS = "gen_ai.tool.definitions"+# GenAI Request Attributes (OTel Semconv)GEN_AI_OPERATION = "gen_ai.operation.name"GEN_AI_SYSTEM = "gen_ai.system"@@ -759,6 +770,13 @@ class SemanticConvention:EVAL_VALIDATOR = "evals.validator"EVAL_EXPLANATION = "evals.explanation"+ # GenAI Evaluation Event (OTel Semconv)+ GEN_AI_EVALUATION_RESULT = "gen_ai.evaluation.result"+ GEN_AI_EVALUATION_NAME = "gen_ai.evaluation.name"+ GEN_AI_EVALUATION_SCORE_VALUE = "gen_ai.evaluation.score.value"+ GEN_AI_EVALUATION_SCORE_LABEL = "gen_ai.evaluation.score.label"+ GEN_AI_EVALUATION_EXPLANATION = "gen_ai.evaluation.explanation"+# === FRAMEWORK OPERATIONS (Generic attributes for all RAG/AI frameworks) ===# Document Processingdiff --git a/sdk/python/tests/test_xai.py b/sdk/python/tests/test_xai.py.holdsimilarity index 100%rename from sdk/python/tests/test_xai.pyrename to sdk/python/tests/test_xai.py.hold