opentelemetry-instrumentation-vertexai 0.40.13__tar.gz → 0.41.0__tar.gz

{opentelemetry_instrumentation_vertexai-0.40.13 → opentelemetry_instrumentation_vertexai-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation-vertexai
-Version: 0.40.13
+Version: 0.41.0
 Summary: OpenTelemetry Vertex AI instrumentation
 License: Apache-2.0
 Author: Gal Kleinman
@@ -17,7 +17,7 @@ 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.9)
+Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.10)
 Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-vertexai
 Description-Content-Type: text/markdown
 

{opentelemetry_instrumentation_vertexai-0.40.13 → opentelemetry_instrumentation_vertexai-0.41.0}/opentelemetry/instrumentation/vertexai/__init__.py

@@ -1,26 +1,34 @@
 """OpenTelemetry Vertex AI instrumentation"""
 
 import logging
-import os
 import types
 from typing import Collection
-from opentelemetry.instrumentation.vertexai.config import Config
-from opentelemetry.instrumentation.vertexai.utils import dont_throw
-from wrapt import wrap_function_wrapper
 
 from opentelemetry import context as context_api
-from opentelemetry.trace import get_tracer, SpanKind
-from opentelemetry.trace.status import Status, StatusCode
-
+from opentelemetry._events import get_event_logger
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
-
+from opentelemetry.instrumentation.vertexai.config import Config
+from opentelemetry.instrumentation.vertexai.event_emitter import (
+    emit_prompt_events,
+    emit_response_events,
+)
+from opentelemetry.instrumentation.vertexai.span_utils import (
+    set_input_attributes,
+    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_ai import (
     SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
-    SpanAttributes,
     LLMRequestTypeValues,
+    SpanAttributes,
 )
-from opentelemetry.instrumentation.vertexai.version import __version__
+from opentelemetry.trace import SpanKind, get_tracer
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import wrap_function_wrapper
 
 logger = logging.getLogger(__name__)
 
@@ -114,12 +122,6 @@ WRAPPED_METHODS = [
 ]
 
 
-def should_send_prompts():
-    return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
-    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
-
-
 def is_streaming_response(response):
     return isinstance(response, types.GeneratorType)
 
@@ -128,81 +130,18 @@ def is_async_streaming_response(response):
     return isinstance(response, types.AsyncGeneratorType)
 
 
-def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
-    return
-
-
-def _set_input_attributes(span, args, kwargs, llm_model):
-    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,
-        )
-
-    _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")
-    )
-
-    return
-
-
 @dont_throw
