opentelemetry-instrumentation-groq 0.40.2__py3-none-any.whl → 0.48.0__py3-none-any.whl

opentelemetry/instrumentation/groq/__init__.py

@@ -1,44 +1,54 @@
 """OpenTelemetry Groq instrumentation"""
 
-import json
 import logging
 import os
 import time
-from typing import Callable, Collection
+from typing import Callable, Collection, Union
 
-from groq._streaming import AsyncStream, Stream
 from opentelemetry import context as context_api
+from opentelemetry._events import EventLogger, get_event_logger
 from opentelemetry.instrumentation.groq.config import Config
+from opentelemetry.instrumentation.groq.event_emitter import (
+    emit_choice_events,
+    emit_message_events,
+    emit_streaming_response_events,
+)
+from opentelemetry.instrumentation.groq.span_utils import (
+    set_input_attributes,
+    set_model_input_attributes,
+    set_model_response_attributes,
+    set_model_streaming_response_attributes,
+    set_response_attributes,
+    set_streaming_response_attributes,
+)
 from opentelemetry.instrumentation.groq.utils import (
-    dont_throw,
     error_metrics_attributes,
-    model_as_dict,
-    set_span_attribute,
     shared_metrics_attributes,
-    should_send_prompts,
+    should_emit_events,
 )
 from opentelemetry.instrumentation.groq.version import __version__
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
 from opentelemetry.metrics import Counter, Histogram, Meter, get_meter
-from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
-    GEN_AI_RESPONSE_ID,
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
 )
 from opentelemetry.semconv_ai import (
     SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
     LLMRequestTypeValues,
-    SpanAttributes,
     Meters,
+    SpanAttributes,
 )
 from opentelemetry.trace import SpanKind, Tracer, get_tracer
 from opentelemetry.trace.status import Status, StatusCode
 from wrapt import wrap_function_wrapper
 
+from groq._streaming import AsyncStream, Stream
+
 logger = logging.getLogger(__name__)
 
 _instruments = ("groq >= 0.9.0",)
 
