opentelemetry-instrumentation-vertexai 0.45.0__tar.gz → 0.49.6__tar.gz

{opentelemetry_instrumentation_vertexai-0.45.0 → opentelemetry_instrumentation_vertexai-0.49.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-vertexai
-Version: 0.45.0
+Version: 0.49.6
 Summary: OpenTelemetry Vertex AI instrumentation
 License: Apache-2.0
 Author: Gal Kleinman
@@ -13,11 +13,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: instruments
-Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.50b0)
-Requires-Dist: opentelemetry-semantic-conventions (>=0.50b0)
-Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.11)
+Requires-Dist: opentelemetry-api (>=1.38.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.13,<0.5.0)
 Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-vertexai
 Description-Content-Type: text/markdown
 

{opentelemetry_instrumentation_vertexai-0.45.0 → opentelemetry_instrumentation_vertexai-0.49.6}/opentelemetry/instrumentation/vertexai/__init__.py

@@ -5,7 +5,7 @@ import types
 from typing import Collection
 
 from opentelemetry import context as context_api
-from opentelemetry._events import get_event_logger
+from opentelemetry._logs import get_logger
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
 from opentelemetry.instrumentation.vertexai.config import Config
@@ -15,12 +15,16 @@ from opentelemetry.instrumentation.vertexai.event_emitter import (
 )
 from opentelemetry.instrumentation.vertexai.span_utils import (
     set_input_attributes,
+    set_input_attributes_sync,
     set_model_input_attributes,
     set_model_response_attributes,
     set_response_attributes,
 )
 from opentelemetry.instrumentation.vertexai.utils import dont_throw, should_emit_events
 from opentelemetry.instrumentation.vertexai.version import __version__
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
 from opentelemetry.semconv_ai import (
     SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
     LLMRequestTypeValues,
@@ -178,12 +182,12 @@ async def _abuild_from_streaming_response(span, event_logger, response, llm_mode
 
 
 @dont_throw
-def _handle_request(span, event_logger, args, kwargs, llm_model):
+async def _handle_request(span, event_logger, args, kwargs, llm_model):
     set_model_input_attributes(span, kwargs, llm_model)
     if should_emit_events():
         emit_prompt_events(args, event_logger)
     else:
-        set_input_attributes(span, args)
+        await set_input_attributes(span, args)
 
 
 def _handle_response(span, event_logger, response, llm_model):
@@ -223,18 +227,23 @@ async def _awrap(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs)
         llm_model = instance._model_id
     if hasattr(instance, "_model_name"):
         llm_model = instance._model_name.replace("publishers/google/models/", "")
+    # For ChatSession, try to get model from the parent model object
+    if hasattr(instance, "_model") and hasattr(instance._model, "_model_name"):
+        llm_model = instance._model._model_name.replace("publishers/google/models/", "")
+    elif hasattr(instance, "_model") and hasattr(instance._model, "_model_id"):
+        llm_model = instance._model._model_id
 
     name = to_wrap.get("span_name")
     span = tracer.start_span(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Google",
+            GenAIAttributes.GEN_AI_SYSTEM: "Google",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
 
-    _handle_request(span, event_logger, args, kwargs, llm_model)
+    await _handle_request(span, event_logger, args, kwargs, llm_model)
 
     response = await wrapped(*args, **kwargs)
 
@@ -267,18 +276,28 @@ def _wrap(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs):
         llm_model = instance._model_id
     if hasattr(instance, "_model_name"):
         llm_model = instance._model_name.replace("publishers/google/models/", "")
+    # For ChatSession, try to get model from the parent model object
+    if hasattr(instance, "_model") and hasattr(instance._model, "_model_name"):
+        llm_model = instance._model._model_name.replace("publishers/google/models/", "")
+    elif hasattr(instance, "_model") and hasattr(instance._model, "_model_id"):
+        llm_model = instance._model._model_id
 
     name = to_wrap.get("span_name")
     span = tracer.start_span(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Google",
+            GenAIAttributes.GEN_AI_SYSTEM: "Google",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
 
-    _handle_request(span, event_logger, args, kwargs, llm_model)
+    # Use sync version for non-async wrapper to avoid image processing for now
+    set_model_input_attributes(span, kwargs, llm_model)
+    if should_emit_events():
+        emit_prompt_events(args, event_logger)
+    else:
+        set_input_attributes_sync(span, args)
 
     response = wrapped(*args, **kwargs)
 
@@ -301,10 +320,12 @@ def _wrap(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs):
 class VertexAIInstrumentor(BaseInstrumentor):
     """An instrumentor for VertextAI's client library."""
 
-    def __init__(self, exception_logger=None, use_legacy_attributes=True):
+    def __init__(self, exception_logger=None, use_legacy_attributes=True, upload_base64_image=None):
         super().__init__()
         Config.exception_logger = exception_logger
         Config.use_legacy_attributes = use_legacy_attributes
+        if upload_base64_image:
+            Config.upload_base64_image = upload_base64_image
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
@@ -316,11 +337,11 @@ class VertexAIInstrumentor(BaseInstrumentor):
         event_logger = None
 
         if should_emit_events():
-            event_logger_provider = kwargs.get("event_logger_provider")
-            event_logger = get_event_logger(
+            logger_provider = kwargs.get("logger_provider")
+            event_logger = get_logger(
                 __name__,
                 __version__,
-                event_logger_provider=event_logger_provider,
+                logger_provider=logger_provider,
             )
 
         for wrapped_method in WRAPPED_METHODS:

opentelemetry_instrumentation_vertexai-0.49.6/opentelemetry/instrumentation/vertexai/config.py

@@ -0,0 +1,9 @@
+from typing import Callable
+
+
+class Config:
+    exception_logger = None
+    use_legacy_attributes = True
+    upload_base64_image: Callable[[str, str, str, str], str] = (
+        lambda trace_id, span_id, image_name, base64_string: str
+    )

{opentelemetry_instrumentation_vertexai-0.45.0 → opentelemetry_instrumentation_vertexai-0.49.6}/opentelemetry/instrumentation/vertexai/event_emitter.py

@@ -2,7 +2,7 @@ from dataclasses import asdict
 from enum import Enum
 from typing import Union
 
-from opentelemetry._events import Event
+from opentelemetry._logs import LogRecord
 from opentelemetry.instrumentation.vertexai.event_models import (
     ChoiceEvent,
     MessageEvent,
@@ -140,7 +140,12 @@ def _emit_message_event(event: MessageEvent, event_logger) -> None:
             for tool_call in body["tool_calls"]:
                 tool_call["function"].pop("arguments", None)
 
-    event_logger.emit(Event(name=name, body=body, attributes=EVENT_ATTRIBUTES))
+    log_record = LogRecord(
+        body=body,
+        attributes=EVENT_ATTRIBUTES,
+        event_name=name
+    )
+    event_logger.emit(log_record)
 
 
 def _emit_choice_event(event: ChoiceEvent, event_logger) -> None:
@@ -159,6 +164,10 @@ def _emit_choice_event(event: ChoiceEvent, event_logger) -> None:
             for tool_call in body["tool_calls"]:
                 tool_call["function"].pop("arguments", None)
 
-    event_logger.emit(
-        Event(name="gen_ai.choice", body=body, attributes=EVENT_ATTRIBUTES)
+    log_record = LogRecord(
+        body=body,
+        attributes=EVENT_ATTRIBUTES,
+        event_name="gen_ai.choice"
+
     )
+    event_logger.emit(log_record)

opentelemetry_instrumentation_vertexai-0.49.6/opentelemetry/instrumentation/vertexai/span_utils.py

@@ -0,0 +1,313 @@
+import copy
+import json
+import base64
+import logging
+import asyncio
+import threading
+from opentelemetry.instrumentation.vertexai.utils import dont_throw, should_send_prompts
+from opentelemetry.instrumentation.vertexai.config import Config
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+from opentelemetry.semconv_ai import SpanAttributes
+
+
+logger = logging.getLogger(__name__)
+
+
+def _set_span_attribute(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+def _is_base64_image_part(item):
+    """Check if item is a VertexAI Part object containing image data"""
+    try:
+        # Check if it has the Part attributes we expect
+        if not hasattr(item, 'inline_data') or not hasattr(item, 'mime_type'):
+            return False
+
+        # Check if it's an image mime type and has inline data
+        if item.mime_type and 'image/' in item.mime_type and item.inline_data:
+            # Check if the inline_data has actual data
+            if hasattr(item.inline_data, 'data') and item.inline_data.data:
+                return True
+
+        return False
+    except Exception:
+        return False
+
+
+async def _process_image_part(item, trace_id, span_id, content_index):
+    """Process a VertexAI Part object containing image data"""
+    if not Config.upload_base64_image:
+        return None
+
+    try:
+        # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
+        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+        image_name = f"content_{content_index}.{image_format}"
+
+        # Convert binary data to base64 string for upload
+        binary_data = item.inline_data.data
+        base64_string = base64.b64encode(binary_data).decode('utf-8')
+
+        # Upload the base64 data - convert IDs to strings
+        url = await Config.upload_base64_image(str(trace_id), str(span_id), image_name, base64_string)
+
+        # Return OpenAI-compatible format for consistency across LLM providers
+        return {
+            "type": "image_url",
+            "image_url": {"url": url}
+        }
+    except Exception as e:
+        logger.warning(f"Failed to process image part: {e}")
+        # Return None to skip adding this image to the span
+        return None
+
+
+def run_async(method):
+    """Handle async method in sync context, following OpenAI's battle-tested approach"""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        thread = threading.Thread(target=lambda: asyncio.run(method))
+        thread.start()
+        thread.join()
+    else:
+        asyncio.run(method)
+
+
+def _process_image_part_sync(item, trace_id, span_id, content_index):
+    """Synchronous version of image part processing using OpenAI's pattern"""
+    if not Config.upload_base64_image:
+        return None
+
+    try:
+        # Extract format from mime type (e.g., 'image/jpeg' -> 'jpeg')
+        image_format = item.mime_type.split('/')[1] if item.mime_type else 'unknown'
+        image_name = f"content_{content_index}.{image_format}"
+
+        # Convert binary data to base64 string for upload
+        binary_data = item.inline_data.data
+        base64_string = base64.b64encode(binary_data).decode('utf-8')
+
+        # Use OpenAI's run_async pattern to handle the async upload function
+        url = None
+
+        async def upload_task():
+            nonlocal url
+            url = await Config.upload_base64_image(str(trace_id), str(span_id), image_name, base64_string)
+
+        run_async(upload_task())
+
+        return {
+            "type": "image_url",
+            "image_url": {"url": url}
+        }
+    except Exception as e:
+        logger.warning(f"Failed to process image part sync: {e}")
+        # Return None to skip adding this image to the span
+        return None
+
+
+async def _process_vertexai_argument(argument, span):
+    """Process a single argument for VertexAI, handling different types"""
+    if isinstance(argument, str):
+        # Simple text argument in OpenAI format
+        return [{"type": "text", "text": argument}]
+
+    elif isinstance(argument, list):
+        # List of mixed content (text strings and Part objects) - deep copy and process
+        content_list = copy.deepcopy(argument)
+        processed_items = []
+
+        for item_index, content_item in enumerate(content_list):
+            processed_item = await _process_content_item_vertexai(content_item, span, item_index)
+            if processed_item is not None:
+                processed_items.append(processed_item)
+
+        return processed_items
+
+    else:
+        # Single Part object - convert to OpenAI format
+        processed_item = await _process_content_item_vertexai(argument, span, 0)
+        return [processed_item] if processed_item is not None else []
+
+
+async def _process_content_item_vertexai(content_item, span, item_index):
+    """Process a single content item for VertexAI"""
+    if isinstance(content_item, str):
+        # Convert text to OpenAI format
+        return {"type": "text", "text": content_item}
+
+    elif _is_base64_image_part(content_item):
+        # Process image part
+        return await _process_image_part(
+            content_item, span.context.trace_id, span.context.span_id, item_index
+        )
+
+    elif hasattr(content_item, 'text'):
+        # Text part to OpenAI format
+        return {"type": "text", "text": content_item.text}
+
+    else:
+        # Other types as text
+        return {"type": "text", "text": str(content_item)}
+
+
+def _process_vertexai_argument_sync(argument, span):
+    """Synchronous version of argument processing for VertexAI"""
+    if isinstance(argument, str):
+        # Simple text argument in OpenAI format
+        return [{"type": "text", "text": argument}]
+
+    elif isinstance(argument, list):
+        # List of mixed content (text strings and Part objects) - deep copy and process
+        content_list = copy.deepcopy(argument)
+        processed_items = []
+
+        for item_index, content_item in enumerate(content_list):
+            processed_item = _process_content_item_vertexai_sync(content_item, span, item_index)
+            if processed_item is not None:
+                processed_items.append(processed_item)
+
+        return processed_items
+
+    else:
+        # Single Part object - convert to OpenAI format
+        processed_item = _process_content_item_vertexai_sync(argument, span, 0)
+        return [processed_item] if processed_item is not None else []
+
+
+def _process_content_item_vertexai_sync(content_item, span, item_index):
+    """Synchronous version of content item processing for VertexAI"""
+    if isinstance(content_item, str):
+        # Convert text to OpenAI format
+        return {"type": "text", "text": content_item}
+
+    elif _is_base64_image_part(content_item):
+        # Process image part
+        return _process_image_part_sync(
+            content_item, span.context.trace_id, span.context.span_id, item_index
+        )
+
+    elif hasattr(content_item, 'text'):
+        # Text part to OpenAI format
+        return {"type": "text", "text": content_item.text}
+
+    else:
+        # Other types as text
+        return {"type": "text", "text": str(content_item)}
+
+
+@dont_throw
+async def set_input_attributes(span, args):
+    """Process input arguments, handling both text and image content"""
+    if not span.is_recording():
+        return
+    if should_send_prompts() and args is not None and len(args) > 0:
+        # Process each argument using extracted helper methods
+        for arg_index, argument in enumerate(args):
+            processed_content = await _process_vertexai_argument(argument, span)
+
+            if processed_content:
+                _set_span_attribute(
+                    span,
+                    f"{GenAIAttributes.GEN_AI_PROMPT}.{arg_index}.role",
+                    "user"
+                )
+                _set_span_attribute(
+                    span,
+                    f"{GenAIAttributes.GEN_AI_PROMPT}.{arg_index}.content",
+                    json.dumps(processed_content)
+                )
+
+
+# Sync version with image processing support
+@dont_throw
+def set_input_attributes_sync(span, args):
+    """Synchronous version with image processing support"""
+    if not span.is_recording():
+        return
+    if should_send_prompts() and args is not None and len(args) > 0:
+        # Process each argument using extracted helper methods
+        for arg_index, argument in enumerate(args):
+            processed_content = _process_vertexai_argument_sync(argument, span)
+
+            if processed_content:
+                _set_span_attribute(
+                    span,
+                    f"{GenAIAttributes.GEN_AI_PROMPT}.{arg_index}.role",
+                    "user"
+                )
+                _set_span_attribute(
+                    span,
+                    f"{GenAIAttributes.GEN_AI_PROMPT}.{arg_index}.content",
+                    json.dumps(processed_content)
+                )
+
+
+@dont_throw
+def set_model_input_attributes(span, kwargs, llm_model):
+    if not span.is_recording():
+        return
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, llm_model)
+    _set_span_attribute(
+        span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.user", kwargs.get("prompt")
+    )
+    _set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE, kwargs.get("temperature")
+    )
+    _set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get("max_output_tokens")
+    )
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_TOP_P, kwargs.get("top_p"))
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_TOP_K, kwargs.get("top_k"))
+    _set_span_attribute(
+        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
+    )
+    _set_span_attribute(
+        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
+    )
+
+
+@dont_throw
+def set_response_attributes(span, llm_model, generation_text):
+    if not span.is_recording() or not should_send_prompts():
+        return
+    _set_span_attribute(span, f"{GenAIAttributes.GEN_AI_COMPLETION}.0.role", "assistant")
+    _set_span_attribute(
+        span,
+        f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content",
+        generation_text,
+    )
+
+
+@dont_throw
+def set_model_response_attributes(span, llm_model, token_usage):
+    if not span.is_recording():
+        return
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, llm_model)
+
+    if token_usage:
+        _set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+            token_usage.total_token_count,
+        )
+        _set_span_attribute(
+            span,
+            GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
+            token_usage.candidates_token_count,
+        )
+        _set_span_attribute(
+            span,
+            GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS,
+            token_usage.prompt_token_count,
+        )

opentelemetry_instrumentation_vertexai-0.49.6/opentelemetry/instrumentation/vertexai/version.py

@@ -0,0 +1 @@
+__version__ = "0.49.6"

{opentelemetry_instrumentation_vertexai-0.45.0 → opentelemetry_instrumentation_vertexai-0.49.6}/pyproject.toml

@@ -8,7 +8,7 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-vertexai"
-version = "0.45.0"
+version = "0.49.6"
 description = "OpenTelemetry Vertex AI instrumentation"
 authors = [
   "Gal Kleinman <gal@traceloop.com>",
@@ -25,10 +25,10 @@ include = "opentelemetry/instrumentation/vertexai"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4"
-opentelemetry-api = "^1.28.0"
-opentelemetry-instrumentation = ">=0.50b0"
-opentelemetry-semantic-conventions = ">=0.50b0"
-opentelemetry-semantic-conventions-ai = "0.4.11"
+opentelemetry-api = "^1.38.0"
+opentelemetry-instrumentation = ">=0.59b0"
+opentelemetry-semantic-conventions = ">=0.59b0"
+opentelemetry-semantic-conventions-ai = "^0.4.13"
 
 [tool.poetry.group.dev.dependencies]
 autopep8 = "^2.2.0"
@@ -41,7 +41,7 @@ pytest = "^8.2.2"
 pytest-sugar = "1.0.0"
 vcrpy = "^6.0.1"
 pytest-recording = "^0.13.1"
-opentelemetry-sdk = "^1.27.0"
+opentelemetry-sdk = "^1.38.0"
 google-cloud-aiplatform = "^1.54.0"
 
 [build-system]

opentelemetry_instrumentation_vertexai-0.45.0/opentelemetry/instrumentation/vertexai/config.py

@@ -1,3 +0,0 @@
-class Config:
-    exception_logger = None
-    use_legacy_attributes = True

opentelemetry_instrumentation_vertexai-0.45.0/opentelemetry/instrumentation/vertexai/span_utils.py

@@ -1,89 +0,0 @@
-from opentelemetry.instrumentation.vertexai.utils import dont_throw, should_send_prompts
-from opentelemetry.semconv_ai import SpanAttributes
-
-
-def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
-    return
-
-
-@dont_throw
-def set_input_attributes(span, args):
-    if not span.is_recording():
-        return
-    if should_send_prompts() and args is not None and len(args) > 0:
-        prompt = ""
-        for arg in args:
-            if isinstance(arg, str):
-                prompt = f"{prompt}{arg}\n"
-            elif isinstance(arg, list):
-                for subarg in arg:
-                    prompt = f"{prompt}{subarg}\n"
-
-        _set_span_attribute(
-            span,
-            f"{SpanAttributes.LLM_PROMPTS}.0.user",
-            prompt,
-        )
-
-
-@dont_throw
-def set_model_input_attributes(span, kwargs, llm_model):
-    if not span.is_recording():
-        return
-    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, llm_model)
-    _set_span_attribute(
-        span, f"{SpanAttributes.LLM_PROMPTS}.0.user", kwargs.get("prompt")
-    )
-    _set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_TEMPERATURE, kwargs.get("temperature")
-    )
-    _set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_output_tokens")
-    )
-    _set_span_attribute(span, SpanAttributes.LLM_REQUEST_TOP_P, kwargs.get("top_p"))
-    _set_span_attribute(span, SpanAttributes.LLM_TOP_K, kwargs.get("top_k"))
-    _set_span_attribute(
-        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
-    )
-    _set_span_attribute(
-        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
-    )
-
-
-@dont_throw
-def set_response_attributes(span, llm_model, generation_text):
-    if not span.is_recording() or not should_send_prompts():
-        return
-    _set_span_attribute(span, f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant")
-    _set_span_attribute(
-        span,
-        f"{SpanAttributes.LLM_COMPLETIONS}.0.content",
-        generation_text,
-    )
-
-
-@dont_throw
-def set_model_response_attributes(span, llm_model, token_usage):
-    if not span.is_recording():
-        return
-    _set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, llm_model)
-
-    if token_usage:
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
-            token_usage.total_token_count,
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-            token_usage.candidates_token_count,
-        )
-        _set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
-            token_usage.prompt_token_count,
-        )

opentelemetry_instrumentation_vertexai-0.45.0/opentelemetry/instrumentation/vertexai/version.py

@@ -1 +0,0 @@
-__version__ = "0.45.0"