opentelemetry-instrumentation-vertexai 0.38.7__py3-none-any.whl → 2.0b0__py3-none-any.whl

opentelemetry/instrumentation/vertexai/patch.py

@@ -0,0 +1,142 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    MutableSequence,
+)
+
+from opentelemetry._events import EventLogger
+from opentelemetry.instrumentation.vertexai.utils import (
+    GenerateContentParams,
+    get_genai_request_attributes,
+    get_genai_response_attributes,
+    get_server_attributes,
+    get_span_name,
+    request_to_events,
+    response_to_events,
+)
+from opentelemetry.trace import SpanKind, Tracer
+
+if TYPE_CHECKING:
+    from google.cloud.aiplatform_v1.services.prediction_service import client
+    from google.cloud.aiplatform_v1.types import (
+        content,
+        prediction_service,
+    )
+    from google.cloud.aiplatform_v1beta1.services.prediction_service import (
+        client as client_v1beta1,
+    )
+    from google.cloud.aiplatform_v1beta1.types import (
+        content as content_v1beta1,
+    )
+    from google.cloud.aiplatform_v1beta1.types import (
+        prediction_service as prediction_service_v1beta1,
+    )
+
+
+# Use parameter signature from
+# https://github.com/googleapis/python-aiplatform/blob/v1.76.0/google/cloud/aiplatform_v1/services/prediction_service/client.py#L2088
+# to handle named vs positional args robustly
+def _extract_params(
+    request: prediction_service.GenerateContentRequest
+    | prediction_service_v1beta1.GenerateContentRequest
+    | dict[Any, Any]
+    | None = None,
+    *,
+    model: str | None = None,
+    contents: MutableSequence[content.Content]
+    | MutableSequence[content_v1beta1.Content]
+    | None = None,
+    **_kwargs: Any,
+) -> GenerateContentParams:
+    # Request vs the named parameters are mututally exclusive or the RPC will fail
+    if not request:
+        return GenerateContentParams(
+            model=model or "",
+            contents=contents,
+        )
+
+    if isinstance(request, dict):
+        return GenerateContentParams(**request)
+
+    return GenerateContentParams(
+        model=request.model,
+        contents=request.contents,
+        system_instruction=request.system_instruction,
+        tools=request.tools,
+        tool_config=request.tool_config,
+        labels=request.labels,
+        safety_settings=request.safety_settings,
+        generation_config=request.generation_config,
+    )
+
+
+def generate_content_create(
+    tracer: Tracer, event_logger: EventLogger, capture_content: bool
+):
+    """Wrap the `generate_content` method of the `GenerativeModel` class to trace it."""
+
+    def traced_method(
+        wrapped: Callable[
+            ...,
+            prediction_service.GenerateContentResponse
+            | prediction_service_v1beta1.GenerateContentResponse,
+        ],
+        instance: client.PredictionServiceClient
+        | client_v1beta1.PredictionServiceClient,
+        args: Any,
+        kwargs: Any,
+    ):
+        params = _extract_params(*args, **kwargs)
+        api_endpoint: str = instance.api_endpoint  # type: ignore[reportUnknownMemberType]
+        span_attributes = {
+            **get_genai_request_attributes(params),
+            **get_server_attributes(api_endpoint),
+        }
+
+        span_name = get_span_name(span_attributes)
+        with tracer.start_as_current_span(
+            name=span_name,
+            kind=SpanKind.CLIENT,
+            attributes=span_attributes,
+        ) as span:
+            for event in request_to_events(
+                params=params, capture_content=capture_content
+            ):
+                event_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
+
+    return traced_method

opentelemetry/instrumentation/vertexai/utils.py

@@ -1,29 +1,344 @@
-import logging
-import traceback
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
-from opentelemetry.instrumentation.vertexai.config import Config
+from __future__ import annotations
 