-CONTENT_FILTER_KEY = "content_filter_results"
 
 WRAPPED_METHODS = [
     {
@@ -62,187 +72,6 @@ def is_streaming_response(response):
     return isinstance(response, Stream) or isinstance(response, AsyncStream)
 
 
-def _dump_content(content):
-    if isinstance(content, str):
-        return content
-    json_serializable = []
-    for item in content:
-        if item.get("type") == "text":
-            json_serializable.append({"type": "text", "text": item.get("text")})
-        elif item.get("type") == "image":
-            json_serializable.append(
-                {
-                    "type": "image",
-                    "source": {
-                        "type": item.get("source").get("type"),
-                        "media_type": item.get("source").get("media_type"),
-                        "data": str(item.get("source").get("data")),
-                    },
-                }
-            )
-    return json.dumps(json_serializable)
-
-
-@dont_throw
-def _set_input_attributes(span, kwargs):
-    set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, kwargs.get("model"))
-    set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_MAX_TOKENS, kwargs.get("max_tokens_to_sample")
-    )
-    set_span_attribute(
-        span, SpanAttributes.LLM_REQUEST_TEMPERATURE, kwargs.get("temperature")
-    )
-    set_span_attribute(span, SpanAttributes.LLM_REQUEST_TOP_P, kwargs.get("top_p"))
-    set_span_attribute(
-        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
-    )
-    set_span_attribute(
-        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
-    )
-    set_span_attribute(
-        span, SpanAttributes.LLM_IS_STREAMING, kwargs.get("stream") or False
-    )
-
-    if should_send_prompts():
-        if kwargs.get("prompt") is not None:
-            set_span_attribute(
-                span, f"{SpanAttributes.LLM_PROMPTS}.0.user", kwargs.get("prompt")
-            )
-
-        elif kwargs.get("messages") is not None:
-            for i, message in enumerate(kwargs.get("messages")):
-                set_span_attribute(
-                    span,
-                    f"{SpanAttributes.LLM_PROMPTS}.{i}.content",
-                    _dump_content(message.get("content")),
-                )
-                set_span_attribute(
-                    span, f"{SpanAttributes.LLM_PROMPTS}.{i}.role", message.get("role")
-                )
-
-
-def _set_completions(span, choices):
-    if choices is None:
-        return
-
-    for choice in choices:
-        index = choice.get("index")
-        prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
-        set_span_attribute(span, f"{prefix}.finish_reason", choice.get("finish_reason"))
-
-        if choice.get("content_filter_results"):
-            set_span_attribute(
-                span,
-                f"{prefix}.{CONTENT_FILTER_KEY}",
-                json.dumps(choice.get("content_filter_results")),
-            )
-
-        if choice.get("finish_reason") == "content_filter":
-            set_span_attribute(span, f"{prefix}.role", "assistant")
-            set_span_attribute(span, f"{prefix}.content", "FILTERED")
-
-            return
-
-        message = choice.get("message")
-        if not message:
-            return
-
-        set_span_attribute(span, f"{prefix}.role", message.get("role"))
-        set_span_attribute(span, f"{prefix}.content", message.get("content"))
-
-        function_call = message.get("function_call")
-        if function_call:
-            set_span_attribute(
-                span, f"{prefix}.tool_calls.0.name", function_call.get("name")
-            )
-            set_span_attribute(
-                span,
-                f"{prefix}.tool_calls.0.arguments",
-                function_call.get("arguments"),
-            )
-
-        tool_calls = message.get("tool_calls")
-        if tool_calls:
-            for i, tool_call in enumerate(tool_calls):
-                function = tool_call.get("function")
-                set_span_attribute(
-                    span,
-                    f"{prefix}.tool_calls.{i}.id",
-                    tool_call.get("id"),
-                )
-                set_span_attribute(
-                    span,
-                    f"{prefix}.tool_calls.{i}.name",
-                    function.get("name"),
-                )
-                set_span_attribute(
-                    span,
-                    f"{prefix}.tool_calls.{i}.arguments",
-                    function.get("arguments"),
-                )
-
-
-@dont_throw
-def _set_response_attributes(span, response, token_histogram):
-    response = model_as_dict(response)
-    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
-    set_span_attribute(span, GEN_AI_RESPONSE_ID, response.get("id"))
-
-    usage = response.get("usage") or {}
-    prompt_tokens = usage.get("prompt_tokens")
-    completion_tokens = usage.get("completion_tokens")
-    if usage:
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.get("total_tokens")
-        )
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, completion_tokens
-        )
-        set_span_attribute(span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, prompt_tokens)
-
-    if (
-        isinstance(prompt_tokens, int)
-        and prompt_tokens >= 0
-        and token_histogram is not None
-    ):
-        token_histogram.record(
-            prompt_tokens,
-            attributes={
-                SpanAttributes.LLM_TOKEN_TYPE: "input",
-                SpanAttributes.LLM_RESPONSE_MODEL: response.get("model"),
-            },
-        )
-
-    if (
-        isinstance(completion_tokens, int)
-        and completion_tokens >= 0
-        and token_histogram is not None
-    ):
-        token_histogram.record(
-            completion_tokens,
-            attributes={
-                SpanAttributes.LLM_TOKEN_TYPE: "output",
-                SpanAttributes.LLM_RESPONSE_MODEL: response.get("model"),
-            },
-        )
-
-    choices = response.get("choices")
-    if should_send_prompts() and choices:
-        _set_completions(span, choices)
-
-
-def _with_tracer_wrapper(func):
-    """Helper for providing tracer for wrapper functions."""
-
-    def _with_tracer(tracer, to_wrap):
-        def wrapper(wrapped, instance, args, kwargs):
-            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
-
-        return wrapper
-
-    return _with_tracer
-
-
 def _with_chat_telemetry_wrapper(func):
     """Helper for providing tracer for wrapper functions. Includes metric collectors."""
 
@@ -251,6 +80,7 @@ def _with_chat_telemetry_wrapper(func):
         token_histogram,
         choice_counter,
         duration_histogram,
+        event_logger,
         to_wrap,
     ):
         def wrapper(wrapped, instance, args, kwargs):
@@ -259,6 +89,7 @@ def _with_chat_telemetry_wrapper(func):
                 token_histogram,
                 choice_counter,
                 duration_histogram,
+                event_logger,
                 to_wrap,
                 wrapped,
                 instance,
@@ -310,32 +141,19 @@ def _process_streaming_chunk(chunk):
     return content, finish_reason, usage
 
 
