opentelemetry-instrumentation-vertexai 2.0b0__py3-none-any.whl → 2.1b0__py3-none-any.whl

opentelemetry/instrumentation/vertexai/__init__.py

@@ -39,58 +39,135 @@ API
 ---
 """
 
+from __future__ import annotations
+
 from typing import Any, Collection
 
 from wrapt import (
     wrap_function_wrapper,  # type: ignore[reportUnknownVariableType]
 )
 
-from opentelemetry._events import get_event_logger
+from opentelemetry._logs import get_logger
+from opentelemetry.instrumentation._semconv import (
+    _OpenTelemetrySemanticConventionStability,
+    _OpenTelemetryStabilitySignalType,
+    _StabilityMode,
+)
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
 from opentelemetry.instrumentation.vertexai.package import _instruments
-from opentelemetry.instrumentation.vertexai.patch import (
-    generate_content_create,
-)
+from opentelemetry.instrumentation.vertexai.patch import MethodWrappers
 from opentelemetry.instrumentation.vertexai.utils import is_content_enabled
 from opentelemetry.semconv.schemas import Schemas
 from opentelemetry.trace import get_tracer
+from opentelemetry.util.genai.completion_hook import load_completion_hook
+
+
+def _methods_to_wrap(
+    method_wrappers: MethodWrappers,
+):
+    # This import is very slow, do it lazily in case instrument() is not called
+    # pylint: disable=import-outside-toplevel
+    from google.cloud.aiplatform_v1.services.prediction_service import (
+        async_client,
+        client,
+    )
+    from google.cloud.aiplatform_v1beta1.services.prediction_service import (
+        async_client as async_client_v1beta1,
+    )
+    from google.cloud.aiplatform_v1beta1.services.prediction_service import (
+        client as client_v1beta1,
+    )
+
+    for client_class in (
+        client.PredictionServiceClient,
+        client_v1beta1.PredictionServiceClient,
+    ):
+        yield (
+            client_class,
+            client_class.generate_content.__name__,  # type: ignore[reportUnknownMemberType]
+            method_wrappers.generate_content,
+        )
+
+    for client_class in (
+        async_client.PredictionServiceAsyncClient,
+        async_client_v1beta1.PredictionServiceAsyncClient,
+    ):
+        yield (
+            client_class,
+            client_class.generate_content.__name__,  # type: ignore[reportUnknownMemberType]
+            method_wrappers.agenerate_content,
+        )
 
 
 class VertexAIInstrumentor(BaseInstrumentor):
+    def __init__(self) -> None:
+        super().__init__()
+        self._methods_to_unwrap: list[tuple[Any, str]] = []
+
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs: Any):
         """Enable VertexAI instrumentation."""
+        completion_hook = (
+            kwargs.get("completion_hook") or load_completion_hook()
+        )
+        sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.GEN_AI,
+        )
         tracer_provider = kwargs.get("tracer_provider")
+        schema = (
+            Schemas.V1_28_0.value
+            if sem_conv_opt_in_mode == _StabilityMode.DEFAULT
+            else Schemas.V1_36_0.value
+        )
         tracer = get_tracer(
             __name__,
             "",
             tracer_provider,
-            schema_url=Schemas.V1_28_0.value,
+            schema_url=schema,
         )
-        event_logger_provider = kwargs.get("event_logger_provider")
-        event_logger = get_event_logger(
+        logger_provider = kwargs.get("logger_provider")
+        logger = get_logger(
             __name__,
             "",
-            schema_url=Schemas.V1_28_0.value,
-            event_logger_provider=event_logger_provider,
-        )
-
-        wrap_function_wrapper(
-            module="google.cloud.aiplatform_v1beta1.services.prediction_service.client",
-            name="PredictionServiceClient.generate_content",
-            wrapper=generate_content_create(
-                tracer, event_logger, is_content_enabled()
-            ),
+            logger_provider=logger_provider,
+            schema_url=schema,
         )
-        wrap_function_wrapper(
-            module="google.cloud.aiplatform_v1.services.prediction_service.client",
-            name="PredictionServiceClient.generate_content",
-            wrapper=generate_content_create(
-                tracer, event_logger, is_content_enabled()
-            ),
+        sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.GEN_AI,
         )
+        if sem_conv_opt_in_mode == _StabilityMode.DEFAULT:
+            # Type checker now knows sem_conv_opt_in_mode is a Literal[_StabilityMode.DEFAULT]
+            method_wrappers = MethodWrappers(
+                tracer,
+                logger,
+                is_content_enabled(sem_conv_opt_in_mode),
+                sem_conv_opt_in_mode,
+                completion_hook,
+            )
+        elif sem_conv_opt_in_mode == _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL:
+            # Type checker now knows it's the other literal
+            method_wrappers = MethodWrappers(
+                tracer,
+                logger,
+                is_content_enabled(sem_conv_opt_in_mode),
+                sem_conv_opt_in_mode,
+                completion_hook,
+            )
+        else:
+            raise RuntimeError(f"{sem_conv_opt_in_mode} mode not supported")
+        for client_class, method_name, wrapper in _methods_to_wrap(
+            method_wrappers
+        ):
+            wrap_function_wrapper(
+                client_class,
+                name=method_name,
+                wrapper=wrapper,
+            )
+            self._methods_to_unwrap.append((client_class, method_name))
 
     def _uninstrument(self, **kwargs: Any) -> None:
-        """TODO: implemented in later PR"""
+        for client_class, method_name in self._methods_to_unwrap:
+            unwrap(client_class, method_name)

opentelemetry/instrumentation/vertexai/events.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# type: ignore[reportUnknownDeprecated]
+
 """
 Factories for event types described in
 https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-events.md#system-event.
