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
feat: Use Otel Events in Anthropic, Google, Azure and AWS instrumentations (#1000)
Ishan Jain2b9ea10163a7
diff --git a/contributors/OTEL_ATTRIBUTE_MAPPING.md b/contributors/OTEL_ATTRIBUTE_MAPPING.mdindex 8c4848e8..7d365282 100644--- a/contributors/OTEL_ATTRIBUTE_MAPPING.md+++ b/contributors/OTEL_ATTRIBUTE_MAPPING.md@@ -17,76 +17,169 @@ Quick reference for mapping provider-specific parameters to OpenTelemetry Gen-AI| 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"` |+| `gen_ai.operation.name` | `GEN_AI_OPERATION_NAME` | string | **REQUIRED** - Name of the operation being performed | `"chat"`, `"completion"`, `"embedding"` |----## Content Attributes (Chat/Completions)+## Conditionally Required Attributes (Inference)-| 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) |+These attributes MUST be included when the specified condition is met:++| OTel Attribute | Constant | Type | Condition | Description | Example |+|----------------|----------|------|-----------|-------------|---------|+| `error.type` | `ERROR_TYPE` | string | If operation ended in error | Error class/type describing the error | `"timeout"`, `"rate_limit"` |+| `gen_ai.conversation.id` | `GEN_AI_CONVERSATION_ID` | string | When readily available | Identifies the conversation/session | `"session-abc123"` |+| `gen_ai.output.type` | `GEN_AI_OUTPUT_TYPE` | string | When applicable | Requested content type | `"text"`, `"json_object"` |+| `gen_ai.request.choice.count` | `GEN_AI_REQUEST_CHOICE_COUNT` | int | If available and ≠ 1 | Number of choices requested | `3` |+| `gen_ai.request.model` | `GEN_AI_REQUEST_MODEL` | string | If available | Model name being called | `"gpt-4"`, `"claude-3-opus"` |+| `gen_ai.request.seed` | `GEN_AI_REQUEST_SEED` | int | If seed was provided | Seed for deterministic generation | `42` |+| `server.port` | `SERVER_PORT` | int | If server.address is set | Server port number | `443` |----## Request Parameters (Optional)+## Recommended Attributes (Inference)-| 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 |+These attributes SHOULD be included when available:----+### Request Parameters-## Response Metadata (Recommended)+| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.request.frequency_penalty` | `GEN_AI_REQUEST_FREQUENCY_PENALTY` | double | Frequency penalty setting | `0.5` |+| `gen_ai.request.max_tokens` | `GEN_AI_REQUEST_MAX_TOKENS` | int | Maximum tokens to generate | `1024` |+| `gen_ai.request.presence_penalty` | `GEN_AI_REQUEST_PRESENCE_PENALTY` | double | Presence penalty setting | `0.3` |+| `gen_ai.request.stop_sequences` | `GEN_AI_REQUEST_STOP_SEQUENCES` | string[] | Sequences where model stops | `["END", "\n\n"]` |+| `gen_ai.request.temperature` | `GEN_AI_REQUEST_TEMPERATURE` | double | Temperature setting | `0.7` |+| `gen_ai.request.top_p` | `GEN_AI_REQUEST_TOP_P` | double | Top-p (nucleus) sampling | `0.9` |++### Response Metadata| OTel Attribute | Constant | Type | Description | Example ||----------------|----------|------|-------------|---------|+| `gen_ai.response.finish_reasons` | `GEN_AI_RESPONSE_FINISH_REASONS` | string[] | Reasons model stopped | `["stop"]`, `["max_tokens"]` || `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"` |+| `gen_ai.response.model` | `GEN_AI_RESPONSE_MODEL` | string | Model that generated response | `"gpt-4-0613"` |++### Usage Metrics++| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.usage.cache_creation.input_tokens` | `GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS` | int | Input tokens written to cache | `512` |+| `gen_ai.usage.cache_read.input_tokens` | `GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS` | int | Input tokens served from cache | `256` |+| `gen_ai.usage.input_tokens` | `GEN_AI_USAGE_INPUT_TOKENS` | int | Total tokens in prompt | `128` |+| `gen_ai.usage.output_tokens` | `GEN_AI_USAGE_OUTPUT_TOKENS` | int | Tokens in response | `64` |++### Server Information++| OTel Attribute | Type | Description | Example |+|----------------|------|-------------|---------|+| `server.address` | string | GenAI server hostname/IP | `"api.openai.com"`, `"api.anthropic.com"` |----## Usage Metrics (Recommended)+## Opt-In Attributes (Content - Chat/Completions)++These attributes contain sensitive content and MUST only be included when explicitly enabled via `capture_message_content=True`:-| 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 |+| OTel Attribute | Constant | Type | Description | Format |+|----------------|----------|------|-------------|--------|+| `gen_ai.input.messages` | `GEN_AI_INPUT_MESSAGES` | array | Chat history provided to model as input | See [Input Message Schema](#input-message-schema) |+| `gen_ai.output.messages` | `GEN_AI_OUTPUT_MESSAGES` | array | Messages returned by model (responses) | See [Output Message Schema](#output-message-schema) |+| `gen_ai.system_instructions` | `GEN_AI_SYSTEM_INSTRUCTIONS` | string or array | System message/instructions separate from chat | `"You are a helpful assistant"` |+| `gen_ai.tool.definitions` | `GEN_AI_TOOL_DEFINITIONS` | array | List of tool/function definitions available | See [Tool Definition Schema](#tool-definition-schema) |++**Important:** These attributes contain user data and MUST only be set when `capture_message_content=True`.----## Server Attributes (Recommended)+## Evaluation Event Attributes-| 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` |+### Event: `gen_ai.evaluation.result`++#### Required Attributes++| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.evaluation.name` | `GEN_AI_EVALUATION_NAME` | string | **REQUIRED** - Evaluation metric name used | `"hallucination"`, `"bias_detection"`, `"toxicity"` |++#### Conditionally Required Attributes++| OTel Attribute | Constant | Type | Condition | Description | Example |+|----------------|----------|------|-----------|-------------|---------|+| `error.type` | `ERROR_TYPE` | string | If operation ended in error | Error type for failed evaluation | `"api_error"` |+| `gen_ai.evaluation.score.label` | `GEN_AI_EVALUATION_SCORE_LABEL` | string | At least one of label/value required | Human-readable evaluation label | `"yes"`, `"no"`, `"pass"`, `"fail"` |+| `gen_ai.evaluation.score.value` | `GEN_AI_EVALUATION_SCORE_VALUE` | double | At least one of label/value required | Numeric evaluation score | `0.85` |++**Note:** Either `score.label` or `score.value` (or both) MUST be present for the evaluation to be meaningful.++#### Recommended Attributes++| OTel Attribute | Constant | Type | Description | Example |+|----------------|----------|------|-------------|---------|+| `gen_ai.evaluation.explanation` | `GEN_AI_EVALUATION_EXPLANATION` | string | Free-form explanation for assigned score | `"The output contains factual inaccuracies"` |+| `gen_ai.response.id` | `GEN_AI_RESPONSE_ID` | string | Links evaluation to specific GenAI response | `"chatcmpl-123"` |----## Evaluation Attributes+## Attribute Requirement Levels++Understanding when to include attributes is critical for OTel compliance:++### Required+- **MUST** be included in every event+- Missing required attributes makes the event non-compliant+- Example: `gen_ai.operation.name`++### Conditionally Required+- **MUST** be included when the specified condition is met+- The condition describes when the attribute becomes mandatory+- Examples:+ - `error.type` - Required IF the operation ended in error+ - `server.port` - Required IF `server.address` is set+ - `gen_ai.request.seed` - Required IF a seed was provided in the request-| 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"` |+### Recommended+- **SHOULD** be included when the information is available+- Improves observability but not strictly required+- Examples: `gen_ai.response.id`, `gen_ai.usage.input_tokens`++### Opt-In+- **MUST NOT** be included by default (contains sensitive data)+- Only include when user explicitly enables via configuration flag+- Examples: `gen_ai.input.messages`, `gen_ai.output.messages`, `gen_ai.tool.definitions`+- Check: `if capture_message_content and event_provider:`++### Implementation Guidelines++```python+# Required - always include+attributes = {+ "gen_ai.operation.name": "chat", # REQUIRED+}++# Conditionally Required - check condition first+if error_occurred:+ attributes["error.type"] = error_type # REQUIRED when condition met++if server_address:+ attributes["server.address"] = server_address+ attributes["server.port"] = server_port # REQUIRED when server.address set++if seed is not None:+ attributes["gen_ai.request.seed"] = seed # REQUIRED when provided++# Recommended - include when available+if response_id:+ attributes["gen_ai.response.id"] = response_id # RECOMMENDED++if input_tokens is not None:+ attributes["gen_ai.usage.input_tokens"] = input_tokens # RECOMMENDED++# Opt-In - only when explicitly enabled+if capture_message_content and event_provider:+ attributes["gen_ai.input.messages"] = input_messages # OPT-IN+ attributes["gen_ai.output.messages"] = output_messages # OPT-IN+```---@@ -337,106 +430,169 @@ tool_definitions = [### 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 |+Request mapping:+| OpenAI Parameter | OTel Attribute | Required Level | Notes |+|------------------|----------------|----------------|-------|+| `messages` | `gen_ai.input.messages` | Opt-In | Transform to structured format |+| `model` | `gen_ai.request.model` | Conditionally Required | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Recommended | Direct mapping |+| `max_tokens` / `max_completion_tokens` | `gen_ai.request.max_tokens` | Recommended | Direct mapping |+| `top_p` | `gen_ai.request.top_p` | Recommended | Direct mapping |+| `frequency_penalty` | `gen_ai.request.frequency_penalty` | Recommended | Direct mapping |+| `presence_penalty` | `gen_ai.request.presence_penalty` | Recommended | Direct mapping |+| `stop` | `gen_ai.request.stop_sequences` | Recommended | Direct mapping |+| `seed` | `gen_ai.request.seed` | Conditionally Required | Include if provided |+| `n` | `gen_ai.request.choice.count` | Conditionally Required | Include if ≠ 1 |+| `tools` / `functions` | `gen_ai.tool.definitions` | Opt-In | Direct mapping |+| `response_format.type` | `gen_ai.output.type` | Conditionally Required | When applicable |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` |+| OpenAI Field | OTel Attribute | Required Level | Notes |+|--------------|----------------|----------------|-------|+| `id` | `gen_ai.response.id` | Recommended | Direct mapping |+| `model` | `gen_ai.response.model` | Recommended | Direct mapping |+| `choices[0].message.content` | Part of `gen_ai.output.messages` | Opt-In | Text content |+| `choices[0].message.tool_calls` | Part of `gen_ai.output.messages` | Opt-In | Tool calls |+| `choices[0].finish_reason` | Part of `gen_ai.output.messages[0].finish_reason` | Recommended | Map: length→max_tokens |+| `usage.prompt_tokens` | `gen_ai.usage.input_tokens` | Recommended | Direct mapping |+| `usage.completion_tokens` | `gen_ai.usage.output_tokens` | Recommended | Direct mapping |+| `usage.prompt_tokens_details.cached_tokens` | `gen_ai.usage.cache_read.input_tokens` | Recommended | Cached input tokens |+| `system_fingerprint` | Custom attribute | Optional | OpenAI-specific backend configuration identifier |### 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 |+Request mapping:+| Anthropic Parameter | OTel Attribute | Required Level | Notes |+|---------------------|----------------|----------------|-------|+| `messages` | `gen_ai.input.messages` | Opt-In | Transform to structured format |+| `system` | `gen_ai.system_instructions` | Opt-In | Single string (not in messages array) |+| `model` | `gen_ai.request.model` | Conditionally Required | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Recommended | Direct mapping |+| `max_tokens` | `gen_ai.request.max_tokens` | Recommended | Direct mapping |+| `top_p` | `gen_ai.request.top_p` | Recommended | Direct mapping |+| `top_k` | `gen_ai.request.top_k` | Recommended | Direct mapping (Anthropic-specific) |+| `stop_sequences` | `gen_ai.request.stop_sequences` | Recommended | Direct mapping |+| `tools` | `gen_ai.tool.definitions` | Opt-In | 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` |+| Anthropic Field | OTel Attribute | Required Level |+|-----------------|----------------|----------------|+| `id` | `gen_ai.response.id` | Recommended |+| `model` | `gen_ai.response.model` | Recommended |+| `content[0].text` | Part of `gen_ai.output.messages` | Opt-In |+| `content[*].type="tool_use"` | Part of `gen_ai.output.messages` | Opt-In |+| `stop_reason` | Map to `gen_ai.output.messages[0].finish_reason` | Recommended |+| `usage.input_tokens` | `gen_ai.usage.input_tokens` | Recommended |+| `usage.output_tokens` | `gen_ai.usage.output_tokens` | Recommended |+| `usage.cache_creation_input_tokens` | `gen_ai.usage.cache_creation.input_tokens` | Recommended |+| `usage.cache_read_input_tokens` | `gen_ai.usage.cache_read.input_tokens` | Recommended |### 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` |+Request mapping:+| Google Parameter | OTel Attribute | Required Level | Notes |+|------------------|----------------|----------------|-------|+| `contents` | `gen_ai.input.messages` | Opt-In | Already uses "parts" structure, map role "model"→"assistant" |+| `systemInstruction` | `gen_ai.system_instructions` | Opt-In | Direct mapping |+| `model` | `gen_ai.request.model` | Conditionally Required | Extract from full name (e.g., "models/gemini-pro" → "gemini-pro") |+| `generationConfig.temperature` | `gen_ai.request.temperature` | Recommended | Direct mapping |+| `generationConfig.maxOutputTokens` | `gen_ai.request.max_tokens` | Recommended | Direct mapping |+| `generationConfig.topP` | `gen_ai.request.top_p` | Recommended | Direct mapping |+| `generationConfig.topK` | `gen_ai.request.top_k` | Recommended | Direct mapping |+| `generationConfig.stopSequences` | `gen_ai.request.stop_sequences` | Recommended | Direct mapping |+| `generationConfig.seed` | `gen_ai.request.seed` | Conditionally Required | Include if provided |+| `tools` | `gen_ai.tool.definitions` | Opt-In | 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` |+| Google Field | OTel Attribute | Required Level | Notes |+|--------------|----------------|----------------|-------|+| N/A | `gen_ai.response.id` | Recommended | Google doesn't provide response IDs - set to None |+| Extracted from request | `gen_ai.response.model` | Recommended | Use request model |+| `candidates[0].content.parts[0].text` | Part of `gen_ai.output.messages` | Opt-In | Text content |+| `candidates[0].content.parts[*].functionCall` | Part of `gen_ai.output.messages` | Opt-In | Tool calls (no IDs provided) |+| `candidates[0].finishReason` | Map to `gen_ai.output.messages[0].finish_reason` | Recommended | Map: STOP→stop, MAX_TOKENS→max_tokens, SAFETY→content_filter |+| `usageMetadata.promptTokenCount` | `gen_ai.usage.input_tokens` | Recommended | Direct mapping |+| `usageMetadata.candidatesTokenCount` | `gen_ai.usage.output_tokens` | Recommended | Direct mapping |+| `usageMetadata.cachedContentTokenCount` | `gen_ai.usage.cache_read.input_tokens` | Recommended | Cached input tokens |+| `usageMetadata.thoughtsTokenCount` | Custom attribute | Recommended | Google-specific reasoning tokens (not in OTel spec yet) |### 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 |+Request mapping:+| Cohere Parameter | OTel Attribute | Required Level | Notes |+|------------------|----------------|----------------|-------|+| `message` | `gen_ai.input.messages` | Opt-In | Transform to array with user role |+| `chat_history` | `gen_ai.input.messages` | Opt-In | Combine with message |+| `preamble` | `gen_ai.system_instructions` | Opt-In | Direct mapping |+| `model` | `gen_ai.request.model` | Conditionally Required | Direct mapping |+| `temperature` | `gen_ai.request.temperature` | Recommended | Direct mapping |+| `max_tokens` | `gen_ai.request.max_tokens` | Recommended | Direct mapping |+| `p` | `gen_ai.request.top_p` | Recommended | Direct mapping (Cohere uses 'p' instead of 'top_p') |+| `k` | `gen_ai.request.top_k` | Recommended | Direct mapping (Cohere uses 'k' instead of 'top_k') |+| `stop_sequences` | `gen_ai.request.stop_sequences` | Recommended | Direct mapping |+| `seed` | `gen_ai.request.seed` | Conditionally Required | Include if provided |+| `tools` | `gen_ai.tool.definitions` | Opt-In | 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` |+| Cohere Field | OTel Attribute | Required Level | Notes |+|--------------|----------------|----------------|-------|+| `generation_id` | `gen_ai.response.id` | Recommended | Direct mapping |+| From request | `gen_ai.response.model` | Recommended | Echo request model |+| `text` | Part of `gen_ai.output.messages` | Opt-In | Text content |+| `tool_calls` | Part of `gen_ai.output.messages` | Opt-In | Tool calls |+| `finish_reason` | Map to `gen_ai.output.messages[0].finish_reason` | Recommended | Map: COMPLETE→stop, MAX_TOKENS→max_tokens |+| `meta.tokens.input_tokens` | `gen_ai.usage.input_tokens` | Recommended | Direct mapping |+| `meta.tokens.output_tokens` | `gen_ai.usage.output_tokens` | Recommended | Direct mapping |++---++## Missing Attributes to Add++Based on the OTel Gen-AI semantic conventions, these attributes are currently missing from our implementation and should be added:++### High Priority (Conditionally Required)++| Attribute | Type | Condition | Current Status | Implementation Notes |+|-----------|------|-----------|----------------|---------------------|+| `gen_ai.conversation.id` | string | When readily available | ❌ Not implemented | Add when session/conversation tracking is available |+| `gen_ai.output.type` | string | When applicable | ❌ Not implemented | Extract from `response_format.type` (OpenAI), add to emit_inference_event() |+| `gen_ai.request.choice.count` | int | If available and ≠ 1 | ❌ Not implemented | Extract from `n` parameter (OpenAI), add to emit_inference_event() |+| `error.type` | string | If operation failed | ❌ Not implemented | Capture error class in exception handlers, add to event attributes |++### Medium Priority (Recommended)++| Attribute | Type | Current Status | Implementation Notes |+|-----------|------|----------------|---------------------|+| `gen_ai.request.frequency_penalty` | double | ✅ Partially | Only in OpenAI, add to Anthropic/Google event emission |+| `gen_ai.request.presence_penalty` | double | ✅ Partially | Only in OpenAI, add to event emission |+| `gen_ai.usage.cache_creation.input_tokens` | int | ❌ Not implemented | Anthropic provides this, add to emit_inference_event() |+| `gen_ai.usage.cache_read.input_tokens` | int | ❌ Not implemented | Anthropic & OpenAI provide this, add to emit_inference_event() |++### Implementation Checklist++**For OpenAI:**+- [ ] Add `gen_ai.output.type` from `response_format.type`+- [ ] Add `gen_ai.request.choice.count` from `n` parameter+- [ ] Add `gen_ai.usage.cache_read.input_tokens` from `usage.prompt_tokens_details.cached_tokens`+- [ ] Add `gen_ai.request.frequency_penalty` to event emission+- [ ] Add `gen_ai.request.presence_penalty` to event emission+- [ ] Add error handling with `error.type` attribute++**For Anthropic:**+- [ ] Add `gen_ai.usage.cache_creation.input_tokens` from `usage.cache_creation_input_tokens`+- [ ] Add `gen_ai.usage.cache_read.input_tokens` from `usage.cache_read_input_tokens`+- [ ] Add error handling with `error.type` attribute++**For Google AI Studio:**+- [ ] Add `gen_ai.usage.cache_read.input_tokens` from `usageMetadata.cachedContentTokenCount`+- [ ] Add `gen_ai.request.seed` when provided+- [ ] Add error handling with `error.type` attribute++**All Providers:**+- [ ] Add `gen_ai.conversation.id` extraction when session tracking is available+- [ ] Implement error.type capture in exception handlers+- [ ] Update emit_inference_event() signature to accept new attributes+- [ ] Update SemanticConvention constants for new attributes---@@ -499,19 +655,47 @@ emit_inference_event(## Validation Checklist-When implementing event emission:+When implementing event emission, verify:++### Event Structure+- [ ] Event name is exactly `gen_ai.client.inference.operation.details` (inference) or `gen_ai.evaluation.result` (evaluation)+- [ ] Event body is empty string (all data in attributes per OTel spec)+- [ ] Using OTel EventLoggerProvider (not span events)++### Required Attributes+- [ ] `gen_ai.operation.name` always present (inference events)+- [ ] `gen_ai.evaluation.name` always present (evaluation events)-- [ ] Event name is exactly `gen_ai.client.inference.operation.details`+### Conditionally Required Attributes+- [ ] `error.type` included if operation failed+- [ ] `server.port` included if `server.address` is set+- [ ] `gen_ai.request.seed` included if seed was provided+- [ ] `gen_ai.evaluation.score.label` or `gen_ai.evaluation.score.value` present (at least one)++### Recommended Attributes+- [ ] Request parameters included when available (`temperature`, `max_tokens`, `top_p`, etc.)+- [ ] Response metadata included when available (`response_id`, `finish_reasons`, `response_model`)+- [ ] Usage metrics included when available (`input_tokens`, `output_tokens`, cache tokens)+- [ ] Server information included when known (`server.address`, `server.port`)++### Opt-In Attributes (Content)+- [ ] Content attributes ONLY included when `capture_message_content=True`- [ ] 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+- [ ] No data URIs in image references (only HTTP/HTTPS URLs)- [ ] 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+- [ ] System instructions included when present++### Message Format+- [ ] Input messages follow [OTel input schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-input-messages.json)+- [ ] Output messages follow [OTel output schema](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-output-messages.json)+- [ ] Finish reasons mapped to OTel standard values (not provider-specific)+- [ ] Message parts use correct types: `text`, `uri`, `tool_call`, `tool_call_response`++### Error Handling+- [ ] Event emission wrapped in try/except (never raises)+- [ ] Silent failures with warning logs+- [ ] Instrumentation continues even if event emission fails---@@ -524,4 +708,15 @@ When implementing event emission:----**Last Updated:** 2026-02-12+## Summary of Requirement Levels++| Level | Symbol | Meaning | Example |+|-------|--------|---------|---------|+| **Required** | 🔴 | MUST be present in every event | `gen_ai.operation.name` |+| **Conditionally Required** | 🟡 | MUST be present when condition met | `error.type` (if error occurred) |+| **Recommended** | 🟢 | SHOULD be present when available | `gen_ai.response.id`, `gen_ai.usage.input_tokens` |+| **Opt-In** | 🔵 | Only when explicitly enabled (sensitive data) | `gen_ai.input.messages`, `gen_ai.output.messages` |++---++**Last Updated:** 2026-02-12 (Expanded with complete OTel attribute requirements)diff --git a/sdk/python/src/openlit/instrumentation/anthropic/__init__.py b/sdk/python/src/openlit/instrumentation/anthropic/__init__.pyindex 3af7cc35..9f04e69d 100644--- a/sdk/python/src/openlit/instrumentation/anthropic/__init__.py+++ b/sdk/python/src/openlit/instrumentation/anthropic/__init__.py@@ -28,6 +28,7 @@ class AnthropicInstrumentor(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")# syncwrap_function_wrapper(@@ -42,6 +43,7 @@ class AnthropicInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -58,6 +60,7 @@ class AnthropicInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py b/sdk/python/src/openlit/instrumentation/anthropic/anthropic.pyindex 62a80c25..8bf1b8b7 100644--- a/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py+++ b/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py@@ -22,6 +22,7 @@ def messages(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Anthropic Messages.create calls.@@ -40,6 +41,7 @@ def messages(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -63,6 +65,7 @@ def messages(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -95,6 +98,7 @@ def messages(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)@@ -119,7 +123,13 @@ def messages(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:@@ -142,6 +152,7 @@ def messages(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/anthropic/async_anthropic.py b/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.pyindex b6641da1..1bfcd97d 100644--- a/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py+++ b/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py@@ -22,6 +22,7 @@ def async_messages(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Anthropic AsyncMessages.create calls.@@ -40,6 +41,7 @@ def async_messages(kwargs,server_address,server_port,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -63,6 +65,7 @@ def async_messages(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -95,6 +98,7 @@ def async_messages(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)@@ -119,7 +123,13 @@ def async_messages(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:@@ -142,6 +152,7 @@ def async_messages(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/anthropic/utils.py b/sdk/python/src/openlit/instrumentation/anthropic/utils.pyindex d1a17c5e..367533be 100644--- a/sdk/python/src/openlit/instrumentation/anthropic/utils.py+++ b/sdk/python/src/openlit/instrumentation/anthropic/utils.py@@ -50,6 +50,361 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages, system=None):+ """+ Convert Anthropic request messages to OTel input message structure.++ Args:+ messages: Anthropic messages array from request+ system: Optional system instruction string++ Returns:+ List of ChatMessage objects with role and parts+ """+ import logging++ logger = logging.getLogger(__name__)++ if not messages:+ return []++ otel_messages = []++ # Add system message first if present+ if system:+ otel_messages.append(+ {"role": "system", "parts": [{"type": "text", "content": system}]}+ )++ 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", "")+ )++ parts = []++ if isinstance(content, list):+ # Multi-part content (text, images, tool results)+ for item in content:+ item_type = (+ item.get("type")+ if isinstance(item, dict)+ else getattr(item, "type", None)+ )++ 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":+ # Anthropic image format: {"type": "image", "source": {"type": "url", "url": "..."}}+ source = (+ item.get("source", {})+ if isinstance(item, dict)+ else getattr(item, "source", {})+ )+ if isinstance(source, dict) and source.get("type") == "url":+ url = source.get("url", "")+ if url and not url.startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": url}+ )++ elif item_type == "tool_use":+ # Anthropic tool use in request (assistant message)+ tool_id = (+ item.get("id", "")+ if isinstance(item, dict)+ else getattr(item, "id", "")+ )+ tool_name = (+ item.get("name", "")+ if isinstance(item, dict)+ else getattr(item, "name", "")+ )+ tool_input = (+ item.get("input", {})+ if isinstance(item, dict)+ else getattr(item, "input", {})+ )+ parts.append(+ {+ "type": "tool_call",+ "id": tool_id,+ "name": tool_name,+ "arguments": tool_input,+ }+ )++ elif item_type == "tool_result":+ # Anthropic tool result (user providing tool response)+ tool_id = (+ item.get("tool_use_id", "")+ if isinstance(item, dict)+ else getattr(item, "tool_use_id", "")+ )+ tool_content = (+ item.get("content", "")+ if isinstance(item, dict)+ else getattr(item, "content", "")+ )+ parts.append(+ {+ "type": "tool_call_response",+ "id": tool_id,+ "response": str(tool_content),+ }+ )++ elif isinstance(content, str) and content:+ # Simple string content+ parts.append({"type": "text", "content": content})++ if parts:+ otel_messages.append({"role": role, "parts": parts})++ 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 Anthropic response to OTel output message structure.++ Args:+ response_text: Response text from model+ finish_reason: Finish reason from Anthropic (end_turn, max_tokens, stop_sequence, tool_use)+ tool_calls: Optional tool calls dict from response++ Returns:+ List with single OutputMessage+ """+ import logging++ logger = logging.getLogger(__name__)++ parts = []++ try:+ # Add text content if present+ if response_text:+ parts.append({"type": "text", "content": response_text})++ # Add tool call if present+ if tool_calls:+ parts.append(+ {+ "type": "tool_call",+ "id": tool_calls.get("id", ""),+ "name": tool_calls.get("name", ""),+ "arguments": tool_calls.get("input", {}),+ }+ )++ # Map Anthropic finish reasons to OTel standard+ finish_reason_map = {+ "end_turn": "stop",+ "max_tokens": "max_tokens",+ "stop_sequence": "stop",+ "tool_use": "tool_calls",+ }++ 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 [{"role": "assistant", "parts": [], "finish_reason": "stop"}]+++def build_tool_definitions(tools):+ """+ Extract tool/function definitions from Anthropic request.++ Args:+ tools: Tools array from Anthropic request++ Returns:+ List of tool definition objects or None+ """+ import logging++ logger = logging.getLogger(__name__)++ if not tools:+ return None++ try:+ tool_definitions = []++ for tool in tools:+ try:+ if isinstance(tool, dict):+ # Anthropic format already compatible with OTel+ tool_definitions.append(+ {+ "type": "function",+ "name": tool.get("name", ""),+ "description": tool.get("description", ""),+ "parameters": tool.get("input_schema", {}),+ }+ )+ else:+ # Handle object format+ tool_definitions.append(+ {+ "type": "function",+ "name": getattr(tool, "name", ""),+ "description": getattr(tool, "description", ""),+ "parameters": getattr(tool, "input_schema", {}),+ }+ )+ 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)+ request_model: Model from request+ response_model: Model from response+ input_messages: Structured input messages+ output_messages: Structured output messages+ tool_definitions: Tool definitions+ server_address: Server address+ server_port: Server port+ **extra_attrs: Additional attributes (temperature, max_tokens, etc.)+ """+ import logging++ logger = logging.getLogger(__name__)++ try:+ if not event_provider:+ return++ from openlit.__helpers import otel_event++ # 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 messages+ 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++ # Map extra attributes+ for key, value in extra_attrs.items():+ if value is not None:+ 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 == "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 == "top_k":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_K] = value+ elif key == "stop_sequences":+ attributes[SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES] = 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[+ SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS+ ] = value+ elif key == "cache_read_input_tokens":+ attributes[+ SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS+ ] = value++ # Create and emit event+ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="",+ )++ event_provider.emit(event)++ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)++def process_chunk(scope, chunk):"""Process a chunk of response data and update state.@@ -68,7 +423,13 @@ def process_chunk(scope, chunk):# Collect message IDs and input token from eventsif chunked.get("type") == "message_start":scope._response_id = chunked.get("message").get("id")- scope._input_tokens = chunked.get("message").get("usage").get("input_tokens")+ message_usage = chunked.get("message").get("usage", {})+ scope._input_tokens = message_usage.get("input_tokens", 0)+ # Extract cache tokens from message_start event+ scope._cache_creation_input_tokens = message_usage.get(+ "cache_creation_input_tokens", 0+ )+ scope._cache_read_input_tokens = message_usage.get("cache_read_input_tokens", 0)scope._response_model = chunked.get("message").get("model")scope._response_role = chunked.get("message").get("role")@@ -101,6 +462,7 @@ def common_chat_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -197,19 +559,51 @@ 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: formatted_messages,- },- )- 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:+ import logging++ logger = logging.getLogger(__name__)+ try:+ input_msgs = build_input_messages(+ scope._kwargs.get("messages", []),+ system=scope._kwargs.get("system"),+ )+ output_msgs = build_output_messages(+ scope._llmresponse, scope._finish_reason, scope._tool_calls+ )+ 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],+ temperature=scope._kwargs.get("temperature"),+ max_tokens=scope._kwargs.get("max_tokens"),+ top_p=scope._kwargs.get("top_p"),+ top_k=scope._kwargs.get("top_k"),+ stop_sequences=scope._kwargs.get("stop_sequences"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ cache_creation_input_tokens=scope._cache_creation_input_tokens+ if hasattr(scope, "_cache_creation_input_tokens")+ and scope._cache_creation_input_tokens > 0+ else None,+ cache_read_input_tokens=scope._cache_read_input_tokens+ if hasattr(scope, "_cache_read_input_tokens")+ and scope._cache_read_input_tokens > 0+ else None,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -244,6 +638,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming chat response and generate telemetry.@@ -266,6 +661,7 @@ def process_streaming_chat_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -283,6 +679,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -298,8 +695,14 @@ def process_chat_response(scope._span = spanscope._llmresponse = response_dict.get("content", [{}])[0].get("text", "")scope._response_role = response_dict.get("role", "assistant")- scope._input_tokens = response_dict.get("usage").get("input_tokens")- scope._output_tokens = response_dict.get("usage").get("output_tokens")++ # Extract usage including cache tokens (Anthropic prompt caching)+ usage = response_dict.get("usage", {})+ scope._input_tokens = usage.get("input_tokens", 0)+ scope._output_tokens = usage.get("output_tokens", 0)+ scope._cache_creation_input_tokens = usage.get("cache_creation_input_tokens", 0)+ scope._cache_read_input_tokens = usage.get("cache_read_input_tokens", 0)+scope._response_model = response_dict.get("model", "")scope._finish_reason = response_dict.get("stop_reason", "")scope._response_id = response_dict.get("id", "")@@ -330,6 +733,7 @@ def process_chat_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/azure_ai_inference/__init__.py b/sdk/python/src/openlit/instrumentation/azure_ai_inference/__init__.pyindex 867161f9..2229964c 100644--- a/sdk/python/src/openlit/instrumentation/azure_ai_inference/__init__.py+++ b/sdk/python/src/openlit/instrumentation/azure_ai_inference/__init__.py@@ -32,6 +32,7 @@ class AzureAIInferenceInstrumentor(BaseInstrumentor):pricing_info = kwargs.get("pricing_info", {})capture_message_content = kwargs.get("capture_message_content", False)disable_metrics = kwargs.get("disable_metrics")+ event_provider = kwargs.get("event_provider")version = importlib.metadata.version("azure-ai-inference")# sync chat completions@@ -47,6 +48,7 @@ class AzureAIInferenceInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -63,6 +65,7 @@ class AzureAIInferenceInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -79,6 +82,7 @@ class AzureAIInferenceInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -95,6 +99,7 @@ class AzureAIInferenceInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/azure_ai_inference/async_azure_ai_inference.py b/sdk/python/src/openlit/instrumentation/azure_ai_inference/async_azure_ai_inference.pyindex 35f5d663..764321bd 100644--- a/sdk/python/src/openlit/instrumentation/azure_ai_inference/async_azure_ai_inference.py+++ b/sdk/python/src/openlit/instrumentation/azure_ai_inference/async_azure_ai_inference.py@@ -30,6 +30,7 @@ def async_complete(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -48,6 +49,7 @@ def async_complete(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -72,6 +74,7 @@ def async_complete(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -88,6 +91,7 @@ def async_complete(capture_message_content,disable_metrics,version,+ event_provider=self._event_provider,)def __aiter__(self):@@ -119,7 +123,13 @@ def async_complete(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=event_provider,)else:@@ -140,6 +150,7 @@ def async_complete(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -157,6 +168,7 @@ def async_embed(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI embedding function call@@ -195,6 +207,7 @@ def async_embed(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/azure_ai_inference/azure_ai_inference.py b/sdk/python/src/openlit/instrumentation/azure_ai_inference/azure_ai_inference.pyindex 25ff9684..9e80d773 100644--- a/sdk/python/src/openlit/instrumentation/azure_ai_inference/azure_ai_inference.py+++ b/sdk/python/src/openlit/instrumentation/azure_ai_inference/azure_ai_inference.py@@ -30,6 +30,7 @@ def complete(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -48,6 +49,7 @@ def complete(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -72,6 +74,7 @@ def complete(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -88,6 +91,7 @@ def complete(capture_message_content,disable_metrics,version,+ event_provider=self._event_provider,)def __iter__(self):@@ -119,7 +123,13 @@ def complete(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=event_provider,)else:@@ -140,6 +150,7 @@ def complete(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -157,6 +168,7 @@ def embed(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI embedding function call@@ -195,6 +207,7 @@ def embed(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/azure_ai_inference/utils.py b/sdk/python/src/openlit/instrumentation/azure_ai_inference/utils.pyindex 68711009..c3f20cd7 100644--- a/sdk/python/src/openlit/instrumentation/azure_ai_inference/utils.py+++ b/sdk/python/src/openlit/instrumentation/azure_ai_inference/utils.py@@ -15,6 +15,7 @@ from openlit.__helpers import (common_span_attributes,record_completion_metrics,record_embedding_metrics,+ otel_event,)from openlit.semcov import SemanticConvention@@ -43,6 +44,228 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages):+ """+ Convert Azure AI Inference messages to OTel input message structure.++ Args:+ messages: List of message objects (OpenAI-compatible format)++ Returns:+ List of ChatMessage objects following OTel schema+ """+ 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,+ }+ )++ if parts:+ structured_messages.append({"role": role, "parts": parts})++ return structured_messages+++def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert Azure AI Inference response to OTel output message structure.++ Args:+ response_text: The text response+ finish_reason: Azure AI finish reason value+ tool_calls: Tool calls from response++ Returns:+ List with single OutputMessage following OTel schema+ """+ 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 Azure AI finish reasons to OTel standard (follows OpenAI)+ finish_reason_map = {+ "stop": "stop",+ "length": "max_tokens",+ "tool_calls": "tool_calls",+ "content_filter": "content_filter",+ }++ otel_finish_reason = finish_reason_map.get(finish_reason, finish_reason)++ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish_reason}]+++def build_tool_definitions(tools):+ """+ Extract tool definitions from request.++ Args:+ tools: Azure AI tools array (OpenAI-compatible format)++ Returns:+ List of tool definition objects or None+ """+ # Azure AI Inference uses OpenAI-compatible tool format+ # Direct pass-through+ return tools if tools else 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,+):+ """+ 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++ # Build base attributes+ attributes = {+ SemanticConvention.GEN_AI_OPERATION_NAME: 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,+ "reasoning_tokens": "gen_ai.usage.reasoning_tokens", # Azure-specific+ "encoding_format": "gen_ai.request.encoding_format", # For embeddings+ "dimensions": "gen_ai.request.dimensions", # For embeddings+ "cache_creation_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,+ "cache_read_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_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)++def process_chunk(scope, chunk):"""Process a chunk of response data and update state.@@ -133,6 +356,7 @@ def common_chat_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -273,19 +497,46 @@ def common_chat_logic(SemanticConvention.GEN_AI_CONTENT_REASONING, scope._reasoning_content)- # 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 OTel log event+ if event_provider:+ try:+ # Build structured messages+ input_msgs = build_input_messages(scope._kwargs.get("messages", []))+ output_msgs = build_output_messages(+ scope._llmresponse, scope._finish_reason, tool_calls=scope._tools+ )+ 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],+ temperature=scope._kwargs.get("temperature"),+ max_tokens=scope._kwargs.get("max_tokens"),+ top_p=scope._kwargs.get("top_p"),+ frequency_penalty=scope._kwargs.get("frequency_penalty"),+ presence_penalty=scope._kwargs.get("presence_penalty"),+ stop_sequences=scope._kwargs.get("stop"),+ seed=scope._kwargs.get("seed"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ reasoning_tokens=scope._reasoning_tokens+ if hasattr(scope, "_reasoning_tokens")+ else None,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -320,6 +571,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming chat request and generate Telemetry@@ -335,6 +587,7 @@ def process_streaming_chat_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -352,6 +605,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -419,6 +673,7 @@ def process_chat_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return response@@ -433,6 +688,7 @@ def common_embedding_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Process embedding request and generate Telemetry@@ -484,15 +740,41 @@ def common_embedding_logic(str(scope._kwargs.get("input", "")),)- # 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: str(- scope._kwargs.get("input", "")- ),- },- )+ # Emit OTel log event+ if event_provider:+ try:+ # For embeddings, input is text strings, output is empty+ # Build input messages from embedding input+ input_text = scope._kwargs.get("input", [])+ if isinstance(input_text, str):+ input_text = [input_text]++ # Create simple text input messages+ input_msgs = [+ {"role": "user", "parts": [{"type": "text", "content": text}]}+ for text in input_text+ ]++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ request_model=request_model,+ response_model=scope._response_model,+ input_messages=input_msgs,+ output_messages=[], # Embeddings don't have text output+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=scope._response_id,+ input_tokens=scope._input_tokens,+ encoding_format=scope._kwargs.get("encoding_format"),+ dimensions=scope._kwargs.get("dimensions"),+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -529,6 +811,7 @@ def process_embedding_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -556,6 +839,7 @@ def process_embedding_response(capture_message_content,disable_metrics,version,+ event_provider=event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/bedrock/__init__.py b/sdk/python/src/openlit/instrumentation/bedrock/__init__.pyindex 1f8795a3..e690fd8f 100644--- a/sdk/python/src/openlit/instrumentation/bedrock/__init__.py+++ b/sdk/python/src/openlit/instrumentation/bedrock/__init__.py@@ -27,6 +27,7 @@ class BedrockInstrumentor(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")# syncwrap_function_wrapper(@@ -41,6 +42,7 @@ class BedrockInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -57,6 +59,7 @@ class BedrockInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/bedrock/bedrock.py b/sdk/python/src/openlit/instrumentation/bedrock/bedrock.pyindex 0467714a..3fd6368c 100644--- a/sdk/python/src/openlit/instrumentation/bedrock/bedrock.py+++ b/sdk/python/src/openlit/instrumentation/bedrock/bedrock.py@@ -22,6 +22,7 @@ def converse(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for AWS Bedrock converse calls.@@ -67,6 +68,7 @@ def converse(disable_metrics=disable_metrics,version=version,llm_config=llm_config,+ event_provider=event_provider,**method_kwargs,)@@ -99,6 +101,7 @@ def converse_stream(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for AWS Bedrock converse_stream calls.@@ -117,6 +120,7 @@ def converse_stream(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped_response = wrapped_response@@ -145,6 +149,7 @@ def converse_stream(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):if hasattr(self.__wrapped_stream, "__enter__"):@@ -195,6 +200,7 @@ def converse_stream(disable_metrics=disable_metrics,version=version,llm_config=llm_config,+ event_provider=self._event_provider,)except Exception as e:@@ -232,6 +238,7 @@ def converse_stream(method_kwargs,server_address,server_port,+ event_provider=event_provider,)# Get the original client instance from the wrapperdiff --git a/sdk/python/src/openlit/instrumentation/bedrock/utils.py b/sdk/python/src/openlit/instrumentation/bedrock/utils.pyindex c054f9cc..f910f963 100644--- a/sdk/python/src/openlit/instrumentation/bedrock/utils.py+++ b/sdk/python/src/openlit/instrumentation/bedrock/utils.py@@ -14,6 +14,7 @@ from openlit.__helpers import (record_completion_metrics,common_span_attributes,handle_exception,+ otel_event,)from openlit.semcov import SemanticConvention@@ -55,6 +56,240 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages):+ """+ Convert Bedrock messages to OTel input message structure.++ Args:+ messages: List of Bedrock message objects or dicts++ Returns:+ List of ChatMessage objects following OTel schema+ """+ structured_messages = []++ for message in messages:+ # Extract role and content+ if isinstance(message, dict):+ role = message.get("role", "user")+ content = message.get("content", [])+ else:+ # Handle Bedrock object format+ role = getattr(message, "role", "user")+ content = getattr(message, "content", [])++ # Ensure content is a list+ if isinstance(content, str):+ content = [{"text": content}]+ elif not isinstance(content, list):+ content = [{"text": str(content)}]++ # Build parts array+ parts = []+ for part in content:+ if isinstance(part, dict):+ # Handle text blocks+ if "text" in part:+ parts.append({"type": "text", "content": part.get("text", "")})+ elif part.get("type") == "text":+ parts.append({"type": "text", "content": part.get("text", "")})++ # Handle image blocks - only include if has URL (skip embedded bytes)+ elif "image" in part:+ image_data = part.get("image", {})+ source = image_data.get("source", {})+ # Only include if URL-based, skip bytes+ if "url" in source:+ parts.append(+ {+ "type": "uri",+ "modality": "image",+ "uri": source.get("url"),+ }+ )++ # Handle document blocks - skip if has embedded bytes+ elif "document" in part:+ document_data = part.get("document", {})+ source = document_data.get("source", {})+ # Only include if URL-based+ if "url" in source:+ parts.append(+ {+ "type": "uri",+ "modality": "document",+ "uri": source.get("url"),+ "name": document_data.get("name", ""),+ }+ )++ if parts:+ structured_messages.append({"role": role, "parts": parts})++ return structured_messages+++def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert Bedrock response to OTel output message structure.++ Args:+ response_text: The text response from Bedrock+ finish_reason: Bedrock stopReason value+ tool_calls: Tool calls (reserved for future, currently None)++ Returns:+ List with single OutputMessage following OTel schema+ """+ parts = []++ # Add text content if present+ if response_text:+ parts.append({"type": "text", "content": response_text})++ # Add tool calls if present (future support)+ if tool_calls:+ for tool_call in tool_calls:+ parts.append(+ {+ "type": "tool_call",+ "id": tool_call.get("id", ""),+ "name": tool_call.get("name", ""),+ "arguments": tool_call.get("arguments", {}),+ }+ )++ # Map Bedrock finish reasons to OTel standard+ finish_reason_map = {+ "end_turn": "stop",+ "max_tokens": "max_tokens",+ "stop_sequence": "stop",+ "tool_use": "tool_calls",+ "content_filtered": "content_filter",+ "guardrail_intervention": "content_filter",+ }++ otel_finish_reason = finish_reason_map.get(finish_reason, finish_reason)++ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish_reason}]+++def build_tool_definitions(tools):+ """+ Extract tool definitions from Bedrock toolConfig.++ Args:+ tools: Bedrock tools array from toolConfig++ Returns:+ List of tool definition objects or None++ Note: Currently returns None as Bedrock tool instrumentation is not yet implemented.+ Reserved for future when tool support is added.+ """+ # Bedrock tool support not yet instrumented+ # Will be implemented when tool calls are added to instrumentation+ 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,+):+ """+ 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++ # Build base attributes+ attributes = {+ SemanticConvention.GEN_AI_OPERATION_NAME: 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,+ "top_k": SemanticConvention.GEN_AI_REQUEST_TOP_K,+ "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,+ "cache_creation_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,+ "cache_read_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_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)++def process_chunk(self, chunk):"""Process a chunk of response data and update state.@@ -107,6 +342,7 @@ def common_chat_logic(version,llm_config,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -189,19 +425,49 @@ 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: formatted_messages,- },- )- scope._span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,- },- )+ # Emit OTel log event+ if event_provider:+ try:+ # Build structured messages+ input_msgs = build_input_messages(scope._kwargs.get("messages", []))+ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ tool_calls=None, # No tool support yet+ )+ # pylint: disable=assignment-from-none+ tool_defs = build_tool_definitions(+ scope._kwargs.get("toolConfig", {}).get("tools")+ )++ # Extract inferenceConfig parameters+ inference_config = llm_config or {}++ 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 if scope._response_id else None,+ finish_reasons=[scope._finish_reason],+ temperature=inference_config.get("temperature"),+ max_tokens=inference_config.get("maxTokens"),+ top_p=inference_config.get("topP"),+ top_k=inference_config.get("topK"),+ stop_sequences=inference_config.get("stopSequences"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -237,6 +503,7 @@ def process_streaming_chat_response(disable_metrics=False,version="",llm_config=None,+ event_provider=None,):"""Process streaming chat response and generate telemetry.@@ -257,6 +524,7 @@ def process_streaming_chat_response(version,llm_config,is_stream=True,+ event_provider=event_provider,)except Exception as e:handle_exception(scope._span, e)@@ -278,6 +546,7 @@ def process_chat_response(disable_metrics=False,version="1.0.0",llm_config=None,+ event_provider=None,**kwargs,):"""@@ -324,6 +593,7 @@ def process_chat_response(version,llm_config,is_stream=False,+ event_provider=event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/google_ai_studio/__init__.py b/sdk/python/src/openlit/instrumentation/google_ai_studio/__init__.pyindex 82a27304..4411400d 100644--- a/sdk/python/src/openlit/instrumentation/google_ai_studio/__init__.py+++ b/sdk/python/src/openlit/instrumentation/google_ai_studio/__init__.py@@ -34,6 +34,7 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):pricing_info = kwargs.get("pricing_info", {})capture_message_content = kwargs.get("capture_message_content", False)disable_metrics = kwargs.get("disable_metrics")+ event_provider = kwargs.get("event_provider")version = importlib.metadata.version("google-genai")# sync generate@@ -49,6 +50,7 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -65,6 +67,7 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -81,6 +84,7 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -97,6 +101,7 @@ class GoogleAIStudioInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/google_ai_studio/async_google_ai_studio.py b/sdk/python/src/openlit/instrumentation/google_ai_studio/async_google_ai_studio.pyindex 9916fee6..f9f9a1b4 100644--- a/sdk/python/src/openlit/instrumentation/google_ai_studio/async_google_ai_studio.py+++ b/sdk/python/src/openlit/instrumentation/google_ai_studio/async_google_ai_studio.py@@ -22,6 +22,7 @@ def async_generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -61,6 +62,7 @@ def async_generate(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,)except Exception as e:@@ -81,6 +83,7 @@ def async_generate_stream(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -99,6 +102,7 @@ def async_generate_stream(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -120,6 +124,7 @@ def async_generate_stream(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -154,6 +159,7 @@ def async_generate_stream(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:@@ -176,7 +182,13 @@ def async_generate_stream(span = tracer.start_as_current_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,)return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/google_ai_studio/google_ai_studio.py b/sdk/python/src/openlit/instrumentation/google_ai_studio/google_ai_studio.pyindex c8692d33..694cd4d4 100644--- a/sdk/python/src/openlit/instrumentation/google_ai_studio/google_ai_studio.py+++ b/sdk/python/src/openlit/instrumentation/google_ai_studio/google_ai_studio.py@@ -22,6 +22,7 @@ def generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -61,6 +62,7 @@ def generate(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,)except Exception as e:@@ -81,6 +83,7 @@ def generate_stream(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -99,6 +102,7 @@ def generate_stream(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -120,6 +124,7 @@ def generate_stream(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -154,6 +159,7 @@ def generate_stream(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)except Exception as e:@@ -176,7 +182,13 @@ def generate_stream(span = tracer.start_as_current_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,)return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/google_ai_studio/utils.py b/sdk/python/src/openlit/instrumentation/google_ai_studio/utils.pyindex a8f882b8..d4cd0c79 100644--- a/sdk/python/src/openlit/instrumentation/google_ai_studio/utils.py+++ b/sdk/python/src/openlit/instrumentation/google_ai_studio/utils.py@@ -72,6 +72,343 @@ def format_content(messages):return prompt+def build_input_messages(contents, system_instruction=None):+ """+ Convert Google AI Studio contents to OTel input message structure.++ Args:+ contents: Contents array from Google AI Studio request+ system_instruction: Optional system instruction++ Returns:+ List of ChatMessage objects with role and parts+ """+ import logging++ logger = logging.getLogger(__name__)++ if not contents:+ return []++ otel_messages = []++ # Add system instruction first if present+ if system_instruction:+ system_text = ""+ if isinstance(system_instruction, str):+ system_text = system_instruction+ elif hasattr(system_instruction, "parts"):+ # Extract text from parts+ for part in system_instruction.parts:+ if hasattr(part, "text") and part.text:+ system_text += part.text++ if system_text:+ otel_messages.append(+ {"role": "system", "parts": [{"type": "text", "content": system_text}]}+ )++ for content in contents:+ try:+ # Extract role - Google uses "user" and "model"+ role = getattr(content, "role", "user")+ if role == "model":+ role = "assistant"++ parts_list = []++ # Google already uses "parts" structure+ if hasattr(content, "parts"):+ for part in content.parts:+ # Text content+ if hasattr(part, "text") and part.text:+ parts_list.append({"type": "text", "content": part.text})++ # File data with URI (skip inline_data to avoid data URIs)+ if hasattr(part, "file_data") and part.file_data:+ file_uri = getattr(part.file_data, "file_uri", None)+ mime_type = getattr(part.file_data, "mime_type", "")+ if file_uri and not file_uri.startswith("data:"):+ modality = (+ "image"+ if "image" in mime_type+ else "video"+ if "video" in mime_type+ else "file"+ )+ parts_list.append(+ {"type": "uri", "modality": modality, "uri": file_uri}+ )++ # Function call (tool call from assistant)+ if hasattr(part, "function_call") and part.function_call:+ fc = part.function_call+ parts_list.append(+ {+ "type": "tool_call",+ "id": "", # Google doesn't provide ID+ "name": getattr(fc, "name", ""),+ "arguments": dict(getattr(fc, "args", {})),+ }+ )++ # Function response (tool result from user)+ if hasattr(part, "function_response") and part.function_response:+ fr = part.function_response+ parts_list.append(+ {+ "type": "tool_call_response",+ "id": "", # Google doesn't provide ID+ "response": str(getattr(fr, "response", "")),+ }+ )++ if parts_list:+ otel_messages.append({"role": role, "parts": parts_list})++ 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, function_calls=None):+ """+ Convert Google AI Studio response to OTel output message structure.++ Args:+ response_text: Response text from model+ finish_reason: Finish reason from Google (STOP, MAX_TOKENS, SAFETY, etc.)+ function_calls: Optional function calls dict from response++ Returns:+ List with single OutputMessage+ """+ import logging++ logger = logging.getLogger(__name__)++ parts = []++ try:+ # Add text content if present+ if response_text:+ parts.append({"type": "text", "content": response_text})++ # Add function calls if present+ if function_calls:+ parts.append(+ {+ "type": "tool_call",+ "id": "", # Google doesn't provide IDs+ "name": function_calls.get("name", ""),+ "arguments": function_calls.get("args", {}),+ }+ )++ # Map Google finish reasons to OTel standard+ finish_reason_map = {+ "STOP": "stop",+ "MAX_TOKENS": "max_tokens",+ "SAFETY": "content_filter",+ "RECITATION": "content_filter",+ "OTHER": "other",+ "FINISH_REASON_UNSPECIFIED": "other",+ }++ otel_finish_reason = finish_reason_map.get(+ finish_reason.upper() if finish_reason else "", 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 [{"role": "assistant", "parts": [], "finish_reason": "stop"}]+++def build_tool_definitions(tools):+ """+ Extract tool/function definitions from Google AI Studio request.++ Args:+ tools: Tools from Google AI Studio request++ Returns:+ List of tool definition objects or None+ """+ import logging++ logger = logging.getLogger(__name__)++ if not tools:+ return None++ try:+ tool_definitions = []++ # Google uses function_declarations+ if hasattr(tools, "function_declarations"):+ for func_decl in tools.function_declarations:+ try:+ # Convert Google schema to OTel format+ params = {}+ if hasattr(func_decl, "parameters"):+ params = {+ "type": getattr(func_decl.parameters, "type", "object"),+ "properties": dict(+ getattr(func_decl.parameters, "properties", {})+ ),+ "required": list(+ getattr(func_decl.parameters, "required", [])+ ),+ }++ tool_definitions.append(+ {+ "type": "function",+ "name": getattr(func_decl, "name", ""),+ "description": getattr(func_decl, "description", ""),+ "parameters": params,+ }+ )+ except Exception as e:+ logger.warning(+ "Failed to process tool definition: %s", e, exc_info=True+ )+ continue+ elif isinstance(tools, list):+ # Handle list format+ for tool in tools:+ if isinstance(tool, dict) and "function_declarations" in tool:+ for func_decl in tool["function_declarations"]:+ tool_definitions.append(+ {+ "type": "function",+ "name": func_decl.get("name", ""),+ "description": func_decl.get("description", ""),+ "parameters": func_decl.get("parameters", {}),+ }+ )++ 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)+ request_model: Model from request+ response_model: Model from response+ input_messages: Structured input messages+ output_messages: Structured output messages+ tool_definitions: Tool definitions+ server_address: Server address+ server_port: Server port+ **extra_attrs: Additional attributes (temperature, max_tokens, etc.)+ """+ import logging++ logger = logging.getLogger(__name__)++ try:+ if not event_provider:+ return++ from openlit.__helpers import otel_event++ # 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 messages+ 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++ # Map extra attributes+ for key, value in extra_attrs.items():+ if value is not None:+ 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 == "temperature":+ attributes[SemanticConvention.GEN_AI_REQUEST_TEMPERATURE] = value+ elif key in ("max_tokens", "max_output_tokens"):+ attributes[SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS] = value+ elif key == "top_p":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_P] = value+ elif key == "top_k":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_K] = value+ elif key == "stop_sequences":+ attributes[SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES] = 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 == "reasoning_tokens":+ # Google-specific: thoughts/reasoning tokens+ attributes[SemanticConvention.GEN_AI_USAGE_REASONING_TOKENS] = value+ elif key == "cache_read_input_tokens":+ attributes[+ SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS+ ] = value++ # Create and emit event+ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="",+ )++ event_provider.emit(event)++ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)++def process_chunk(self, chunk):"""Process a chunk of response data and update state.@@ -88,16 +425,18 @@ def process_chunk(self, chunk):chunked = response_as_dict(chunk)self._response_id = str(chunked.get("response_id"))- self._input_tokens = chunked.get("usage_metadata").get("prompt_token_count")++ # Extract usage including cache tokens (Google prompt caching)+ usage_metadata = chunked.get("usage_metadata", {})+ self._input_tokens = usage_metadata.get("prompt_token_count", 0)+ self._output_tokens = usage_metadata.get("candidates_token_count", 0)+ self._reasoning_tokens = usage_metadata.get("thoughts_token_count") or 0+ self._cache_read_input_tokens = usage_metadata.get("cached_content_token_count", 0)+self._response_model = chunked.get("model_version")if chunk.text:self._llmresponse += str(chunk.text)-- self._output_tokens = chunked.get("usage_metadata").get("candidates_token_count")- self._reasoning_tokens = (- chunked.get("usage_metadata").get("thoughts_token_count") or 0- )self._finish_reason = str(chunked.get("candidates")[0].get("finish_reason"))try:@@ -121,6 +460,7 @@ def common_chat_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -213,24 +553,60 @@ def common_chat_logic(SemanticConvention.GEN_AI_TOOL_ARGS, str(scope._tools.get("args", "")))- # To be removed one the change to span_attributes (from span events) is complete+ # Span Attributes for Contentif capture_message_content:scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, prompt)scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)- 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:+ import logging++ logger = logging.getLogger(__name__)+ try:+ input_msgs = build_input_messages(+ scope._kwargs.get("contents", []),+ system_instruction=getattr(+ inference_config, "system_instruction", None+ ),+ )+ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ function_calls=scope._tools,+ )+ tool_defs = build_tool_definitions(+ getattr(inference_config, "tools", 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=tool_defs,+ server_address=scope._server_address,+ server_port=scope._server_port,+ finish_reasons=[scope._finish_reason],+ temperature=getattr(inference_config, "temperature", None),+ max_output_tokens=getattr(inference_config, "max_tokens", None),+ top_p=getattr(inference_config, "top_p", None),+ top_k=getattr(inference_config, "top_k", None),+ stop_sequences=getattr(inference_config, "stop_sequences", None),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ reasoning_tokens=scope._reasoning_tokens,+ cache_read_input_tokens=scope._cache_read_input_tokens+ if hasattr(scope, "_cache_read_input_tokens")+ and scope._cache_read_input_tokens > 0+ else None,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -273,6 +649,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process chat request and generate Telemetry@@ -288,6 +665,7 @@ def process_streaming_chat_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -308,6 +686,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,):"""Process chat request and generate Telemetry@@ -320,13 +699,14 @@ def process_chat_response(self._end_time = time.time()self._span = spanself._llmresponse = str(response.text)- self._input_tokens = response_dict.get("usage_metadata").get("prompt_token_count")- self._output_tokens = response_dict.get("usage_metadata").get(- "candidates_token_count"- )- self._reasoning_tokens = (- response_dict.get("usage_metadata").get("thoughts_token_count") or 0- )++ # Extract usage including cache tokens (Google prompt caching)+ usage_metadata = response_dict.get("usage_metadata", {})+ self._input_tokens = usage_metadata.get("prompt_token_count", 0)+ self._output_tokens = usage_metadata.get("candidates_token_count", 0)+ self._reasoning_tokens = usage_metadata.get("thoughts_token_count") or 0+ self._cache_read_input_tokens = usage_metadata.get("cached_content_token_count", 0)+self._response_model = response_dict.get("model_version")self._timestamps = []self._ttft, self._tbt = self._end_time - self._start_time, 0@@ -354,6 +734,7 @@ def process_chat_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/langchain/__init__.py b/sdk/python/src/openlit/instrumentation/langchain/__init__.pyindex 042707de..9ce9f9ab 100644--- a/sdk/python/src/openlit/instrumentation/langchain/__init__.py+++ b/sdk/python/src/openlit/instrumentation/langchain/__init__.py@@ -40,6 +40,7 @@ class SpanHolder:"model_name","model_parameters","prompt_content",+ "input_messages",)def __init__(self, span, token=None, start_time=None):@@ -56,6 +57,7 @@ class SpanHolder:self.model_name = "unknown"self.model_parameters: Dict[str, Any] = {}self.prompt_content = ""+ self.input_messages: List[Dict[str, Any]] = []def get_duration(self) -> float:"""Calculate duration from start time to now."""@@ -174,6 +176,190 @@ def _extract_model_from_repr(return None+def build_input_messages_from_langchain(messages):+ """+ Convert LangChain messages to OTel structured input message format.++ Args:+ messages: List of LangChain message lists (typically [[msg1, msg2, ...]])++ Returns:+ List of ChatMessage objects with role and parts+ """+ try:+ structured_messages = []++ # LangChain wraps messages in nested lists+ for msg_list in messages:+ for msg in msg_list:+ # Extract role and content from LangChain message+ role = getattr(msg, "type", "user")+ content = getattr(msg, "content", str(msg))++ # Map LangChain roles to OTel roles+ role_mapping = {+ "system": "system",+ "human": "user",+ "ai": "assistant",+ "tool": "tool",+ "function": "tool",+ }+ otel_role = role_mapping.get(role, "user")++ # Build structured message with parts+ structured_msg = {+ "role": otel_role,+ "parts": [{"type": "text", "content": str(content)}],+ }+ structured_messages.append(structured_msg)++ return structured_messages+ except Exception as e:+ # Return empty list on error to prevent instrumentation breakage+ logger.debug("Error building input messages from LangChain: %s", e)+ return []+++def build_input_messages_from_prompts(prompts):+ """+ Convert LangChain prompts (strings) to OTel structured input message format.++ Args:+ prompts: List of prompt strings++ Returns:+ List of ChatMessage objects with role and parts+ """+ try:+ structured_messages = []++ for prompt_list in prompts:+ # prompts is typically a list of lists+ prompt_text = (+ prompt_list if isinstance(prompt_list, str) else str(prompt_list)+ )++ structured_msg = {+ "role": "user",+ "parts": [{"type": "text", "content": prompt_text}],+ }+ structured_messages.append(structured_msg)++ return structured_messages+ except Exception as e:+ # Return empty list on error to prevent instrumentation breakage+ logger.debug("Error building input messages from prompts: %s", e)+ return []+++def build_output_messages_langchain(completion_content, finish_reason="stop"):+ """+ Convert LangChain completion content to OTel structured output message format.++ Args:+ completion_content: The completion text content+ finish_reason: The finish reason (default: "stop")++ Returns:+ List with single OutputMessage containing response+ """+ try:+ if not completion_content:+ return []++ output_msg = {+ "role": "assistant",+ "parts": [{"type": "text", "content": str(completion_content)}],+ "finish_reason": finish_reason,+ }++ return [output_msg]+ except Exception as e:+ # Return empty list on error to prevent instrumentation breakage+ logger.debug("Error building output messages: %s", e)+ return []+++def emit_inference_event_langchain(+ event_provider,+ operation_name,+ request_model,+ response_model,+ input_messages,+ output_messages,+ server_address,+ server_port,+ **extra_attrs,+):+ """+ Emit gen_ai.client.inference.operation.details event for LangChain operations.++ Args:+ event_provider: The OTel event provider+ operation_name: The operation name (e.g., "chat")+ request_model: The request model name+ response_model: The response model name+ input_messages: Structured input messages+ output_messages: Structured output messages+ server_address: Server address+ server_port: Server port+ **extra_attrs: Additional attributes (temperature, tokens, etc.)+ """+ try:+ if not event_provider:+ return++ from openlit.__helpers import otel_event+ from openlit.semcov import SemanticConvention++ # Build event attributes per OTel spec+ attributes = {+ SemanticConvention.GEN_AI_OPERATION: operation_name,+ SemanticConvention.GEN_AI_REQUEST_MODEL: request_model,+ SemanticConvention.SERVER_ADDRESS: server_address,+ SemanticConvention.SERVER_PORT: server_port,+ }++ # Add response model if different from request+ if response_model and response_model != request_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model++ # Add input/output messages+ if input_messages:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages++ # Add optional attributes+ optional_attrs = {+ "temperature": SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,+ "max_tokens": SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,+ "top_p": SemanticConvention.GEN_AI_REQUEST_TOP_P,+ "top_k": SemanticConvention.GEN_AI_REQUEST_TOP_K,+ "frequency_penalty": SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,+ "presence_penalty": SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,+ "input_tokens": SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,+ "output_tokens": SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,+ "finish_reasons": SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,+ }++ for key, attr_name in optional_attrs.items():+ if key in extra_attrs and extra_attrs[key] is not None:+ attributes[attr_name] = extra_attrs[key]++ # 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 extract_model_name(serialized: Optional[Dict[str, Any]],kwargs: Optional[Dict[str, Any]] = None,@@ -339,6 +525,7 @@ def _create_callback_handler_class(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Create and return an OpenLITCallbackHandler class configured with the given parameters.@@ -376,6 +563,7 @@ def _create_callback_handler_class(self._capture_message_content = capture_message_contentself._metrics = metricsself._disable_metrics = disable_metrics+ self._event_provider = event_providerself.spans: Dict[UUID, SpanHolder] = {}self.run_inline = True@@ -795,6 +983,15 @@ def _create_callback_handler_class()self.spans[run_id].input_tokens = general_tokens(prompt_str)+ # Store structured prompts for event emission+ try:+ structured_prompts = build_input_messages_from_prompts(prompts)+ self.spans[run_id].input_messages = structured_prompts+ except Exception as prompt_err:+ logger.debug(+ "Error building structured prompts: %s", prompt_err+ )+except Exception as e:logger.debug("Error in on_llm_start: %s", e)@@ -851,6 +1048,13 @@ def _create_callback_handler_class(SemanticConvention.GEN_AI_CONTENT_PROMPT, prompt_str)+ # Store structured messages for event emission+ try:+ structured_msgs = build_input_messages_from_langchain(messages)+ self.spans[run_id].input_messages = structured_msgs+ except Exception as msg_err:+ logger.debug("Error building structured messages: %s", msg_err)+except Exception as e:logger.debug("Error in on_chat_model_start: %s", e)@@ -1022,6 +1226,56 @@ def _create_callback_handler_class(completion_content[:5000],)+ # Emit OTel log event+ if self._event_provider and self._capture_message_content:+ try:+ # Get stored input messages+ input_msgs = (+ holder.input_messages if holder.input_messages else []+ )++ # Build output messages+ output_msgs = build_output_messages_langchain(+ completion_content+ )++ # Extract model parameters+ model_params = (+ holder.model_parameters if holder.model_parameters else {}+ )++ # Determine response model+ response_model = model_name+ if response.llm_output:+ response_model = response.llm_output.get(+ "model_name"+ ) or response.llm_output.get("model", model_name)++ emit_inference_event_langchain(+ event_provider=self._event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ request_model=model_name,+ response_model=response_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ server_address="localhost",+ server_port=8080,+ temperature=model_params.get("temperature"),+ max_tokens=model_params.get("max_tokens"),+ top_p=model_params.get("top_p"),+ top_k=model_params.get("top_k"),+ frequency_penalty=model_params.get("frequency_penalty"),+ presence_penalty=model_params.get("presence_penalty"),+ input_tokens=input_tokens,+ output_tokens=output_tokens,+ )+ except Exception as event_err:+ logger.warning(+ "Failed to emit inference event: %s",+ event_err,+ exc_info=True,+ )+# Always set token attributesspan.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens@@ -1040,12 +1294,15 @@ def _create_callback_handler_class()span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)- # Set response model- response_model = model_name+ # Set response model (if not already set in event emission above)+ if "response_model" not in locals():+ response_model = model_name+ if response.llm_output:+ response_model = response.llm_output.get(+ "model_name"+ ) or response.llm_output.get("model", model_name)+if response.llm_output:- response_model = response.llm_output.get(- "model_name"- ) or response.llm_output.get("model", model_name)span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, response_model)@@ -1460,6 +1717,7 @@ class LangChainInstrumentor(BaseInstrumentor):capture_message_content = kwargs.get("capture_message_content", False)metrics = kwargs.get("metrics_dict")disable_metrics = kwargs.get("disable_metrics", False)+ event_provider = kwargs.get("event_provider")handler_class = _create_callback_handler_class(tracer,@@ -1470,6 +1728,7 @@ class LangChainInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)if handler_class is None:diff --git a/sdk/python/src/openlit/instrumentation/litellm/__init__.py b/sdk/python/src/openlit/instrumentation/litellm/__init__.pyindex 391d1546..7ded53cf 100644--- a/sdk/python/src/openlit/instrumentation/litellm/__init__.py+++ b/sdk/python/src/openlit/instrumentation/litellm/__init__.py@@ -27,6 +27,7 @@ class LiteLLMInstrumentor(BaseInstrumentor):pricing_info = kwargs.get("pricing_info", {})capture_message_content = kwargs.get("capture_message_content", False)disable_metrics = kwargs.get("disable_metrics")+ event_provider = kwargs.get("event_provider")version = importlib.metadata.version("litellm")# Chat completions@@ -42,6 +43,7 @@ class LiteLLMInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -58,6 +60,7 @@ class LiteLLMInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -74,6 +77,7 @@ class LiteLLMInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)@@ -90,6 +94,7 @@ class LiteLLMInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,),)diff --git a/sdk/python/src/openlit/instrumentation/litellm/async_litellm.py b/sdk/python/src/openlit/instrumentation/litellm/async_litellm.pyindex 64cfffd2..b266cc71 100644--- a/sdk/python/src/openlit/instrumentation/litellm/async_litellm.py+++ b/sdk/python/src/openlit/instrumentation/litellm/async_litellm.py@@ -23,6 +23,7 @@ def acompletion(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -41,6 +42,7 @@ def acompletion(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -63,6 +65,7 @@ def acompletion(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -95,6 +98,7 @@ def acompletion(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)# End the span after processingself._span.end()@@ -123,7 +127,13 @@ def acompletion(awaited_wrapped = await wrapped(*args, **kwargs)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=event_provider,)else:# Handling for non-streaming responses@@ -146,6 +156,7 @@ def acompletion(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -166,6 +177,7 @@ def aembedding(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI embedding function call@@ -203,6 +215,7 @@ def aembedding(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/litellm/litellm.py b/sdk/python/src/openlit/instrumentation/litellm/litellm.pyindex 1a99383c..888b5d6d 100644--- a/sdk/python/src/openlit/instrumentation/litellm/litellm.py+++ b/sdk/python/src/openlit/instrumentation/litellm/litellm.py@@ -23,6 +23,7 @@ def completion(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI function call@@ -41,6 +42,7 @@ def completion(kwargs,server_address,server_port,+ event_provider=None,**args,):self.__wrapped__ = wrapped@@ -63,6 +65,7 @@ def completion(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -95,6 +98,7 @@ def completion(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=self._event_provider,)# End the span after processingself._span.end()@@ -123,7 +127,13 @@ def completion(awaited_wrapped = wrapped(*args, **kwargs)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=event_provider,)else:# Handling for non-streaming responses@@ -146,6 +156,7 @@ def completion(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -166,6 +177,7 @@ def embedding(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for GenAI embedding function call@@ -203,6 +215,7 @@ def embedding(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/litellm/utils.py b/sdk/python/src/openlit/instrumentation/litellm/utils.pyindex c99cd8ff..0024c231 100644--- a/sdk/python/src/openlit/instrumentation/litellm/utils.py+++ b/sdk/python/src/openlit/instrumentation/litellm/utils.py@@ -15,6 +15,7 @@ from openlit.__helpers import (common_span_attributes,record_completion_metrics,record_embedding_metrics,+ otel_event,)from openlit.semcov import SemanticConvention@@ -43,6 +44,225 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages):+ """+ Convert LiteLLM messages (OpenAI-compatible format) to OTel input message structure.++ Args:+ messages: List of message objects from LiteLLM request++ Returns:+ List of ChatMessage objects following OTel schema+ """+ 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,+ }+ )++ if parts:+ structured_messages.append({"role": role, "parts": parts})++ return structured_messages+++def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert LiteLLM response to OTel output message structure.++ Args:+ response_text: The text response+ finish_reason: LiteLLM finish reason value+ tool_calls: Tool calls from response++ Returns:+ List with single OutputMessage following OTel schema+ """+ 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 LiteLLM finish reasons to OTel standard+ finish_reason_map = {+ "stop": "stop",+ "length": "max_tokens",+ "tool_calls": "tool_calls",+ "content_filter": "content_filter",+ }++ otel_finish_reason = finish_reason_map.get(finish_reason, finish_reason)++ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish_reason}]+++def build_tool_definitions(tools):+ """+ Extract tool definitions from request.++ Args:+ tools: LiteLLM tools array (OpenAI-compatible format)++ Returns:+ List of tool definition objects or None+ """+ # LiteLLM uses OpenAI-compatible tool format+ # Direct pass-through+ return tools if tools else 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,+):+ """+ 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++ # Build base attributes+ attributes = {+ SemanticConvention.GEN_AI_OPERATION_NAME: 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,+ "cache_creation_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,+ "cache_read_input_tokens": SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_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)++def process_chunk(scope, chunk):"""Process a chunk of response data and update state.@@ -118,6 +338,7 @@ def common_chat_logic(disable_metrics,version,is_stream,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -256,19 +477,40 @@ 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 OTel log event+ if event_provider:+ try:+ input_msgs = build_input_messages(scope._kwargs.get("messages", []))+ output_msgs = build_output_messages(+ scope._llmresponse, scope._finish_reason, scope._tools+ )+ 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="api.litellm.ai",+ server_port=443,+ response_id=scope._response_id,+ finish_reasons=[scope._finish_reason],+ temperature=scope._kwargs.get("temperature"),+ max_tokens=scope._kwargs.get("max_tokens"),+ top_p=scope._kwargs.get("top_p"),+ frequency_penalty=scope._kwargs.get("frequency_penalty"),+ presence_penalty=scope._kwargs.get("presence_penalty"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -303,6 +545,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming chat request and generate Telemetry@@ -318,6 +561,7 @@ def process_streaming_chat_response(disable_metrics,version,is_stream=True,+ event_provider=event_provider,)@@ -335,6 +579,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -383,6 +628,7 @@ def process_chat_response(disable_metrics,version,is_stream=False,+ event_provider=event_provider,)return response@@ -402,6 +648,7 @@ def process_embedding_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -469,15 +716,38 @@ def process_embedding_response(str(scope._kwargs.get("input", "")),)- # 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: str(- scope._kwargs.get("input", "")- ),- },- )+ # Emit OTel log event+ if event_provider:+ try:+ # For embeddings, input is text strings, output is empty+ input_text = scope._kwargs.get("input", [])+ if isinstance(input_text, str):+ input_text = [input_text]++ # Create simple text input messages+ input_msgs = [+ {"role": "user", "parts": [{"type": "text", "content": text}]}+ for text in input_text+ ]++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ request_model=request_model,+ response_model=scope._response_model,+ input_messages=input_msgs,+ output_messages=[], # Embeddings don't have text output+ tool_definitions=None,+ server_address="api.litellm.ai",+ server_port=443,+ response_id=None,+ input_tokens=scope._input_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))diff --git a/sdk/python/src/openlit/instrumentation/ollama/__init__.py b/sdk/python/src/openlit/instrumentation/ollama/__init__.pyindex 442ef4ee..d50ad1b8 100644--- a/sdk/python/src/openlit/instrumentation/ollama/__init__.py+++ b/sdk/python/src/openlit/instrumentation/ollama/__init__.py@@ -64,6 +64,7 @@ class OllamaInstrumentor(BaseInstrumentor):pricing_info = kwargs.get("pricing_info", {})capture_message_content = kwargs.get("capture_message_content", False)disable_metrics = kwargs.get("disable_metrics")+ event_provider = kwargs.get("event_provider")version = importlib.metadata.version("ollama")# Build wrapper factories for chat and embeddings@@ -76,6 +77,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)sync_generate_wrap = generate(version,@@ -86,6 +88,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)sync_emb_wrap = embeddings(version,@@ -96,6 +99,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)async_chat_wrap = async_chat(version,@@ -106,6 +110,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)async_generate_wrap = async_generate(version,@@ -116,6 +121,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)async_emb_wrap = async_embeddings(version,@@ -126,6 +132,7 @@ class OllamaInstrumentor(BaseInstrumentor):capture_message_content,metrics,disable_metrics,+ event_provider,)# Patch underlying request methods to ensure instrumentation regardless of import orderdiff --git a/sdk/python/src/openlit/instrumentation/ollama/async_ollama.py b/sdk/python/src/openlit/instrumentation/ollama/async_ollama.pyindex 250b4b08..cf3837e4 100644--- a/sdk/python/src/openlit/instrumentation/ollama/async_ollama.py+++ b/sdk/python/src/openlit/instrumentation/ollama/async_ollama.py@@ -25,6 +25,7 @@ def async_chat(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama async chat function call@@ -44,6 +45,7 @@ def async_chat(server_address,server_port,args,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -64,6 +66,7 @@ def async_chat(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -98,6 +101,7 @@ def async_chat(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)@@ -130,6 +134,7 @@ def async_chat(server_address,server_port,args,+ event_provider,)else:@@ -153,6 +158,7 @@ def async_chat(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -173,6 +179,7 @@ def async_generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama async generate function call@@ -192,6 +199,7 @@ def async_generate(server_address,server_port,args,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -212,6 +220,7 @@ def async_generate(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerasync def __aenter__(self):await self.__wrapped__.__aenter__()@@ -246,6 +255,7 @@ def async_generate(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)@@ -278,6 +288,7 @@ def async_generate(server_address,server_port,args,+ event_provider,)else:@@ -301,6 +312,7 @@ def async_generate(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -321,6 +333,7 @@ def async_embeddings(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama async embeddings function call@@ -360,6 +373,7 @@ def async_embeddings(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/ollama/ollama.py b/sdk/python/src/openlit/instrumentation/ollama/ollama.pyindex d0d9387e..8ae613c7 100644--- a/sdk/python/src/openlit/instrumentation/ollama/ollama.py+++ b/sdk/python/src/openlit/instrumentation/ollama/ollama.py@@ -25,6 +25,7 @@ def chat(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama chat function call@@ -44,6 +45,7 @@ def chat(server_address,server_port,args,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -64,6 +66,7 @@ def chat(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -98,6 +101,7 @@ def chat(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)@@ -130,6 +134,7 @@ def chat(server_address,server_port,args,+ event_provider,)else:@@ -153,6 +158,7 @@ def chat(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -173,6 +179,7 @@ def generate(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama generate function call@@ -192,6 +199,7 @@ def generate(server_address,server_port,args,+ event_provider=None,):self.__wrapped__ = wrappedself._span = span@@ -212,6 +220,7 @@ def generate(self._tbt = 0self._server_address = server_addressself._server_port = server_port+ self._event_provider = event_providerdef __enter__(self):self.__wrapped__.__enter__()@@ -246,6 +255,7 @@ def generate(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)@@ -278,6 +288,7 @@ def generate(server_address,server_port,args,+ event_provider,)else:@@ -301,6 +312,7 @@ def generate(capture_message_content=capture_message_content,disable_metrics=disable_metrics,version=version,+ event_provider=event_provider,**kwargs,)@@ -321,6 +333,7 @@ def embeddings(capture_message_content,metrics,disable_metrics,+ event_provider=None,):"""Generates a telemetry wrapper for Ollama embeddings function call@@ -360,6 +373,7 @@ def embeddings(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/ollama/utils.py b/sdk/python/src/openlit/instrumentation/ollama/utils.pyindex 89fb9bdb..183e220c 100644--- a/sdk/python/src/openlit/instrumentation/ollama/utils.py+++ b/sdk/python/src/openlit/instrumentation/ollama/utils.py@@ -16,6 +16,7 @@ from openlit.__helpers import (create_metrics_attributes,common_span_attributes,record_completion_metrics,+ otel_event,)from openlit.semcov import SemanticConvention@@ -44,6 +45,165 @@ def format_content(messages):return "\n".join(formatted_messages)+def build_input_messages(messages):+ """+ Convert Ollama messages to OTel input message structure.+ Ollama uses OpenAI-compatible message format.+ """+ structured_messages = []+ for msg in messages:+ role = msg.get("role", "user")+ parts = []+ content = msg.get("content", "")++ if isinstance(content, str):+ parts.append({"type": "text", "content": content})+ elif isinstance(content, list):+ 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", "")+ if not image_url.startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": image_url}+ )++ # Handle tool calls+ 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+ if role == "tool" and "tool_call_id" in msg:+ parts.append(+ {+ "type": "tool_call_response",+ "id": msg.get("tool_call_id", ""),+ "response": content,+ }+ )++ if parts:+ structured_messages.append({"role": role, "parts": parts})++ return structured_messages+++def build_output_messages(response_text, finish_reason, tool_calls=None):+ """+ Convert Ollama response to OTel output message structure.+ Maps Ollama finish reasons to OTel standard.+ """+ parts = []+ if response_text:+ parts.append({"type": "text", "content": response_text})++ 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", {}),+ }+ )++ # Ollama uses done_reason field - map to OTel standard+ finish_reason_map = {+ "stop": "stop",+ "length": "max_tokens",+ "tool_calls": "tool_calls",+ "content_filter": "content_filter",+ }++ otel_finish_reason = finish_reason_map.get(finish_reason, finish_reason)+ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish_reason}]+++def build_tool_definitions(tools):+ """+ Extract tool definitions from Ollama request.+ Returns tool definitions or None if not present.+ """+ return tools if tools else 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,+):+ """+ Centralized function to emit gen_ai.client.inference.operation.details event.+ Uses Ollama-specific defaults (localhost:11434).+ """+ try:+ if not event_provider:+ return++ attributes = {SemanticConvention.GEN_AI_OPERATION_NAME: operation_name}++ if request_model:+ attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = request_model+ if response_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model+ if server_address:+ attributes["server.address"] = server_address+ if server_port:+ attributes["server.port"] = server_port+ if input_messages:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages+ if tool_definitions:+ attributes[SemanticConvention.GEN_AI_TOOL_DEFINITIONS] = tool_definitions++ # Map extra attributes to semantic conventions+ attr_mapping = {+ "response_id": SemanticConvention.GEN_AI_RESPONSE_ID,+ "finish_reasons": SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,+ "temperature": SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,+ "max_tokens": SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,+ "top_p": SemanticConvention.GEN_AI_REQUEST_TOP_P,+ "top_k": SemanticConvention.GEN_AI_REQUEST_TOP_K,+ "repeat_penalty": SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,+ "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++ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="",+ )+ 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)++def process_chunk(self, chunk):"""Process a chunk of response data and update state.@@ -117,6 +277,7 @@ def common_chat_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Process chat request and generate Telemetry@@ -224,19 +385,47 @@ 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 OTel log event+ if event_provider:+ try:+ json_body = scope._kwargs.get("json", {}) or {}+ input_msgs = build_input_messages(+ json_body.get("messages", scope._kwargs.get("messages", []))+ )+ output_msgs = build_output_messages(+ scope._llmresponse, scope._finish_reason, scope._tools+ )+ tool_defs = build_tool_definitions(+ json_body.get("tools", scope._kwargs.get("tools"))+ )++ # Extract options for parameters+ options = json_body.get("options", scope._kwargs.get("options", {}))++ 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,+ finish_reasons=[scope._finish_reason],+ temperature=options.get("temperature"),+ max_tokens=options.get("max_tokens"),+ top_p=options.get("top_p"),+ top_k=options.get("top_k"),+ repeat_penalty=options.get("repeat_penalty"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -272,6 +461,7 @@ def common_generate_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Process generate request and generate Telemetry@@ -378,19 +568,49 @@ def common_generate_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 OTel log event+ if event_provider:+ try:+ json_body = scope._kwargs.get("json", {}) or {}++ # For generate operation, input is a prompt string, not messages+ input_msgs = [+ {"role": "user", "parts": [{"type": "text", "content": prompt}]}+ ]+ output_msgs = build_output_messages(+ scope._llmresponse, scope._finish_reason, scope._tools+ )+ tool_defs = build_tool_definitions(+ json_body.get("tools", scope._kwargs.get("tools"))+ )++ # Extract options for parameters+ options = json_body.get("options", scope._kwargs.get("options", {}))++ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION,+ 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,+ finish_reasons=[scope._finish_reason],+ temperature=options.get("temperature"),+ max_tokens=options.get("max_tokens"),+ top_p=options.get("top_p"),+ top_k=options.get("top_k"),+ repeat_penalty=options.get("repeat_penalty"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)scope._span.set_status(Status(StatusCode.OK))@@ -426,6 +646,7 @@ def common_embedding_logic(capture_message_content,disable_metrics,version,+ event_provider=None,):"""Process embedding request and generate Telemetry@@ -471,6 +692,41 @@ def common_embedding_logic(if capture_message_content:scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, prompt_val)+ # Emit OTel log event+ if event_provider:+ try:+ # For embeddings, input is text strings, output is empty+ if isinstance(prompt_val, str):+ input_text = [prompt_val]+ elif isinstance(prompt_val, list):+ input_text = prompt_val+ else:+ input_text = [str(prompt_val)]++ # Create simple text input messages+ input_msgs = [+ {"role": "user", "parts": [{"type": "text", "content": text}]}+ for text in input_text+ ]++ 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=[], # Embeddings don't have text output+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ input_tokens=input_tokens,+ )+ except Exception as e:+ import logging++ logger = logging.getLogger(__name__)+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)+scope._span.set_status(Status(StatusCode.OK))# Metrics@@ -501,6 +757,7 @@ def process_streaming_chat_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming chat request and generate Telemetry@@ -516,6 +773,7 @@ def process_streaming_chat_response(capture_message_content,disable_metrics,version,+ event_provider,)@@ -533,6 +791,7 @@ def process_chat_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -572,6 +831,7 @@ def process_chat_response(capture_message_content,disable_metrics,version,+ event_provider,)return response@@ -586,6 +846,7 @@ def process_streaming_generate_response(capture_message_content=False,disable_metrics=False,version="",+ event_provider=None,):"""Process streaming generate request and generate Telemetry@@ -601,6 +862,7 @@ def process_streaming_generate_response(capture_message_content,disable_metrics,version,+ event_provider,)@@ -618,6 +880,7 @@ def process_generate_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -657,6 +920,7 @@ def process_generate_response(capture_message_content,disable_metrics,version,+ event_provider,)return response@@ -676,6 +940,7 @@ def process_embedding_response(capture_message_content=False,disable_metrics=False,version="1.0.0",+ event_provider=None,**kwargs,):"""@@ -705,6 +970,7 @@ def process_embedding_response(capture_message_content,disable_metrics,version,+ event_provider,)return responsediff --git a/sdk/python/src/openlit/instrumentation/openai/utils.py b/sdk/python/src/openlit/instrumentation/openai/utils.pyindex ab0fdee6..7e4f51d6 100644--- a/sdk/python/src/openlit/instrumentation/openai/utils.py+++ b/sdk/python/src/openlit/instrumentation/openai/utils.py@@ -482,15 +482,21 @@ def emit_inference_event(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+ attributes[SemanticConvention.GEN_AI_REQUEST_CHOICE_COUNT] = (+ value+ )elif key == "input_tokens":attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] = valueelif key == "output_tokens":attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] = valueelif key == "cache_creation_input_tokens":- attributes["gen_ai.usage.cache_creation.input_tokens"] = value+ attributes[+ SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS+ ] = valueelif key == "cache_read_input_tokens":- attributes["gen_ai.usage.cache_read.input_tokens"] = value+ attributes[+ SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS+ ] = valueelse:# Pass through any other attributes as-isattributes[key] = value@@ -1218,6 +1224,10 @@ def common_chat_logic(choice_count=scope._kwargs.get("n", 1),input_tokens=input_tokens,output_tokens=output_tokens,+ cache_read_input_tokens=scope._cache_read_input_tokens+ if hasattr(scope, "_cache_read_input_tokens")+ and scope._cache_read_input_tokens > 0+ else None,)except Exception as e:logger.warning("Failed to emit inference event: %s", e, exc_info=True)@@ -1310,6 +1320,13 @@ def process_chat_response(scope._response_model = response_dict.get("model", "")scope._input_tokens = response_dict.get("usage", {}).get("prompt_tokens", 0)scope._output_tokens = response_dict.get("usage", {}).get("completion_tokens", 0)++ # Extract cache tokens (OpenAI prompt caching)+ prompt_tokens_details = response_dict.get("usage", {}).get(+ "prompt_tokens_details", {}+ )+ scope._cache_read_input_tokens = prompt_tokens_details.get("cached_tokens", 0)+scope._timestamps = []scope._ttft, scope._tbt = scope._end_time - scope._start_time, 0scope._server_address, scope._server_port = server_address, server_portdiff --git a/sdk/python/src/openlit/semcov/__init__.py b/sdk/python/src/openlit/semcov/__init__.pyindex 079a3917..d4ac5e37 100644--- a/sdk/python/src/openlit/semcov/__init__.py+++ b/sdk/python/src/openlit/semcov/__init__.py@@ -56,6 +56,7 @@ class SemanticConvention:GEN_AI_ENDPOINT = "gen_ai.endpoint"GEN_AI_REQUEST_MODEL = "gen_ai.request.model"GEN_AI_REQUEST_SEED = "gen_ai.request.seed"+ GEN_AI_REQUEST_CHOICE_COUNT = "gen_ai.request.choice.count"GEN_AI_REQUEST_ENCODING_FORMATS = "gen_ai.request.encoding_formats"GEN_AI_REQUEST_FREQUENCY_PENALTY = "gen_ai.request.frequency_penalty"GEN_AI_REQUEST_MAX_TOKENS = "gen_ai.request.max_tokens"@@ -65,6 +66,9 @@ class SemanticConvention:GEN_AI_REQUEST_TOP_K = "gen_ai.request.top_k"GEN_AI_REQUEST_TOP_P = "gen_ai.request.top_p"+ # GenAI Conversation Attributes (OTel Semconv)+ GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id"+# GenAI Response Attributes (OTel Semconv)GEN_AI_TOKEN_TYPE = "gen_ai.token.type"GEN_AI_RESPONSE_FINISH_REASON = "gen_ai.response.finish_reasons"@@ -74,6 +78,10 @@ class SemanticConvention:GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens"GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens"GEN_AI_USAGE_REASONING_TOKENS = "gen_ai.usage.reasoning_tokens"+ GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS = (+ "gen_ai.usage.cache_creation.input_tokens"+ )+ GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read.input_tokens"GEN_AI_USAGE_READ_UNITS = "gen_ai.usage.read_units"GEN_AI_USAGE_RERANK_UNITS = "gen_ai.usage.rerank_units"GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id"