-def _set_streaming_response_attributes(
-    span, accumulated_content, finish_reason=None, usage=None
+def _handle_streaming_response(
+    span, accumulated_content, finish_reason, usage, event_logger
 ):
-    """Set span attributes for accumulated streaming response."""
-    if not span.is_recording():
-        return
-
-    prefix = f"{SpanAttributes.LLM_COMPLETIONS}.0"
-    set_span_attribute(span, f"{prefix}.role", "assistant")
-    set_span_attribute(span, f"{prefix}.content", accumulated_content)
-    if finish_reason:
-        set_span_attribute(span, f"{prefix}.finish_reason", finish_reason)
-
-    if usage:
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens
-        )
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens
-        )
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens
+    set_model_streaming_response_attributes(span, usage)
+    if should_emit_events() and event_logger:
+        emit_streaming_response_events(accumulated_content, finish_reason, event_logger)
+    else:
+        set_streaming_response_attributes(
+            span, accumulated_content, finish_reason, usage
         )
 
 
-def _create_stream_processor(response, span):
+def _create_stream_processor(response, span, event_logger):
     """Create a generator that processes a stream while collecting telemetry."""
     accumulated_content = ""
     finish_reason = None
@@ -351,15 +169,17 @@ def _create_stream_processor(response, span):
             usage = chunk_usage
         yield chunk
 
+    _handle_streaming_response(
+        span, accumulated_content, finish_reason, usage, event_logger
+    )
+
     if span.is_recording():
-        _set_streaming_response_attributes(
-            span, accumulated_content, finish_reason, usage
-        )
         span.set_status(Status(StatusCode.OK))
+
     span.end()
 
 
-async def _create_async_stream_processor(response, span):
+async def _create_async_stream_processor(response, span, event_logger):
     """Create an async generator that processes a stream while collecting telemetry."""
     accumulated_content = ""
     finish_reason = None
@@ -375,20 +195,39 @@ async def _create_async_stream_processor(response, span):
             usage = chunk_usage
         yield chunk
 
+    _handle_streaming_response(
+        span, accumulated_content, finish_reason, usage, event_logger
+    )
+
     if span.is_recording():
-        _set_streaming_response_attributes(
-            span, accumulated_content, finish_reason, usage
-        )
         span.set_status(Status(StatusCode.OK))
+
     span.end()
 
 