-def _set_response_attributes(span, llm_model, generation_text, token_usage):
-    _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,
-        )
-
-    _set_span_attribute(span, f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant")
-    _set_span_attribute(
-        span,
-        f"{SpanAttributes.LLM_COMPLETIONS}.0.content",
-        generation_text,
-    )
+def handle_streaming_response(span, event_logger, llm_model, response, token_usage):
+    set_model_response_attributes(span, llm_model, token_usage)
+    if should_emit_events():
+        emit_response_events(response, event_logger)
+    else:
+        set_response_attributes(span, llm_model, response)
+    if span.is_recording():
+        span.set_status(Status(StatusCode.OK))
 
 
-def _build_from_streaming_response(span, response, llm_model):
+def _build_from_streaming_response(span, event_logger, response, llm_model):
     complete_response = ""
     token_usage = None
     for item in response:
@@ -213,13 +152,15 @@ def _build_from_streaming_response(span, response, llm_model):
 
         yield item_to_yield
 
-    _set_response_attributes(span, llm_model, complete_response, token_usage)
+    handle_streaming_response(
+        span, event_logger, llm_model, complete_response, token_usage
+    )
 
     span.set_status(Status(StatusCode.OK))
     span.end()
 
 
-async def _abuild_from_streaming_response(span, response, llm_model):
+async def _abuild_from_streaming_response(span, event_logger, response, llm_model):
     complete_response = ""
     token_usage = None
     async for item in response:
@@ -230,34 +171,39 @@ async def _abuild_from_streaming_response(span, response, llm_model):
 
         yield item_to_yield
 
-    _set_response_attributes(span, llm_model, complete_response, token_usage)
+    handle_streaming_response(span, event_logger, llm_model, response, token_usage)
 
     span.set_status(Status(StatusCode.OK))
     span.end()
 
 
 @dont_throw
-def _handle_request(span, args, kwargs, llm_model):
-    if span.is_recording():
-        _set_input_attributes(span, args, kwargs, llm_model)
-
-
-@dont_throw
-def _handle_response(span, response, llm_model):
-    if span.is_recording():
-        _set_response_attributes(
-            span, llm_model, response.candidates[0].text, response.usage_metadata
+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)
+
+
+def _handle_response(span, event_logger, response, llm_model):
+    set_model_response_attributes(span, llm_model, response.usage_metadata)
+    if should_emit_events():
+        emit_response_events(response, event_logger)
+    else:
+        set_response_attributes(
+            span, llm_model, response.candidates[0].text if response.candidates else ""
         )
-
+    if span.is_recording():
         span.set_status(Status(StatusCode.OK))
 
 
 def _with_tracer_wrapper(func):
     """Helper for providing tracer for wrapper functions."""
 
-    def _with_tracer(tracer, to_wrap):
+    def _with_tracer(tracer, event_logger, to_wrap):
         def wrapper(wrapped, instance, args, kwargs):
-            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
+            return func(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs)
 
         return wrapper
 
@@ -265,7 +211,7 @@ def _with_tracer_wrapper(func):
 
 
 @_with_tracer_wrapper
-async def _awrap(tracer, to_wrap, wrapped, instance, args, kwargs):
+async def _awrap(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs):
     """Instruments and calls every function defined in TO_WRAP."""
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
         SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
@@ -283,29 +229,33 @@ async def _awrap(tracer, to_wrap, wrapped, instance, args, kwargs):
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "VertexAI",
+            SpanAttributes.LLM_SYSTEM: "Google",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
 
-    _handle_request(span, args, kwargs, llm_model)
+    _handle_request(span, event_logger, args, kwargs, llm_model)
 
     response = await wrapped(*args, **kwargs)
 
     if response:
         if is_streaming_response(response):
-            return _build_from_streaming_response(span, response, llm_model)
+            return _build_from_streaming_response(
+                span, event_logger, response, llm_model
+            )
         elif is_async_streaming_response(response):
-            return _abuild_from_streaming_response(span, response, llm_model)
+            return _abuild_from_streaming_response(
+                span, event_logger, response, llm_model
+            )
         else:
-            _handle_response(span, response, llm_model)
+            _handle_response(span, event_logger, response, llm_model)
 
     span.end()
     return response
 
 
 @_with_tracer_wrapper
-def _wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
+def _wrap(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs):
     """Instruments and calls every function defined in TO_WRAP."""
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) or context_api.get_value(
         SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY
@@ -323,22 +273,26 @@ def _wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "VertexAI",
+            SpanAttributes.LLM_SYSTEM: "Google",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
 
-    _handle_request(span, args, kwargs, llm_model)
+    _handle_request(span, event_logger, args, kwargs, llm_model)
 
     response = wrapped(*args, **kwargs)
 
     if response:
         if is_streaming_response(response):
-            return _build_from_streaming_response(span, response, llm_model)
+            return _build_from_streaming_response(
+                span, event_logger, response, llm_model
+            )
         elif is_async_streaming_response(response):
-            return _abuild_from_streaming_response(span, response, llm_model)
+            return _abuild_from_streaming_response(
+                span, event_logger, response, llm_model
+            )
         else:
-            _handle_response(span, response, llm_model)
+            _handle_response(span, event_logger, response, llm_model)
 
     span.end()
     return response
@@ -347,9 +301,10 @@ def _wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
 class VertexAIInstrumentor(BaseInstrumentor):
     """An instrumentor for VertextAI's client library."""
 
-    def __init__(self, exception_logger=None):
+    def __init__(self, exception_logger=None, use_legacy_attributes=True):
         super().__init__()
         Config.exception_logger = exception_logger
+        Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
@@ -357,6 +312,17 @@ class VertexAIInstrumentor(BaseInstrumentor):
     def _instrument(self, **kwargs):
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        event_logger = None
+
+        if should_emit_events():
+            event_logger_provider = kwargs.get("event_logger_provider")
+            event_logger = get_event_logger(
+                __name__,
+                __version__,
+                event_logger_provider=event_logger_provider,
+            )
+
         for wrapped_method in WRAPPED_METHODS:
             wrap_package = wrapped_method.get("package")
             wrap_object = wrapped_method.get("object")
@@ -366,9 +332,9 @@ class VertexAIInstrumentor(BaseInstrumentor):
                 wrap_package,
                 f"{wrap_object}.{wrap_method}",
                 (
-                    _awrap(tracer, wrapped_method)
+                    _awrap(tracer, event_logger, wrapped_method)
                     if wrapped_method.get("is_async")
-                    else _wrap(tracer, wrapped_method)
+                    else _wrap(tracer, event_logger, wrapped_method)
                 ),
             )
 

