linting fix

Author: shuningc

util/opentelemetry-util-genai/src/opentelemetry/util/genai/handler.py

@@ -85,6 +85,7 @@
     _apply_llm_finish_attributes,
     _get_embedding_span_name,
     _get_llm_span_name,
+    _maybe_emit_embedding_event,
     _maybe_emit_llm_event,
 )
 from opentelemetry.util.genai.types import (
@@ -129,9 +130,9 @@ def __init__(
             schema_url=schema_url,
         )
 
-    def _record_llm_metrics(
+    def _record_metrics(
         self,
-        invocation: LLMInvocation,
+        invocation: GenAIInvocation,
         span: Span | None = None,
         *,
         error_type: str | None = None,
@@ -144,18 +145,6 @@ def _record_llm_metrics(
             error_type=error_type,
         )
 
-    @staticmethod
-    def _record_embedding_metrics(
-        invocation: EmbeddingInvocation,
-        span: Span | None = None,
-        *,
-        error_type: str | None = None,
-    ) -> None:
-        # Metrics recorder currently supports LLMInvocation fields only.
-        # Keep embedding metrics as a no-op until dedicated embedding
-        # metric support is added.
-        return
-
     def _start(self, invocation: _T) -> _T:
         """Start a GenAI invocation and create a pending span entry."""
         if isinstance(invocation, LLMInvocation):
@@ -187,11 +176,12 @@ def _stop(self, invocation: _T) -> _T:
         try:
             if isinstance(invocation, LLMInvocation):
                 _apply_llm_finish_attributes(span, invocation)
-                self._record_llm_metrics(invocation, span)
+                self._record_metrics(invocation, span)
                 _maybe_emit_llm_event(self._logger, span, invocation)
             elif isinstance(invocation, EmbeddingInvocation):
                 _apply_embedding_finish_attributes(span, invocation)
-                self._record_embedding_metrics(invocation, span)
+                self._record_metrics(invocation, span)
+                _maybe_emit_embedding_event(self._logger, span, invocation)
         finally:
             # Detach context and end span even if finishing fails
             otel_context.detach(invocation.context_token)
@@ -210,17 +200,16 @@ def _fail(self, invocation: _T, error: Error) -> _T:
             if isinstance(invocation, LLMInvocation):
                 _apply_llm_finish_attributes(span, invocation)
                 _apply_error_attributes(span, error, error_type)
-                self._record_llm_metrics(
-                    invocation, span, error_type=error_type
-                )
+                self._record_metrics(invocation, span, error_type=error_type)
                 _maybe_emit_llm_event(
                     self._logger, span, invocation, error_type
                 )
             elif isinstance(invocation, EmbeddingInvocation):
                 _apply_embedding_finish_attributes(span, invocation)
                 _apply_error_attributes(span, error, error_type)
-                self._record_embedding_metrics(
-                    invocation, span, error_type=error_type
+                self._record_metrics(invocation, span, error_type=error_type)
+                _maybe_emit_embedding_event(
+                    self._logger, span, invocation, error_type
                 )
         finally:
             # Detach context and end span even if finishing fails

util/opentelemetry-util-genai/src/opentelemetry/util/genai/metrics.py

@@ -1,4 +1,4 @@
-"""Helpers for emitting GenAI metrics from LLM invocations."""
+"""Helpers for emitting GenAI metrics from invocations."""
 
 from __future__ import annotations
 
@@ -18,7 +18,7 @@
     create_duration_histogram,
     create_token_histogram,
 )
-from opentelemetry.util.genai.types import LLMInvocation
+from opentelemetry.util.genai.types import GenAIInvocation, LLMInvocation
 from opentelemetry.util.types import AttributeValue
 
 
@@ -29,57 +29,69 @@ def __init__(self, meter: Meter):
         self._duration_histogram: Histogram = create_duration_histogram(meter)
         self._token_histogram: Histogram = create_token_histogram(meter)
 
+    @staticmethod
+    def _build_attributes(
+        invocation: GenAIInvocation,
+        error_type: Optional[str] = None,
+    ) -> Dict[str, AttributeValue]:
+        """Build metric attributes from an invocation."""
+        attributes: Dict[str, AttributeValue] = {}
+
+        # Set attributes using getattr for fields that may not exist on base class
+        operation_name = getattr(invocation, "operation_name", None)
+        if operation_name:
+            attributes[GenAI.GEN_AI_OPERATION_NAME] = operation_name
+
+        request_model = getattr(invocation, "request_model", None)
+        if request_model:
+            attributes[GenAI.GEN_AI_REQUEST_MODEL] = request_model
+
+        provider = getattr(invocation, "provider", None)
+        if provider:
+            attributes[GenAI.GEN_AI_PROVIDER_NAME] = provider
+
+        response_model_name = getattr(invocation, "response_model_name", None)
+        if response_model_name:
+            attributes[GenAI.GEN_AI_RESPONSE_MODEL] = response_model_name
+
+        server_address = getattr(invocation, "server_address", None)
+        if server_address:
+            attributes[server_attributes.SERVER_ADDRESS] = server_address
+
+        server_port = getattr(invocation, "server_port", None)
+        if server_port is not None:
+            attributes[server_attributes.SERVER_PORT] = server_port
+
+        metric_attributes = getattr(invocation, "metric_attributes", None)
+        if metric_attributes:
+            attributes.update(metric_attributes)
+
+        if error_type:
+            attributes[error_attributes.ERROR_TYPE] = error_type
+
+        return attributes
+
     def record(
         self,
         span: Optional[Span],
-        invocation: LLMInvocation,
+        invocation: GenAIInvocation,
         *,
         error_type: Optional[str] = None,
     ) -> None:
-        """Record duration and token metrics for an invocation if possible."""
+        """Record duration and token metrics for an invocation if possible.
+
+        For LLMInvocation: records duration and token (input/output) metrics.
+        For EmbeddingInvocation: records duration only.
+        """
 
         # pylint: disable=too-many-branches
 
         if span is None:
             return
 
-        token_counts: list[tuple[int, str]] = []
-        if invocation.input_tokens is not None:
-            token_counts.append(
-                (
-                    invocation.input_tokens,
-                    GenAI.GenAiTokenTypeValues.INPUT.value,
-                )
-            )
-        if invocation.output_tokens is not None:
-            token_counts.append(
-                (
-                    invocation.output_tokens,
-                    GenAI.GenAiTokenTypeValues.OUTPUT.value,
-                )
-            )
+        attributes = self._build_attributes(invocation, error_type)
 
-        attributes: Dict[str, AttributeValue] = {
-            GenAI.GEN_AI_OPERATION_NAME: GenAI.GenAiOperationNameValues.CHAT.value
-        }
-        if invocation.request_model:
-            attributes[GenAI.GEN_AI_REQUEST_MODEL] = invocation.request_model
-        if invocation.provider:
-            attributes[GenAI.GEN_AI_PROVIDER_NAME] = invocation.provider
-        if invocation.response_model_name:
-            attributes[GenAI.GEN_AI_RESPONSE_MODEL] = (
-                invocation.response_model_name
-            )
-        if invocation.server_address:
-            attributes[server_attributes.SERVER_ADDRESS] = (
-                invocation.server_address
-            )
-        if invocation.server_port is not None:
-            attributes[server_attributes.SERVER_PORT] = invocation.server_port
-        if invocation.metric_attributes:
-            attributes.update(invocation.metric_attributes)
-
-        # Calculate duration from span timing or invocation monotonic start
+        # Calculate duration from invocation monotonic start
         duration_seconds: Optional[float] = None
         if invocation.monotonic_start_s is not None:
             duration_seconds = max(
@@ -88,8 +100,6 @@ def record(
             )
 
         span_context = set_span_in_context(span)
-        if error_type:
-            attributes[error_attributes.ERROR_TYPE] = error_type
 
         if duration_seconds is not None:
             self._duration_histogram.record(
@@ -98,12 +108,31 @@ def record(
                 context=span_context,
             )
 
-        for token_count, token_type in token_counts:
-            self._token_histogram.record(
-                token_count,
-                attributes=attributes | {GenAI.GEN_AI_TOKEN_TYPE: token_type},
-                context=span_context,
-            )
+        # Only record token metrics for LLMInvocation
+        if isinstance(invocation, LLMInvocation):
+            token_counts: list[tuple[int, str]] = []
+            if invocation.input_tokens is not None:
+                token_counts.append(
+                    (
+                        invocation.input_tokens,
+                        GenAI.GenAiTokenTypeValues.INPUT.value,
+                    )
+                )
+            if invocation.output_tokens is not None:
+                token_counts.append(
+                    (
+                        invocation.output_tokens,
+                        GenAI.GenAiTokenTypeValues.OUTPUT.value,
+                    )
+                )
+
+            for token_count, token_type in token_counts:
+                self._token_histogram.record(
+                    token_count,
+                    attributes=attributes
+                    | {GenAI.GEN_AI_TOKEN_TYPE: token_type},
+                    context=span_context,
+                )
 
 
 __all__ = ["InvocationMetricsRecorder"]

util/opentelemetry-util-genai/src/opentelemetry/util/genai/span_utils.py

@@ -227,6 +227,44 @@ def _maybe_emit_llm_event(
     logger.emit(event)
 
 
+def _maybe_emit_embedding_event(
+    logger: Logger | None,
+    span: Span,
+    invocation: EmbeddingInvocation,
+    error_type: str | None = None,
+) -> None:
+    """Emit a gen_ai.client.inference.operation.details event to the logger.
+
+    This function creates a LogRecord event following the semantic convention
+    for gen_ai.client.inference.operation.details as specified in the GenAI
+    event semantic conventions.
+
+    For more details, see the semantic convention documentation:
+    https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md#event-eventgen_aiclientinferenceoperationdetails
+    """
+    if not is_experimental_mode() or not should_emit_event() or logger is None:
+        return
+
+    # Build event attributes by reusing the attribute getter functions
+    attributes: dict[str, Any] = {}
+    attributes.update(_get_embedding_common_attributes(invocation))
+    attributes.update(_get_embedding_request_attributes(invocation))
+    attributes.update(_get_embedding_response_attributes(invocation))
+
+    # Add error.type if operation ended in error
+    if error_type is not None:
+        attributes[error_attributes.ERROR_TYPE] = error_type
+
+    # Create and emit the event
+    context = set_span_in_context(span, get_current())
+    event = LogRecord(
+        event_name="gen_ai.client.embedding.operation.details",
+        attributes=attributes,
+        context=context,
+    )
+    logger.emit(event)
+
+
 def _apply_llm_finish_attributes(
     span: Span, invocation: LLMInvocation
 ) -> None:
@@ -365,6 +403,7 @@ def _get_embedding_response_attributes(
     "_get_llm_response_attributes",
     "_get_llm_span_name",
     "_maybe_emit_llm_event",
+    "_maybe_emit_embedding_event",
     "_apply_embedding_finish_attributes",
     "_get_embedding_common_attributes",
     "_get_embedding_request_attributes",