+def _handle_input(span, kwargs, event_logger):
+    set_model_input_attributes(span, kwargs)
+    if should_emit_events() and event_logger:
+        emit_message_events(kwargs, event_logger)
+    else:
+        set_input_attributes(span, kwargs)
+
+
+def _handle_response(span, response, token_histogram, event_logger):
+    set_model_response_attributes(span, response, token_histogram)
+    if should_emit_events() and event_logger:
+        emit_choice_events(response, event_logger)
+    else:
+        set_response_attributes(span, response)
+
+
 @_with_chat_telemetry_wrapper
 def _wrap(
     tracer: Tracer,
     token_histogram: Histogram,
     choice_counter: Counter,
     duration_histogram: Histogram,
+    event_logger: Union[EventLogger, None],
     to_wrap,
     wrapped,
     instance,
@@ -406,13 +245,12 @@ def _wrap(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Groq",
+            GenAIAttributes.GEN_AI_SYSTEM: "groq",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
 
-    if span.is_recording():
-        _set_input_attributes(span, kwargs)
+    _handle_input(span, kwargs, event_logger)
 
     start_time = time.time()
     try:
@@ -431,7 +269,7 @@ def _wrap(
 
     if is_streaming_response(response):
         try:
-            return _create_stream_processor(response, span)
+            return _create_stream_processor(response, span, event_logger)
         except Exception as ex:
             logger.warning(
                 "Failed to process streaming response for groq span, error: %s",
@@ -451,14 +289,14 @@ def _wrap(
                     attributes=metric_attributes,
                 )
 
-            if span.is_recording():
-                _set_response_attributes(span, response, token_histogram)
+            _handle_response(span, response, token_histogram, event_logger)
 
         except Exception as ex:  # pylint: disable=broad-except
             logger.warning(
                 "Failed to set response attributes for groq span, error: %s",
                 str(ex),
             )
+
         if span.is_recording():
             span.set_status(Status(StatusCode.OK))
     span.end()
@@ -471,6 +309,7 @@ async def _awrap(
     token_histogram: Histogram,
     choice_counter: Counter,
     duration_histogram: Histogram,
+    event_logger: Union[EventLogger, None],
     to_wrap,
     wrapped,
     instance,
@@ -488,20 +327,15 @@ async def _awrap(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Groq",
+            GenAIAttributes.GEN_AI_SYSTEM: "groq",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
     )
-    try:
-        if span.is_recording():
-            _set_input_attributes(span, kwargs)
 
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set input attributes for groq span, error: %s", str(ex)
-        )
+    _handle_input(span, kwargs, event_logger)
 
     start_time = time.time()
+
     try:
         response = await wrapped(*args, **kwargs)
     except Exception as e:  # pylint: disable=broad-except
@@ -518,7 +352,7 @@ async def _awrap(
 
     if is_streaming_response(response):
         try:
-            return await _create_async_stream_processor(response, span)
+            return await _create_async_stream_processor(response, span, event_logger)
         except Exception as ex:
             logger.warning(
                 "Failed to process streaming response for groq span, error: %s",
@@ -537,8 +371,7 @@ async def _awrap(
                 attributes=metric_attributes,
             )
 
-        if span.is_recording():
-            _set_response_attributes(span, response, token_histogram)
+        _handle_response(span, response, token_histogram, event_logger)
 
         if span.is_recording():
             span.set_status(Status(StatusCode.OK))
@@ -555,14 +388,14 @@ class GroqInstrumentor(BaseInstrumentor):
 
     def __init__(
         self,
-        enrich_token_usage: bool = False,
         exception_logger=None,
+        use_legacy_attributes: bool = True,
         get_common_metrics_attributes: Callable[[], dict] = lambda: {},
     ):
         super().__init__()
         Config.exception_logger = exception_logger
-        Config.enrich_token_usage = enrich_token_usage
         Config.get_common_metrics_attributes = get_common_metrics_attributes
+        Config.use_legacy_attributes = use_legacy_attributes
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
@@ -588,6 +421,13 @@ class GroqInstrumentor(BaseInstrumentor):
                 duration_histogram,
             ) = (None, None, None)
 
+        event_logger = None
+        if not Config.use_legacy_attributes:
+            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")
@@ -602,6 +442,7 @@ class GroqInstrumentor(BaseInstrumentor):
                         token_histogram,
                         choice_counter,
                         duration_histogram,
+                        event_logger,
                         wrapped_method,
                     ),
                 )
@@ -621,6 +462,7 @@ class GroqInstrumentor(BaseInstrumentor):
                         token_histogram,
                         choice_counter,
                         duration_histogram,
+                        event_logger,
                         wrapped_method,
                     ),
                 )
@@ -636,8 +478,9 @@ class GroqInstrumentor(BaseInstrumentor):
                 wrapped_method.get("method"),
             )
         for wrapped_method in WRAPPED_AMETHODS:
+            wrap_package = wrapped_method.get("package")
             wrap_object = wrapped_method.get("object")
             unwrap(
-                f"groq.resources.completions.{wrap_object}",
+                f"{wrap_package}.{wrap_object}",
                 wrapped_method.get("method"),
             )

opentelemetry/instrumentation/groq/config.py

@@ -2,6 +2,6 @@ from typing import Callable
 
 
 class Config:
-    enrich_token_usage = False
     exception_logger = None
     get_common_metrics_attributes: Callable[[], dict] = lambda: {}
+    use_legacy_attributes = True

opentelemetry/instrumentation/groq/event_emitter.py