{opentelemetry_instrumentation_vertexai-0.40.13 → opentelemetry_instrumentation_vertexai-0.41.0}/opentelemetry/instrumentation/vertexai/config.py

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

opentelemetry_instrumentation_vertexai-0.41.0/opentelemetry/instrumentation/vertexai/event_emitter.py

@@ -0,0 +1,164 @@
+from dataclasses import asdict
+from enum import Enum
+from typing import Union
+
+from opentelemetry._events import Event
+from opentelemetry.instrumentation.vertexai.event_models import (
+    ChoiceEvent,
+    MessageEvent,
+)
+from opentelemetry.instrumentation.vertexai.utils import (
+    dont_throw,
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+from vertexai.generative_models import GenerationResponse
+
+
+class Roles(Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+VALID_MESSAGE_ROLES = {role.value for role in Roles}
+"""The valid roles for naming the message event."""
+
+EVENT_ATTRIBUTES = {
+    GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.VERTEX_AI.value
+}
+"""The attributes to be used for the event."""
+
+
+def _parse_vertex_finish_reason(reason):
+    if reason is None:
+        return "unknown"
+
+    finish_reason_map = {
+        0: "unspecified",
+        1: "stop",
+        2: "max_tokens",
+        3: "safety",
+        4: "recitation",
+        5: "other",
+        6: "blocklist",
+        7: "prohibited_content",
+        8: "spii",
+        9: "malformed_function_call",
+    }
+
+    if hasattr(reason, "value"):
+        reason_value = reason.value
+    else:
+        reason_value = reason
+
+    return finish_reason_map.get(reason_value, "unknown")
+
+
+@dont_throw
+def emit_prompt_events(args, event_logger):
+    prompt = ""
+    if args is not None and len(args) > 0:
+        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"
+    emit_event(MessageEvent(content=prompt, role=Roles.USER.value), event_logger)
+
+
+def emit_response_events(response, event_logger):
+    if isinstance(response, str):
+        emit_event(
+            ChoiceEvent(
+                index=0,
+                message={"content": response, "role": Roles.ASSISTANT.value},
+                finish_reason="unknown",
+            ),
+            event_logger,
+        )
+    elif isinstance(response, GenerationResponse):
+        for candidate in response.candidates:
+            emit_event(
+                ChoiceEvent(
+                    index=candidate.index,
+                    message={
+                        "content": candidate.text,
+                        "role": Roles.ASSISTANT.value,
+                    },
+                    finish_reason=_parse_vertex_finish_reason(candidate.finish_reason),
+                ),
+                event_logger,
+            )
+
+
+def emit_event(event: Union[MessageEvent, ChoiceEvent], event_logger) -> None:
+    """
+    Emit an event to the OpenTelemetry SDK.
+
+    Args:
+        event: The event to emit.
+    """
+    if not should_emit_events() or event_logger is None:
+        return
+
+    if isinstance(event, MessageEvent):
+        _emit_message_event(event, event_logger)
+    elif isinstance(event, ChoiceEvent):
+        _emit_choice_event(event, event_logger)
+    else:
+        raise TypeError("Unsupported event type")
+
+
+def _emit_message_event(event: MessageEvent, event_logger) -> None:
+    body = asdict(event)
+
+    if event.role in VALID_MESSAGE_ROLES:
+        name = "gen_ai.{}.message".format(event.role)
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to the "role" in the message name. So, remove the role from the body if
+        # it is the same as the in the event name.
+        body.pop("role", None)
+    else:
+        name = "gen_ai.user.message"
+
+    # According to the semantic conventions, only the assistant role has tool call
+    if event.role != Roles.ASSISTANT.value and event.tool_calls is not None:
+        del body["tool_calls"]
+    elif event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        del body["content"]
+        if body.get("tool_calls") is not 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))
+
+
+def _emit_choice_event(event: ChoiceEvent, event_logger) -> None:
+    body = asdict(event)
+    if event.message["role"] == Roles.ASSISTANT.value:
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to "assistant", so remove the role from the body if it is "assistant".
+        body["message"].pop("role", None)
+
+    if event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        body["message"].pop("content", None)
+        if body.get("tool_calls") is not 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)
+    )