+import re
+from dataclasses import dataclass
+from os import environ
+from typing import (
+    TYPE_CHECKING,
+    Iterable,
+    Mapping,
+    Sequence,
+    cast,
+)
+from urllib.parse import urlparse
+
+from google.protobuf import json_format
+
+from opentelemetry._events import Event
+from opentelemetry.instrumentation.vertexai.events import (
+    ChoiceMessage,
+    ChoiceToolCall,
+    FinishReason,
+    assistant_event,
+    choice_event,
+    system_event,
+    tool_event,
+    user_event,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+from opentelemetry.semconv.attributes import server_attributes
+from opentelemetry.util.types import AnyValue, AttributeValue
+
+if TYPE_CHECKING:
+    from google.cloud.aiplatform_v1.types import (
+        content,
+        prediction_service,
+        tool,
+    )
+    from google.cloud.aiplatform_v1beta1.types import (
+        content as content_v1beta1,
+    )
+    from google.cloud.aiplatform_v1beta1.types import (
+        prediction_service as prediction_service_v1beta1,
+    )
+    from google.cloud.aiplatform_v1beta1.types import (
+        tool as tool_v1beta1,
+    )
+
+
+_MODEL = "model"
 
-def dont_throw(func):
-    """
-    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
 
-    @param func: The function to wrap
-    @return: The wrapper function
+@dataclass(frozen=True)
+class GenerateContentParams:
+    model: str
+    contents: (
+        Sequence[content.Content] | Sequence[content_v1beta1.Content] | None
+    ) = None
+    system_instruction: content.Content | content_v1beta1.Content | None = None
+    tools: Sequence[tool.Tool] | Sequence[tool_v1beta1.Tool] | None = None
+    tool_config: tool.ToolConfig | tool_v1beta1.ToolConfig | None = None
+    labels: Mapping[str, str] | None = None
+    safety_settings: (
+        Sequence[content.SafetySetting]
+        | Sequence[content_v1beta1.SafetySetting]
+        | None
+    ) = None
+    generation_config: (
+        content.GenerationConfig | content_v1beta1.GenerationConfig | None
+    ) = None
+
+
+def get_server_attributes(
+    endpoint: str,
+) -> dict[str, AttributeValue]:
+    """Get server.* attributes from the endpoint, which is a hostname with optional port e.g.
+    - ``us-central1-aiplatform.googleapis.com``
+    - ``us-central1-aiplatform.googleapis.com:5431``
     """
-    # Obtain a logger specific to the function's module
-    logger = logging.getLogger(func.__module__)
-
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.debug(
-                "OpenLLMetry failed to trace in %s, error: %s",
-                func.__name__,
-                traceback.format_exc(),
+    parsed = urlparse(f"scheme://{endpoint}")
+
+    if not parsed.hostname:
+        return {}
+
+    return {
+        server_attributes.SERVER_ADDRESS: parsed.hostname,
+        server_attributes.SERVER_PORT: parsed.port or 443,
+    }
+
+
+def get_genai_request_attributes(
+    params: GenerateContentParams,
+    operation_name: GenAIAttributes.GenAiOperationNameValues = GenAIAttributes.GenAiOperationNameValues.CHAT,
+):
+    model = _get_model_name(params.model)
+    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 generation_config:
+        return attributes
+
+    # Check for optional fields
+    # https://proto-plus-python.readthedocs.io/en/stable/fields.html#optional-fields
+    if "temperature" in generation_config:
+        attributes[GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE] = (
+            generation_config.temperature
+        )
+    if "top_p" in generation_config:
+        attributes[GenAIAttributes.GEN_AI_REQUEST_TOP_P] = (
+            generation_config.top_p
+        )
+    if "max_output_tokens" in generation_config:
+        attributes[GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS] = (
+            generation_config.max_output_tokens
+        )
+    if "presence_penalty" in generation_config:
+        attributes[GenAIAttributes.GEN_AI_REQUEST_PRESENCE_PENALTY] = (
+            generation_config.presence_penalty
+        )
+    if "frequency_penalty" in generation_config:
+        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
+        )
+
+    return attributes
+
+
+def get_genai_response_attributes(
+    response: prediction_service.GenerateContentResponse
+    | prediction_service_v1beta1.GenerateContentResponse,
+) -> dict[str, AttributeValue]:
+    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,
+        GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS: response.usage_metadata.prompt_token_count,
+        GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS: response.usage_metadata.candidates_token_count,
+    }
+
+
+_MODEL_STRIP_RE = re.compile(
+    r"^projects/(.*)/locations/(.*)/publishers/google/models/"
+)
+
+
+def _get_model_name(model: str) -> str:
+    return _MODEL_STRIP_RE.sub("", model)
+
+
+OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = (
+    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"
+)
+
+
+def is_content_enabled() -> bool:
+    capture_content = environ.get(
+        OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, "false"
+    )
+
+    return capture_content.lower() == "true"
+
+
+def get_span_name(span_attributes: Mapping[str, AttributeValue]) -> str:
+    name = span_attributes[GenAIAttributes.GEN_AI_OPERATION_NAME]
+    model = span_attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL]
+    if not model:
+        return f"{name}"
+    return f"{name} {model}"
+
+
+def request_to_events(
+    *, params: GenerateContentParams, capture_content: bool
+) -> Iterable[Event]:
+    # System message
+    if params.system_instruction:
+        request_content = _parts_to_any_value(
+            capture_content=capture_content,
+            parts=params.system_instruction.parts,
+        )
+        yield system_event(
+            role=params.system_instruction.role, content=request_content
+        )
+
+    for content in params.contents or []:
+        # Assistant message
+        if content.role == _MODEL:
+            request_content = _parts_to_any_value(
+                capture_content=capture_content, parts=content.parts
+            )
+
+            yield assistant_event(role=content.role, content=request_content)
+            continue
+
+        # Tool event
+        #
+        # Function call results can be parts inside of a user Content or in a separate Content
+        # entry without a role. That may cause duplication in a user event, see
+        # https://github.com/open-telemetry/opentelemetry-python-contrib/issues/3280
+        function_responses = [
+            part.function_response
+            for part in content.parts
+            if "function_response" in part
+        ]
+        for idx, function_response in enumerate(function_responses):
+            yield tool_event(
+                id_=f"{function_response.name}_{idx}",
+                role=content.role,
+                content=json_format.MessageToDict(
+                    function_response._pb.response  # type: ignore[reportUnknownMemberType]
+                )
+                if capture_content
+                else None,
             )
-            if Config.exception_logger:
-                Config.exception_logger(e)
 
-    return wrapper
+        if len(function_responses) == len(content.parts):
+            # If the content only contained function responses, don't emit a user event
+            continue
+
+        request_content = _parts_to_any_value(
+            capture_content=capture_content, parts=content.parts
+        )
+        yield user_event(role=content.role, content=request_content)
+
+
+def response_to_events(
+    *,
+    response: prediction_service.GenerateContentResponse
+    | prediction_service_v1beta1.GenerateContentResponse,
+    capture_content: bool,
+) -> Iterable[Event]:
+    for candidate in response.candidates:
+        tool_calls = _extract_tool_calls(
+            candidate=candidate, capture_content=capture_content
+        )
+
+        # The original function_call Part is still duplicated in message, see
+        # https://github.com/open-telemetry/opentelemetry-python-contrib/issues/3280
+        yield choice_event(
+            finish_reason=_map_finish_reason(candidate.finish_reason),
+            index=candidate.index,
+            # default to "model" since Vertex uses that instead of assistant
+            message=ChoiceMessage(
+                role=candidate.content.role or _MODEL,
+                content=_parts_to_any_value(
+                    capture_content=capture_content,
+                    parts=candidate.content.parts,
+                ),
+            ),
+            tool_calls=tool_calls,
+        )
+
+
+def _extract_tool_calls(
+    *,
+    candidate: content.Candidate | content_v1beta1.Candidate,
+    capture_content: bool,
+) -> Iterable[ChoiceToolCall]:
+    for idx, part in enumerate(candidate.content.parts):
+        if "function_call" not in part:
+            continue
+
+        yield ChoiceToolCall(
+            # Make up an id with index since vertex expects the indices to line up instead of
+            # using ids.
+            id=f"{part.function_call.name}_{idx}",
+            function=ChoiceToolCall.Function(
+                name=part.function_call.name,
+                arguments=json_format.MessageToDict(
+                    part.function_call._pb.args  # type: ignore[reportUnknownMemberType]
+                )
+                if capture_content
+                else None,
+            ),
+        )
+
+
+def _parts_to_any_value(
+    *,
+    capture_content: bool,
+    parts: Sequence[content.Part] | Sequence[content_v1beta1.Part],
+) -> list[dict[str, AnyValue]] | None:
+    if not capture_content:
+        return None
+
+    return [
+        cast(
+            "dict[str, AnyValue]",
+            type(part).to_dict(part, including_default_value_fields=False),  # type: ignore[reportUnknownMemberType]
+        )
+        for part in parts
+    ]
+
+
+def _map_finish_reason(
+    finish_reason: content.Candidate.FinishReason
+    | content_v1beta1.Candidate.FinishReason,
+) -> FinishReason | str:
+    EnumType = type(finish_reason)  # pylint: disable=invalid-name
+    if (
+        finish_reason is EnumType.FINISH_REASON_UNSPECIFIED
+        or finish_reason is EnumType.OTHER
+    ):
+        return "error"
+    if finish_reason is EnumType.STOP:
+        return "stop"
+    if finish_reason is EnumType.MAX_TOKENS:
+        return "length"
+
+    # If there is no 1:1 mapping to an OTel preferred enum value, use the exact vertex reason
+    return finish_reason.name

opentelemetry/instrumentation/vertexai/version.py

@@ -1 +1,15 @@
-__version__ = "0.38.7"
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "2.0b0"

opentelemetry_instrumentation_vertexai-2.0b0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: opentelemetry-instrumentation-vertexai
+Version: 2.0b0
+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
+Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+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
+Provides-Extra: instruments
+Requires-Dist: google-cloud-aiplatform>=1.64; extra == 'instruments'
+Description-Content-Type: text/x-rst
+
+OpenTelemetry VertexAI Instrumentation
+======================================
+
+|pypi|
+
+.. |pypi| image:: https://badge.fury.io/py/opentelemetry-instrumentation-vertexai.svg
+   :target: https://pypi.org/project/opentelemetry-instrumentation-vertexai/
+
+This library allows tracing LLM requests and logging of messages made by the
+`VertexAI Python API library <https://pypi.org/project/google-cloud-aiplatform/>`_.
+
+
+Installation
+------------
+
+If your application is already instrumented with OpenTelemetry, add this
+package to your requirements.
+::
+
+    pip install opentelemetry-instrumentation-vertexai
+
+If you don't have an VertexAI application, yet, try our `examples <examples>`_.
+
+Check out `zero-code example <examples/zero-code>`_ for a quick start.
+
+Usage
+-----
+
+This section describes how to set up VertexAI instrumentation if you're setting OpenTelemetry up manually.
+Check out the `manual example <examples/manual>`_ for more details.
+
+Instrumenting all clients
+*************************
+
+When using the instrumentor, all clients will automatically trace VertexAI chat completion operations.
+You can also optionally capture prompts and completions as log events.
+
+Make sure to configure OpenTelemetry tracing, logging, and events to capture all telemetry emitted by the instrumentation.
+
+.. code-block:: python
+
+    from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+    from vertexai.generative_models import GenerativeModel
+
+    VertexAIInstrumentor().instrument()
+
+
+    vertexai.init()
+    model = GenerativeModel("gemini-1.5-flash-002")
+    response = model.generate_content("Write a short poem on OpenTelemetry.")
+
+Enabling message content
+*************************
+
+Message content such as the contents of the prompt, completion, function arguments and return values
+are not captured by default. To capture message content as log events, set the environment variable
+`OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `true`.
+
+Uninstrument
+************
+
+To uninstrument clients, call the uninstrument method:
+
+.. code-block:: python
+
+    from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+
+    VertexAIInstrumentor().instrument()
+    # ...
+
+    # Uninstrument all clients
+    VertexAIInstrumentor().uninstrument()
+
+References
+----------
+* `OpenTelemetry VertexAI Instrumentation <https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/vertexai/vertexai.html>`_
+* `OpenTelemetry Project <https://opentelemetry.io/>`_
+* `OpenTelemetry Python Examples <https://github.com/open-telemetry/opentelemetry-python/tree/main/docs/examples>`_
+

opentelemetry_instrumentation_vertexai-2.0b0.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

{opentelemetry_instrumentation_vertexai-0.38.7.dist-info → opentelemetry_instrumentation_vertexai-2.0b0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

opentelemetry_instrumentation_vertexai-2.0b0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[opentelemetry_instrumentor]
+vertexai = opentelemetry.instrumentation.vertexai:VertexAIInstrumentor