@@ -0,0 +1,143 @@
+from dataclasses import asdict
+from enum import Enum
+from typing import Union
+
+from opentelemetry._events import Event, EventLogger
+from opentelemetry.instrumentation.groq.event_models import ChoiceEvent, MessageEvent
+from opentelemetry.instrumentation.groq.utils import (
+    dont_throw,
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+from groq.types.chat.chat_completion import ChatCompletion
+
+
+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 = {
+    # Should be GenAIAttributes.GenAiSystemValues.GROQ.value but it's not defined in the opentelemetry-semconv package
+    GenAIAttributes.GEN_AI_SYSTEM: "groq"
+}
+"""The attributes to be used for the event."""
+
+
+@dont_throw
+def emit_message_events(kwargs: dict, event_logger):
+    for message in kwargs.get("messages", []):
+        emit_event(
+            MessageEvent(
+                content=message.get("content"), role=message.get("role", "unknown")
+            ),
+            event_logger=event_logger,
+        )
+
+
+@dont_throw
+def emit_choice_events(response: ChatCompletion, event_logger):
+    for choice in response.choices:
+        emit_event(
+            ChoiceEvent(
+                index=choice.index,
+                message={
+                    "content": choice.message.content,
+                    "role": choice.message.role or "unknown",
+                },
+                finish_reason=choice.finish_reason,
+            ),
+            event_logger=event_logger,
+        )
+
+
+@dont_throw
+def emit_streaming_response_events(
+    accumulated_content: str, finish_reason: Union[str, None], event_logger
+):
+    """Emit events for streaming response."""
+    emit_event(
+        ChoiceEvent(
+            index=0,
+            message={"content": accumulated_content, "role": "assistant"},
+            finish_reason=finish_reason or "unknown",
+        ),
+        event_logger,
+    )
+
+
+def emit_event(
+    event: Union[MessageEvent, ChoiceEvent], event_logger: Union[EventLogger, None]
+) -> 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: EventLogger) -> 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: EventLogger) -> 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/groq/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/groq/span_utils.py