opentelemetry_instrumentation_vertexai-0.41.0/opentelemetry/instrumentation/vertexai/event_models.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Any, List, Literal, Optional, TypedDict
+
+
+class _FunctionToolCall(TypedDict):
+    function_name: str
+    arguments: Optional[dict[str, Any]]
+
+
+class ToolCall(TypedDict):
+    """Represents a tool call in the AI model."""
+
+    id: str
+    function: _FunctionToolCall
+    type: Literal["function"]
+
+
+class CompletionMessage(TypedDict):
+    """Represents a message in the AI model."""
+
+    content: Any
+    role: str = "assistant"
+
+
+@dataclass
+class MessageEvent:
+    """Represents an input event for the AI model."""
+
+    content: Any
+    role: str = "user"
+    tool_calls: Optional[List[ToolCall]] = None
+
+
+@dataclass
+class ChoiceEvent:
+    """Represents a completion event for the AI model."""
+
+    index: int
+    message: CompletionMessage
+    finish_reason: str = "unknown"
+    tool_calls: Optional[List[ToolCall]] = None

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

@@ -0,0 +1,89 @@
+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.40.13 → opentelemetry_instrumentation_vertexai-0.41.0}/opentelemetry/instrumentation/vertexai/utils.py

@@ -1,8 +1,18 @@
 import logging
+import os
 import traceback
 
+from opentelemetry import context as context_api
 from opentelemetry.instrumentation.vertexai.config import Config
 
+TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+
+
+def should_send_prompts():
+    return (
+        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
 
 def dont_throw(func):
     """
@@ -27,3 +37,7 @@ def dont_throw(func):
                 Config.exception_logger(e)
 
     return wrapper
+
+
+def should_emit_events():
+    return not Config.use_legacy_attributes

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

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

{opentelemetry_instrumentation_vertexai-0.40.13 → opentelemetry_instrumentation_vertexai-0.41.0}/pyproject.toml

@@ -8,7 +8,7 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-vertexai"
-version = "0.40.13"
+version = "0.41.0"
 description = "OpenTelemetry Vertex AI instrumentation"
 authors = [
   "Gal Kleinman <gal@traceloop.com>",
@@ -28,7 +28,7 @@ python = ">=3.9,<4"
 opentelemetry-api = "^1.28.0"
 opentelemetry-instrumentation = ">=0.50b0"
 opentelemetry-semantic-conventions = ">=0.50b0"
-opentelemetry-semantic-conventions-ai = "0.4.9"
+opentelemetry-semantic-conventions-ai = "0.4.10"
 
 [tool.poetry.group.dev.dependencies]
 autopep8 = "^2.2.0"

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

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