@@ -25,7 +27,7 @@ from __future__ import annotations
 from dataclasses import asdict, dataclass
 from typing import Any, Iterable, Literal
 
-from opentelemetry._events import Event
+from opentelemetry._logs import LogRecord
 from opentelemetry.semconv._incubating.attributes import gen_ai_attributes
 from opentelemetry.util.types import AnyValue
 
@@ -34,7 +36,7 @@ def user_event(
     *,
     role: str = "user",
     content: AnyValue = None,
-) -> Event:
+) -> LogRecord:
     """Creates a User event
     https://github.com/open-telemetry/semantic-conventions/blob/v1.28.0/docs/gen-ai/gen-ai-events.md#user-event
     """
@@ -43,8 +45,8 @@ def user_event(
     }
     if content is not None:
         body["content"] = content
-    return Event(
-        name="gen_ai.user.message",
+    return LogRecord(
+        event_name="gen_ai.user.message",
         attributes={
             gen_ai_attributes.GEN_AI_SYSTEM: gen_ai_attributes.GenAiSystemValues.VERTEX_AI.value,
         },
@@ -56,7 +58,7 @@ def assistant_event(
     *,
     role: str = "assistant",
     content: AnyValue = None,
-) -> Event:
+) -> LogRecord:
     """Creates an Assistant event
     https://github.com/open-telemetry/semantic-conventions/blob/v1.28.0/docs/gen-ai/gen-ai-events.md#assistant-event
     """
@@ -65,8 +67,8 @@ def assistant_event(
     }
     if content is not None:
         body["content"] = content
-    return Event(
-        name="gen_ai.assistant.message",
+    return LogRecord(
+        event_name="gen_ai.assistant.message",
         attributes={
             gen_ai_attributes.GEN_AI_SYSTEM: gen_ai_attributes.GenAiSystemValues.VERTEX_AI.value,
         },
@@ -78,7 +80,7 @@ def system_event(
     *,
     role: str = "system",
     content: AnyValue = None,
-) -> Event:
+) -> LogRecord:
     """Creates a System event
     https://github.com/open-telemetry/semantic-conventions/blob/v1.28.0/docs/gen-ai/gen-ai-events.md#system-event
     """
@@ -87,8 +89,8 @@ def system_event(
     }
     if content is not None:
         body["content"] = content
-    return Event(
-        name="gen_ai.system.message",
+    return LogRecord(
+        event_name="gen_ai.system.message",
         attributes={
             gen_ai_attributes.GEN_AI_SYSTEM: gen_ai_attributes.GenAiSystemValues.VERTEX_AI.value,
         },
@@ -101,7 +103,7 @@ def tool_event(
     role: str | None,
     id_: str,
     content: AnyValue = None,
-) -> Event:
+) -> LogRecord:
     """Creates a Tool message event
     https://github.com/open-telemetry/semantic-conventions/blob/v1.28.0/docs/gen-ai/gen-ai-events.md#event-gen_aitoolmessage
     """
@@ -114,8 +116,8 @@ def tool_event(
     }
     if content is not None:
         body["content"] = content
-    return Event(
-        name="gen_ai.tool.message",
+    return LogRecord(
+        event_name="gen_ai.tool.message",
         attributes={
             gen_ai_attributes.GEN_AI_SYSTEM: gen_ai_attributes.GenAiSystemValues.VERTEX_AI.value,
         },
@@ -156,7 +158,7 @@ def choice_event(
     index: int,
     message: ChoiceMessage,
     tool_calls: Iterable[ChoiceToolCall] = (),
-) -> Event:
+) -> LogRecord:
     """Creates a choice event, which describes the Gen AI response message.
     https://github.com/open-telemetry/semantic-conventions/blob/v1.28.0/docs/gen-ai/gen-ai-events.md#event-gen_aichoice
     """
@@ -172,8 +174,8 @@ def choice_event(
     if tool_calls_list:
         body["tool_calls"] = tool_calls_list
 
-    return Event(
-        name="gen_ai.choice",
+    return LogRecord(
+        event_name="gen_ai.choice",
         attributes={
             gen_ai_attributes.GEN_AI_SYSTEM: gen_ai_attributes.GenAiSystemValues.VERTEX_AI.value,
         },

opentelemetry/instrumentation/vertexai/patch.py

@@ -14,16 +14,28 @@
 
 from __future__ import annotations
 
+from contextlib import contextmanager
+from dataclasses import asdict
 from typing import (
     TYPE_CHECKING,
     Any,
+    Awaitable,
     Callable,
+    Literal,
     MutableSequence,
+    Union,
+    cast,
+    overload,
 )
 
-from opentelemetry._events import EventLogger
+from opentelemetry._logs import Logger, LogRecord
+from opentelemetry.instrumentation._semconv import (
+    _StabilityMode,
+)
 from opentelemetry.instrumentation.vertexai.utils import (
     GenerateContentParams,
+    _map_finish_reason,
+    convert_content_to_message_parts,
     get_genai_request_attributes,
     get_genai_response_attributes,
     get_server_attributes,
@@ -31,7 +43,17 @@ from opentelemetry.instrumentation.vertexai.utils import (
     request_to_events,
     response_to_events,
 )
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAI,
+)
 from opentelemetry.trace import SpanKind, Tracer
+from opentelemetry.util.genai.completion_hook import CompletionHook
+from opentelemetry.util.genai.types import (
+    ContentCapturingMode,
+    InputMessage,
+    OutputMessage,
+)
+from opentelemetry.util.genai.utils import gen_ai_json_dumps
 
 if TYPE_CHECKING:
     from google.cloud.aiplatform_v1.services.prediction_service import client
@@ -87,17 +109,148 @@ def _extract_params(
     )
 
 
-def generate_content_create(
-    tracer: Tracer, event_logger: EventLogger, capture_content: bool
-):
-    """Wrap the `generate_content` method of the `GenerativeModel` class to trace it."""
+# For details about GEN_AI_LATEST_EXPERIMENTAL stability mode see
+# https://github.com/open-telemetry/semantic-conventions/blob/v1.37.0/docs/gen-ai/gen-ai-agent-spans.md?plain=1#L18-L37
+class MethodWrappers:
+    @overload
+    def __init__(
+        self,
+        tracer: Tracer,
+        logger: Logger,
+        capture_content: ContentCapturingMode,
+        sem_conv_opt_in_mode: Literal[
+            _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+        ],
+        completion_hook: CompletionHook,
+    ) -> None: ...
 
-    def traced_method(
-        wrapped: Callable[
-            ...,
-            prediction_service.GenerateContentResponse
-            | prediction_service_v1beta1.GenerateContentResponse,
+    @overload
+    def __init__(
+        self,
+        tracer: Tracer,
+        logger: Logger,
+        capture_content: bool,
+        sem_conv_opt_in_mode: Literal[_StabilityMode.DEFAULT],
+        completion_hook: CompletionHook,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        tracer: Tracer,
+        logger: Logger,
+        capture_content: Union[bool, ContentCapturingMode],
+        sem_conv_opt_in_mode: Union[
+            Literal[_StabilityMode.DEFAULT],
+            Literal[_StabilityMode.GEN_AI_LATEST_EXPERIMENTAL],
         ],
+        completion_hook: CompletionHook,
+    ) -> None:
+        self.tracer = tracer
+        self.logger = logger
+        self.capture_content = capture_content
+        self.sem_conv_opt_in_mode = sem_conv_opt_in_mode
+        self.completion_hook = completion_hook
+
+    @contextmanager
+    def _with_new_instrumentation(
+        self,
+        capture_content: ContentCapturingMode,
+        instance: client.PredictionServiceClient
+        | client_v1beta1.PredictionServiceClient,
+        args: Any,
+        kwargs: Any,
+    ):
+        params = _extract_params(*args, **kwargs)
+        request_attributes = get_genai_request_attributes(True, params)
+        with self.tracer.start_as_current_span(
+            name=f"{GenAI.GenAiOperationNameValues.CHAT.value} {request_attributes.get(GenAI.GEN_AI_REQUEST_MODEL, '')}".strip(),
+            kind=SpanKind.CLIENT,
+        ) as span:
+
+            def handle_response(
+                response: prediction_service.GenerateContentResponse
+                | prediction_service_v1beta1.GenerateContentResponse
+                | None,
+            ) -> None:
+                event = LogRecord(
+                    event_name="gen_ai.client.inference.operation.details",
+                )
+                attributes = (
+                    get_server_attributes(instance.api_endpoint)  # type: ignore[reportUnknownMemberType]
+                    | request_attributes
+                    | get_genai_response_attributes(response)
+                )
+                system_instructions, inputs, outputs = [], [], []
+                if params.system_instruction:
+                    system_instructions = convert_content_to_message_parts(
+                        params.system_instruction
+                    )
+                if params.contents:
+                    inputs = [
+                        InputMessage(
+                            role=content.role,
+                            parts=convert_content_to_message_parts(content),
+                        )
+                        for content in params.contents
+                    ]
+                if response:
+                    outputs = [
+                        OutputMessage(
+                            finish_reason=_map_finish_reason(
+                                candidate.finish_reason
+                            ),
+                            role=candidate.content.role,
+                            parts=convert_content_to_message_parts(
+                                candidate.content
+                            ),
+                        )
+                        for candidate in response.candidates
+                    ]
+                self.completion_hook.on_completion(
+                    inputs=inputs,
+                    outputs=outputs,
+                    system_instruction=system_instructions,
+                    span=span,
+                    log_record=event,
+                )
+                content_attributes = {
+                    k: [asdict(x) for x in v]
+                    for k, v in [
+                        (
+                            GenAI.GEN_AI_SYSTEM_INSTRUCTIONS,
+                            system_instructions,
+                        ),
+                        (GenAI.GEN_AI_INPUT_MESSAGES, inputs),
+                        (GenAI.GEN_AI_OUTPUT_MESSAGES, outputs),
+                    ]
+                    if v
+                }
+                if span.is_recording():
+                    span.set_attributes(attributes)
+                    if capture_content in (
+                        ContentCapturingMode.SPAN_AND_EVENT,
+                        ContentCapturingMode.SPAN_ONLY,
+                    ):
+                        span.set_attributes(
+                            {
+                                k: gen_ai_json_dumps(v)
+                                for k, v in content_attributes.items()
+                            }
+                        )
+                event.attributes = attributes
+                if capture_content in (
+                    ContentCapturingMode.SPAN_AND_EVENT,
+                    ContentCapturingMode.EVENT_ONLY,
+                ):
+                    event.attributes |= content_attributes
+                self.logger.emit(event)
+
+            yield handle_response
+
+    @contextmanager
+    def _with_default_instrumentation(
+        self,
+        capture_content: bool,
         instance: client.PredictionServiceClient
         | client_v1beta1.PredictionServiceClient,
         args: Any,
@@ -106,12 +259,13 @@ def generate_content_create(
         params = _extract_params(*args, **kwargs)
         api_endpoint: str = instance.api_endpoint  # type: ignore[reportUnknownMemberType]
         span_attributes = {
-            **get_genai_request_attributes(params),
+            **get_genai_request_attributes(False, params),
             **get_server_attributes(api_endpoint),
         }
 
         span_name = get_span_name(span_attributes)
-        with tracer.start_as_current_span(
+
+        with self.tracer.start_as_current_span(
             name=span_name,
             kind=SpanKind.CLIENT,
             attributes=span_attributes,
@@ -119,24 +273,99 @@ def generate_content_create(
             for event in request_to_events(
                 params=params, capture_content=capture_content
             ):
-                event_logger.emit(event)
+                self.logger.emit(event)
 
             # TODO: set error.type attribute
             # https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-spans.md
-            response = wrapped(*args, **kwargs)
-            # TODO: handle streaming
-            # if is_streaming(kwargs):
-            #     return StreamWrapper(
-            #         result, span, event_logger, capture_content
-            #     )
-
-            if span.is_recording():
-                span.set_attributes(get_genai_response_attributes(response))
-            for event in response_to_events(
-                response=response, capture_content=capture_content
-            ):
-                event_logger.emit(event)
 
-            return response
+            def handle_response(
+                response: prediction_service.GenerateContentResponse
+                | prediction_service_v1beta1.GenerateContentResponse,
+            ) -> None:
+                if span.is_recording():
+                    # When streaming, this is called multiple times so attributes would be
+                    # overwritten. In practice, it looks the API only returns the interesting
+                    # attributes on the last streamed response. However, I couldn't find
+                    # documentation for this and setting attributes shouldn't be too expensive.
+                    span.set_attributes(
+                        get_genai_response_attributes(response)
+                    )
+
+                for event in response_to_events(
+                    response=response, capture_content=capture_content
+                ):
+                    self.logger.emit(event)
+
+            yield handle_response
+
+    def generate_content(
+        self,
+        wrapped: Callable[
+            ...,
+            prediction_service.GenerateContentResponse
+            | prediction_service_v1beta1.GenerateContentResponse,
+        ],
+        instance: client.PredictionServiceClient
+        | client_v1beta1.PredictionServiceClient,
+        args: Any,
+        kwargs: Any,
+    ) -> (
+        prediction_service.GenerateContentResponse
+        | prediction_service_v1beta1.GenerateContentResponse
+    ):
+        if self.sem_conv_opt_in_mode == _StabilityMode.DEFAULT:
+            capture_content_bool = cast(bool, self.capture_content)
+            with self._with_default_instrumentation(
+                capture_content_bool, instance, args, kwargs
+            ) as handle_response:
+                response = wrapped(*args, **kwargs)
+                handle_response(response)
+                return response
+        else:
+            capture_content = cast(ContentCapturingMode, self.capture_content)
+            with self._with_new_instrumentation(
+                capture_content, instance, args, kwargs
+            ) as handle_response:
+                response = None
+                try:
+                    response = wrapped(*args, **kwargs)
+                    return response
+                finally:
+                    handle_response(response)
 
-    return traced_method
+    async def agenerate_content(
+        self,
+        wrapped: Callable[
+            ...,
+            Awaitable[
+                prediction_service.GenerateContentResponse
+                | prediction_service_v1beta1.GenerateContentResponse
+            ],
+        ],
+        instance: client.PredictionServiceClient
+        | client_v1beta1.PredictionServiceClient,
+        args: Any,
+        kwargs: Any,
+    ) -> (
+        prediction_service.GenerateContentResponse
+        | prediction_service_v1beta1.GenerateContentResponse
+    ):
+        if self.sem_conv_opt_in_mode == _StabilityMode.DEFAULT:
+            capture_content_bool = cast(bool, self.capture_content)
+            with self._with_default_instrumentation(
+                capture_content_bool, instance, args, kwargs
+            ) as handle_response:
+                response = await wrapped(*args, **kwargs)
+                handle_response(response)
+                return response
+        else:
+            capture_content = cast(ContentCapturingMode, self.capture_content)
+            with self._with_new_instrumentation(
+                capture_content, instance, args, kwargs
+            ) as handle_response:
+                response = None
+                try:
+                    response = await wrapped(*args, **kwargs)
+                    return response
+                finally:
+                    handle_response(response)

opentelemetry/instrumentation/vertexai/utils.py

@@ -12,27 +12,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# type: ignore[reportUnknownDeprecated]
+
 from __future__ import annotations
 
+import logging
 import re
 from dataclasses import dataclass
 from os import environ
 from typing import (
     TYPE_CHECKING,
     Iterable,
+    Literal,
     Mapping,
     Sequence,
+    Union,
     cast,
+    overload,
 )
 from urllib.parse import urlparse
 
 from google.protobuf import json_format
 
-from opentelemetry._events import Event
+from opentelemetry._logs import LogRecord
+from opentelemetry.instrumentation._semconv import (
+    _StabilityMode,
+)
 from opentelemetry.instrumentation.vertexai.events import (
     ChoiceMessage,
     ChoiceToolCall,
-    FinishReason,
     assistant_event,
     choice_event,
     system_event,
@@ -43,6 +51,15 @@ from opentelemetry.semconv._incubating.attributes import (
     gen_ai_attributes as GenAIAttributes,
 )
 from opentelemetry.semconv.attributes import server_attributes
+from opentelemetry.util.genai.types import (
+    ContentCapturingMode,
+    FinishReason,
+    MessagePart,
+    Text,
+    ToolCall,
+    ToolCallResponse,
+)
+from opentelemetry.util.genai.utils import get_content_capturing_mode
 from opentelemetry.util.types import AnyValue, AttributeValue
 
 if TYPE_CHECKING:
@@ -103,7 +120,8 @@ def get_server_attributes(
     }
 
 
-def get_genai_request_attributes(
+def get_genai_request_attributes(  # pylint: disable=too-many-branches
+    use_latest_semconvs: bool,
     params: GenerateContentParams,
     operation_name: GenAIAttributes.GenAiOperationNameValues = GenAIAttributes.GenAiOperationNameValues.CHAT,
 ):
@@ -111,9 +129,12 @@ def get_genai_request_attributes(
     generation_config = params.generation_config
     attributes: dict[str, AttributeValue] = {
         GenAIAttributes.GEN_AI_OPERATION_NAME: operation_name.value,
-        GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.VERTEX_AI.value,
         GenAIAttributes.GEN_AI_REQUEST_MODEL: model,
     }
+    if not use_latest_semconvs:
+        attributes[GenAIAttributes.GEN_AI_SYSTEM] = (
+            GenAIAttributes.GenAiSystemValues.VERTEX_AI.value
+        )
 
     if not generation_config:
         return attributes
@@ -125,6 +146,8 @@ def get_genai_request_attributes(
             generation_config.temperature
         )
     if "top_p" in generation_config:
+        # There is also a top_k parameter ( The maximum number of tokens to consider when sampling.),
+        # but no semconv yet exists for it.
         attributes[GenAIAttributes.GEN_AI_REQUEST_TOP_P] = (
             generation_config.top_p
         )
@@ -140,30 +163,43 @@ def get_genai_request_attributes(
         attributes[GenAIAttributes.GEN_AI_REQUEST_FREQUENCY_PENALTY] = (
             generation_config.frequency_penalty
         )
-    # Uncomment once GEN_AI_REQUEST_SEED is released in 1.30
-    # https://github.com/open-telemetry/semantic-conventions/pull/1710
-    # if "seed" in generation_config:
-    #     attributes[GenAIAttributes.GEN_AI_REQUEST_SEED] = (
-    #         generation_config.seed
-    #     )
     if "stop_sequences" in generation_config:
         attributes[GenAIAttributes.GEN_AI_REQUEST_STOP_SEQUENCES] = (
             generation_config.stop_sequences
         )
+    if use_latest_semconvs:
+        if "seed" in generation_config:
+            attributes[GenAIAttributes.GEN_AI_REQUEST_SEED] = (
+                generation_config.seed
+            )
+        if "candidate_count" in generation_config:
+            attributes[GenAIAttributes.GEN_AI_REQUEST_CHOICE_COUNT] = (
+                generation_config.candidate_count
+            )
+        if "response_mime_type" in generation_config:
+            if generation_config.response_mime_type == "text/plain":
+                attributes[GenAIAttributes.GEN_AI_OUTPUT_TYPE] = "text"
+            elif generation_config.response_mime_type == "application/json":
+                attributes[GenAIAttributes.GEN_AI_OUTPUT_TYPE] = "json"
+            else:
+                attributes[GenAIAttributes.GEN_AI_OUTPUT_TYPE] = (
+                    generation_config.response_mime_type
+                )
 
     return attributes
 
 
 def get_genai_response_attributes(
     response: prediction_service.GenerateContentResponse
-    | prediction_service_v1beta1.GenerateContentResponse,
+    | prediction_service_v1beta1.GenerateContentResponse
+    | None,
 ) -> dict[str, AttributeValue]:
+    if not response:
+        return {}
     finish_reasons: list[str] = [
         _map_finish_reason(candidate.finish_reason)
         for candidate in response.candidates
     ]
-    # TODO: add gen_ai.response.id once available in the python client
-    # https://github.com/open-telemetry/opentelemetry-python-contrib/issues/3246
     return {
         GenAIAttributes.GEN_AI_RESPONSE_MODEL: response.model_version,
         GenAIAttributes.GEN_AI_RESPONSE_FINISH_REASONS: finish_reasons,
@@ -186,12 +222,29 @@ OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = (
 )
 
 
-def is_content_enabled() -> bool:
-    capture_content = environ.get(
-        OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, "false"
-    )
+@overload
+def is_content_enabled(
+    mode: Literal[_StabilityMode.GEN_AI_LATEST_EXPERIMENTAL],
+) -> ContentCapturingMode: ...
+
+
+@overload
+def is_content_enabled(mode: Literal[_StabilityMode.DEFAULT]) -> bool: ...
+
+
+def is_content_enabled(
+    mode: Union[
+        Literal[_StabilityMode.DEFAULT],
+        Literal[_StabilityMode.GEN_AI_LATEST_EXPERIMENTAL],
+    ],
+) -> Union[bool, ContentCapturingMode]:
+    if mode == _StabilityMode.DEFAULT:
+        capture_content = environ.get(
+            OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, "false"
+        )
 
-    return capture_content.lower() == "true"
+        return capture_content.lower() == "true"
+    return get_content_capturing_mode()
 
 
 def get_span_name(span_attributes: Mapping[str, AttributeValue]) -> str:
@@ -204,7 +257,7 @@ def get_span_name(span_attributes: Mapping[str, AttributeValue]) -> str:
 
 def request_to_events(
     *, params: GenerateContentParams, capture_content: bool
-) -> Iterable[Event]:
+) -> Iterable[LogRecord]:
     # System message
     if params.system_instruction:
         request_content = _parts_to_any_value(
@@ -256,12 +309,72 @@ def request_to_events(
         yield user_event(role=content.role, content=request_content)
 
 
+@dataclass
+class BlobPart:
+    data: bytes
+    mime_type: str
+    type: Literal["blob"] = "blob"
+
+
+@dataclass
+class FileDataPart:
+    mime_type: str
+    uri: str
+    type: Literal["file_data"] = "file_data"
+
+    class Config:
+        extra = "allow"
+
+
+def convert_content_to_message_parts(
+    content: content.Content | content_v1beta1.Content,
+) -> list[MessagePart]:
+    parts: MessagePart = []
+    for idx, part in enumerate(content.parts):
+        if "function_response" in part:
+            part = part.function_response
+            parts.append(
+                ToolCallResponse(
+                    id=f"{part.name}_{idx}",
+                    response=json_format.MessageToDict(part._pb.response),  # type: ignore[reportUnknownMemberType]
+                )
+            )
+        elif "function_call" in part:
+            part = part.function_call
+            parts.append(
+                ToolCall(
+                    id=f"{part.name}_{idx}",
+                    name=part.name,
+                    arguments=json_format.MessageToDict(
+                        part._pb.args,  # type: ignore[reportUnknownMemberType]
+                    ),
+                )
+            )
+        elif "text" in part:
+            parts.append(Text(content=part.text))
+        elif "inline_data" in part:
+            part = part.inline_data
+            parts.append(
+                BlobPart(mime_type=part.mime_type or "", data=part.data or b"")
+            )
+        elif "file_data" in part:
+            part = part.file_data
+            parts.append(
+                FileDataPart(
+                    mime_type=part.mime_type or "", uri=part.file_uri or ""
+                )
+            )
+        else:
+            logging.warning("Unknown part dropped from telemetry %s", part)
+    return parts
+
+
 def response_to_events(
     *,
     response: prediction_service.GenerateContentResponse
     | prediction_service_v1beta1.GenerateContentResponse,
     capture_content: bool,
-) -> Iterable[Event]:
+) -> Iterable[LogRecord]:
     for candidate in response.candidates:
         tool_calls = _extract_tool_calls(
             candidate=candidate, capture_content=capture_content
@@ -319,7 +432,9 @@ def _parts_to_any_value(
     return [
         cast(
             "dict[str, AnyValue]",
-            type(part).to_dict(part, including_default_value_fields=False),  # type: ignore[reportUnknownMemberType]
+            type(part).to_dict(  # type: ignore[reportUnknownMemberType]
+                part, always_print_fields_with_no_presence=False
+            ),
         )
         for part in parts
     ]

opentelemetry/instrumentation/vertexai/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "2.0b0"
+__version__ = "2.1b0"

{opentelemetry_instrumentation_vertexai-2.0b0.dist-info → opentelemetry_instrumentation_vertexai-2.1b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-vertexai
-Version: 2.0b0
+Version: 2.1b0
 Summary: OpenTelemetry Official VertexAI instrumentation
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation-genai/opentelemetry-instrumentation-vertexai
 Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
@@ -12,15 +12,15 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Requires-Dist: opentelemetry-api~=1.28
-Requires-Dist: opentelemetry-instrumentation~=0.49b0
-Requires-Dist: opentelemetry-semantic-conventions~=0.49b0
+Requires-Python: >=3.9
+Requires-Dist: opentelemetry-api~=1.37
+Requires-Dist: opentelemetry-instrumentation~=0.58b0
+Requires-Dist: opentelemetry-semantic-conventions~=0.58b0
+Requires-Dist: opentelemetry-util-genai<0.3b0,>=0.2b0
 Provides-Extra: instruments
 Requires-Dist: google-cloud-aiplatform>=1.64; extra == 'instruments'
 Description-Content-Type: text/x-rst

opentelemetry_instrumentation_vertexai-2.1b0.dist-info/RECORD

@@ -0,0 +1,12 @@
+opentelemetry/instrumentation/vertexai/__init__.py,sha256=h2ikRd_hLXscLwbacyfCY5fdFYH76iMxkHHr8r1AeCU,6010
+opentelemetry/instrumentation/vertexai/events.py,sha256=EHp1uqJ-vMKJ5jVxRgHNyboN51JUYEPcXcT3yV5rcRE,5274
+opentelemetry/instrumentation/vertexai/package.py,sha256=CFLAAZb6L_fDNfJgpW-cXjhiQjwGLAuxhdAjMNt3jPM,638
+opentelemetry/instrumentation/vertexai/patch.py,sha256=_YZpMo14k-ccy8VcNbl9rG7VsztLorcS12an6e8wJx8,13543
+opentelemetry/instrumentation/vertexai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opentelemetry/instrumentation/vertexai/utils.py,sha256=CxOypyBGjpuaKX4lijomyGBupiViC_TpYHgiCTR2nGE,15001
+opentelemetry/instrumentation/vertexai/version.py,sha256=tlQVIB6SsAnJ7uZmREAk0QDaATSCgbgYwdtY4G8GX9M,607
+opentelemetry_instrumentation_vertexai-2.1b0.dist-info/METADATA,sha256=tXZDreIfz0gB64b5zYAdufFr3WdjRL6hB_1k4ynrrL4,3946
+opentelemetry_instrumentation_vertexai-2.1b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentelemetry_instrumentation_vertexai-2.1b0.dist-info/entry_points.txt,sha256=aAbxWr7zIDuYms-m-ea5GEV2rqyx7xPT8FWr2umrCmU,100
+opentelemetry_instrumentation_vertexai-2.1b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentelemetry_instrumentation_vertexai-2.1b0.dist-info/RECORD,,

opentelemetry_instrumentation_vertexai-2.0b0.dist-info/RECORD

@@ -1,12 +0,0 @@
-opentelemetry/instrumentation/vertexai/__init__.py,sha256=DrASu5cA6RjJU9fX6z-T4Oi_DfG5bmZi49mX4D7k_us,3188
-opentelemetry/instrumentation/vertexai/events.py,sha256=0PlFioS1I_hnvelEwFAOMxwiLBQqQpq9ADSZa8yxF_c,5161
-opentelemetry/instrumentation/vertexai/package.py,sha256=CFLAAZb6L_fDNfJgpW-cXjhiQjwGLAuxhdAjMNt3jPM,638
-opentelemetry/instrumentation/vertexai/patch.py,sha256=UIgMrsT4Qhr6bFRUn2vca_ntQgR7MGUMRlVZEsgMvDA,4769
-opentelemetry/instrumentation/vertexai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opentelemetry/instrumentation/vertexai/utils.py,sha256=CJwxZIH-9CmnCcbc9TXsG9W59NaJdU_cHDVTdK-6jCU,11546
-opentelemetry/instrumentation/vertexai/version.py,sha256=3DvzQveBD-YdMIJDP5YIVXzqInnizLBgk8mSkEdl7CA,607
-opentelemetry_instrumentation_vertexai-2.0b0.dist-info/METADATA,sha256=G6fPgJcQPWVvSTSeD1oC-ssN6V7_Rql_30B1Q3BaW3I,3942
-opentelemetry_instrumentation_vertexai-2.0b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-opentelemetry_instrumentation_vertexai-2.0b0.dist-info/entry_points.txt,sha256=aAbxWr7zIDuYms-m-ea5GEV2rqyx7xPT8FWr2umrCmU,100
-opentelemetry_instrumentation_vertexai-2.0b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentelemetry_instrumentation_vertexai-2.0b0.dist-info/RECORD,,