@@ -0,0 +1,233 @@
+import json
+
+from opentelemetry.instrumentation.groq.utils import (
+    dont_throw,
+    model_as_dict,
+    set_span_attribute,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
+    GEN_AI_RESPONSE_ID,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+from opentelemetry.semconv_ai import (
+    SpanAttributes,
+)
+
+CONTENT_FILTER_KEY = "content_filter_results"
+
+
+@dont_throw
+def set_input_attributes(span, kwargs):
+    if not span.is_recording():
+        return
+
+    if should_send_prompts():
+        if kwargs.get("prompt") is not None:
+            set_span_attribute(
+                span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.user", kwargs.get("prompt")
+            )
+
+        elif kwargs.get("messages") is not None:
+            for i, message in enumerate(kwargs.get("messages")):
+                set_span_attribute(
+                    span,
+                    f"{GenAIAttributes.GEN_AI_PROMPT}.{i}.content",
+                    _dump_content(message.get("content")),
+                )
+                set_span_attribute(
+                    span, f"{GenAIAttributes.GEN_AI_PROMPT}.{i}.role", message.get("role")
+                )
+
+
+@dont_throw
+def set_model_input_attributes(span, kwargs):
+    if not span.is_recording():
+        return
+
+    set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, kwargs.get("model"))
+    set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get("max_tokens_to_sample")
+    )
+    set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE, kwargs.get("temperature")
+    )
+    set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_TOP_P, kwargs.get("top_p"))
+    set_span_attribute(
+        span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
+    )
+    set_span_attribute(
+        span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
+    )
+    set_span_attribute(
+        span, SpanAttributes.LLM_IS_STREAMING, kwargs.get("stream") or False
+    )
+
+
+def set_streaming_response_attributes(
+    span, accumulated_content, finish_reason=None, usage=None
+):
+    """Set span attributes for accumulated streaming response."""
+    if not span.is_recording() or not should_send_prompts():
+        return
+
+    prefix = f"{GenAIAttributes.GEN_AI_COMPLETION}.0"
+    set_span_attribute(span, f"{prefix}.role", "assistant")
+    set_span_attribute(span, f"{prefix}.content", accumulated_content)
+    if finish_reason:
+        set_span_attribute(span, f"{prefix}.finish_reason", finish_reason)
+
+
+def set_model_streaming_response_attributes(span, usage):
+    if not span.is_recording():
+        return
+
+    if usage:
+        set_span_attribute(
+            span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.completion_tokens
+        )
+        set_span_attribute(
+            span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.prompt_tokens
+        )
+        set_span_attribute(
+            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens
+        )
+
+
+@dont_throw
+def set_model_response_attributes(span, response, token_histogram):
+    if not span.is_recording():
+        return
+    response = model_as_dict(response)
+    set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, response.get("model"))
+    set_span_attribute(span, GEN_AI_RESPONSE_ID, response.get("id"))
+
+    usage = response.get("usage") or {}
+    prompt_tokens = usage.get("prompt_tokens")
+    completion_tokens = usage.get("completion_tokens")
+    if usage:
+        set_span_attribute(
+            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.get("total_tokens")
+        )
+        set_span_attribute(
+            span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, completion_tokens
+        )
+        set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, prompt_tokens)
+
+    if (
+        isinstance(prompt_tokens, int)
+        and prompt_tokens >= 0
+        and token_histogram is not None
+    ):
+        token_histogram.record(
+            prompt_tokens,
+            attributes={
+                GenAIAttributes.GEN_AI_TOKEN_TYPE: "input",
+                GenAIAttributes.GEN_AI_RESPONSE_MODEL: response.get("model"),
+            },
+        )
+
+    if (
+        isinstance(completion_tokens, int)
+        and completion_tokens >= 0
+        and token_histogram is not None
+    ):
+        token_histogram.record(
+            completion_tokens,
+            attributes={
+                GenAIAttributes.GEN_AI_TOKEN_TYPE: "output",
+                GenAIAttributes.GEN_AI_RESPONSE_MODEL: response.get("model"),
+            },
+        )
+
+
+def set_response_attributes(span, response):
+    if not span.is_recording():
+        return
+    choices = model_as_dict(response).get("choices")
+    if should_send_prompts() and choices:
+        _set_completions(span, choices)
+
+
+def _set_completions(span, choices):
+    if choices is None or not should_send_prompts():
+        return
+
+    for choice in choices:
+        index = choice.get("index")
+        prefix = f"{GenAIAttributes.GEN_AI_COMPLETION}.{index}"
+        set_span_attribute(span, f"{prefix}.finish_reason", choice.get("finish_reason"))
+
+        if choice.get("content_filter_results"):
+            set_span_attribute(
+                span,
+                f"{prefix}.{CONTENT_FILTER_KEY}",
+                json.dumps(choice.get("content_filter_results")),
+            )
+
+        if choice.get("finish_reason") == "content_filter":
+            set_span_attribute(span, f"{prefix}.role", "assistant")
+            set_span_attribute(span, f"{prefix}.content", "FILTERED")
+
+            return
+
+        message = choice.get("message")
+        if not message:
+            return
+
+        set_span_attribute(span, f"{prefix}.role", message.get("role"))
+        set_span_attribute(span, f"{prefix}.content", message.get("content"))
+
+        function_call = message.get("function_call")
+        if function_call:
+            set_span_attribute(
+                span, f"{prefix}.tool_calls.0.name", function_call.get("name")
+            )
+            set_span_attribute(
+                span,
+                f"{prefix}.tool_calls.0.arguments",
+                function_call.get("arguments"),
+            )
+
+        tool_calls = message.get("tool_calls")
+        if tool_calls:
+            for i, tool_call in enumerate(tool_calls):
+                function = tool_call.get("function")
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.{i}.id",
+                    tool_call.get("id"),
+                )
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.{i}.name",
+                    function.get("name"),
+                )
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.{i}.arguments",
+                    function.get("arguments"),
+                )
+
+
+def _dump_content(content):
+    if isinstance(content, str):
+        return content
+    json_serializable = []
+    for item in content:
+        if item.get("type") == "text":
+            json_serializable.append({"type": "text", "text": item.get("text")})
+        elif item.get("type") == "image":
+            json_serializable.append(
+                {
+                    "type": "image",
+                    "source": {
+                        "type": item.get("source").get("type"),
+                        "media_type": item.get("source").get("media_type"),
+                        "data": str(item.get("source").get("data")),
+                    },
+                }
+            )
+    return json.dumps(json_serializable)

opentelemetry/instrumentation/groq/utils.py

@@ -1,16 +1,21 @@
-from importlib.metadata import version
-import os
 import logging
+import os
 import traceback
+from importlib.metadata import version
+
 from opentelemetry import context as context_api
 from opentelemetry.instrumentation.groq.config import Config
-from opentelemetry.semconv_ai import SpanAttributes
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
 
 GEN_AI_SYSTEM = "gen_ai.system"
 GEN_AI_SYSTEM_GROQ = "groq"
 
 _PYDANTIC_VERSION = version("pydantic")
 
+TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+
 
 def set_span_attribute(span, name, value):
     if value is not None and value != "":
@@ -19,7 +24,7 @@ def set_span_attribute(span, name, value):
 
 def should_send_prompts():
     return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
     ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
 
 
@@ -57,7 +62,7 @@ def shared_metrics_attributes(response):
     return {
         **common_attributes,
         GEN_AI_SYSTEM: GEN_AI_SYSTEM_GROQ,
-        SpanAttributes.LLM_RESPONSE_MODEL: response_dict.get("model"),
+        GenAIAttributes.GEN_AI_RESPONSE_MODEL: response_dict.get("model"),
     }
 
 
@@ -78,3 +83,12 @@ def model_as_dict(model):
         return model_as_dict(model.parse())
     else:
         return model
+
+
+def should_emit_events() -> bool:
+    """
+    Checks if the instrumentation isn't using the legacy attributes
+    and if the event logger is not None.
+    """
+
+    return not Config.use_legacy_attributes

opentelemetry/instrumentation/groq/version.py

@@ -1 +1 @@
-__version__ = "0.40.2"
+__version__ = "0.48.0"

{opentelemetry_instrumentation_groq-0.40.2.dist-info → opentelemetry_instrumentation_groq-0.48.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-groq
-Version: 0.40.2
+Version: 0.48.0
 Summary: OpenTelemetry Groq 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.5)
+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-groq
 Description-Content-Type: text/markdown
 

opentelemetry_instrumentation_groq-0.48.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+opentelemetry/instrumentation/groq/__init__.py,sha256=Be0lZGwA528PZRC3SmrELzZygeVBW4JVEGmdw2jOPd8,15021
+opentelemetry/instrumentation/groq/config.py,sha256=c11xP2YLnXpKFwVlLh23_a-DV96dsfqRqOg6IWACNBI,172
+opentelemetry/instrumentation/groq/event_emitter.py,sha256=m29pi5dSBIN1PGek6Mo_exifBy9vxECes1hdIEa1YaE,4549
+opentelemetry/instrumentation/groq/event_models.py,sha256=PCfCGxrrArwZqR-4wFcXrhwQq0sBMAxmSrpC4PUMtaM,876
+opentelemetry/instrumentation/groq/span_utils.py,sha256=D6PP9kljSmROGNFBkSaccUCh-d3_V0SUEQbwpjTjI2o,7738
+opentelemetry/instrumentation/groq/utils.py,sha256=jSqYCmESVXDCOfJEPIvF6y5M5QoFx2qf7Jnw-r9TTyc,2464
+opentelemetry/instrumentation/groq/version.py,sha256=bkYe4lEQZCEmFm0XRZaZkxTV1niMqR_lbp-tzKL6s6c,23
+opentelemetry_instrumentation_groq-0.48.0.dist-info/METADATA,sha256=uw3O490pTgYTppJq5urVIScLUbfk16Kam-8FcqlJZ68,2176
+opentelemetry_instrumentation_groq-0.48.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+opentelemetry_instrumentation_groq-0.48.0.dist-info/entry_points.txt,sha256=uezQe06CpIK8xTZZSK0lF29nOKkz_w6VR4sQnb4IAFQ,87
+opentelemetry_instrumentation_groq-0.48.0.dist-info/RECORD,,

{opentelemetry_instrumentation_groq-0.40.2.dist-info → opentelemetry_instrumentation_groq-0.48.0.dist-info}/WHEEL

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

opentelemetry_instrumentation_groq-0.40.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-opentelemetry/instrumentation/groq/__init__.py,sha256=E1blGTym8YomMT-bsUCrVSneSy-CZmHdtCWup19OpFw,20433
-opentelemetry/instrumentation/groq/config.py,sha256=eN2YxQdWlAF-qWPwZZr0xFM-8tx9zUjmiparuB64jcU,170
-opentelemetry/instrumentation/groq/utils.py,sha256=1ESL4NCp8Mjww8cGEzQO_AEqGiSK4JSiMFYUhwBnuao,2151
-opentelemetry/instrumentation/groq/version.py,sha256=GgBV43P17gCEFbfEWV0eXof7RjJb8K6WBCun28R_eEw,23
-opentelemetry_instrumentation_groq-0.40.2.dist-info/METADATA,sha256=rA1UQTy0-HB3cYLkuKMf2XaKfV-Z9YuaZ_Ul9nnQ-FI,2117
-opentelemetry_instrumentation_groq-0.40.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-opentelemetry_instrumentation_groq-0.40.2.dist-info/entry_points.txt,sha256=uezQe06CpIK8xTZZSK0lF29nOKkz_w6VR4sQnb4IAFQ,87
-opentelemetry_instrumentation_groq-0.40.2.dist-info/RECORD,,