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

opentelemetry/instrumentation/groq/__init__.py

@@ -1,41 +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 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 = [
     {
@@ -59,163 +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):
-    response = model_as_dict(response)
-
-    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
-
-    usage = response.get("usage")
-    if usage:
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.get("total_tokens")
-        )
-        set_span_attribute(
-            span,
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-            usage.get("completion_tokens"),
-        )
-        set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.get("prompt_tokens")
-        )
-
-    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."""
 
@@ -224,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):
@@ -232,6 +89,7 @@ def _with_chat_telemetry_wrapper(func):
                 token_histogram,
                 choice_counter,
                 duration_histogram,
+                event_logger,
                 to_wrap,
                 wrapped,
                 instance,
@@ -266,12 +124,110 @@ def _create_metrics(meter: Meter):
     return token_histogram, choice_counter, duration_histogram
 
 
+def _process_streaming_chunk(chunk):
+    """Extract content, finish_reason and usage from a streaming chunk."""
+    if not chunk.choices:
+        return None, None, None
+
+    delta = chunk.choices[0].delta
+    content = delta.content if hasattr(delta, "content") else None
+    finish_reason = chunk.choices[0].finish_reason
+
+    # Extract usage from x_groq if present in the final chunk
+    usage = None
+    if hasattr(chunk, "x_groq") and chunk.x_groq and chunk.x_groq.usage:
+        usage = chunk.x_groq.usage
+
+    return content, finish_reason, usage
+
+
+def _handle_streaming_response(
+    span, accumulated_content, finish_reason, usage, event_logger
+):
+    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, event_logger):
+    """Create a generator that processes a stream while collecting telemetry."""
+    accumulated_content = ""
+    finish_reason = None
+    usage = None
+
+    for chunk in response:
+        content, chunk_finish_reason, chunk_usage = _process_streaming_chunk(chunk)
+        if content:
+            accumulated_content += content
+        if chunk_finish_reason:
+            finish_reason = chunk_finish_reason
+        if chunk_usage:
+            usage = chunk_usage
+        yield chunk
+
+    _handle_streaming_response(
+        span, accumulated_content, finish_reason, usage, event_logger
+    )
+
+    if span.is_recording():
+        span.set_status(Status(StatusCode.OK))
+
+    span.end()
+
+
+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
+    usage = None
+
+    async for chunk in response:
+        content, chunk_finish_reason, chunk_usage = _process_streaming_chunk(chunk)
+        if content:
+            accumulated_content += content
+        if chunk_finish_reason:
+            finish_reason = chunk_finish_reason
+        if chunk_usage:
+            usage = chunk_usage
+        yield chunk
+
+    _handle_streaming_response(
+        span, accumulated_content, finish_reason, usage, event_logger
+    )
+
+    if span.is_recording():
+        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,
@@ -289,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:
@@ -313,8 +268,16 @@ def _wrap(
     end_time = time.time()
 
     if is_streaming_response(response):
-        # TODO: implement streaming
-        pass
+        try:
+            return _create_stream_processor(response, span, event_logger)
+        except Exception as ex:
+            logger.warning(
+                "Failed to process streaming response for groq span, error: %s",
+                str(ex),
+            )
+            span.set_status(Status(StatusCode.ERROR))
+            span.end()
+            raise
     elif response:
         try:
             metric_attributes = shared_metrics_attributes(response)
@@ -326,14 +289,14 @@ def _wrap(
                     attributes=metric_attributes,
                 )
 
-            if span.is_recording():
-                _set_response_attributes(span, response)
+            _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()
@@ -346,6 +309,7 @@ async def _awrap(
     token_histogram: Histogram,
     choice_counter: Counter,
     duration_histogram: Histogram,
+    event_logger: Union[EventLogger, None],
     to_wrap,
     wrapped,
     instance,
@@ -363,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
@@ -389,9 +348,19 @@ async def _awrap(
 
         raise e
 
+    end_time = time.time()
+
     if is_streaming_response(response):
-        # TODO: implement streaming
-        pass
+        try:
+            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",
+                str(ex),
+            )
+            span.set_status(Status(StatusCode.ERROR))
+            span.end()
+            raise
     elif response:
         metric_attributes = shared_metrics_attributes(response)
 
@@ -402,8 +371,7 @@ async def _awrap(
                 attributes=metric_attributes,
             )
 
-        if span.is_recording():
-            _set_response_attributes(span, response)
+        _handle_response(span, response, token_histogram, event_logger)
 
         if span.is_recording():
             span.set_status(Status(StatusCode.OK))
@@ -420,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
@@ -451,7 +419,14 @@ class GroqInstrumentor(BaseInstrumentor):
                 token_histogram,
                 choice_counter,
                 duration_histogram,
-            ) = (None, None, None, None)
+            ) = (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")
@@ -467,6 +442,7 @@ class GroqInstrumentor(BaseInstrumentor):
                         token_histogram,
                         choice_counter,
                         duration_histogram,
+                        event_logger,
                         wrapped_method,
                     ),
                 )
@@ -486,6 +462,7 @@ class GroqInstrumentor(BaseInstrumentor):
                         token_histogram,
                         choice_counter,
                         duration_histogram,
+                        event_logger,
                         wrapped_method,
                     ),
                 )
@@ -501,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,14 +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 != "":
@@ -17,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")
 
 
@@ -55,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"),
     }
 
 
@@ -68,7 +75,7 @@ def error_metrics_attributes(exception):
 
 
 def model_as_dict(model):
-    if version("pydantic") < "2.0.0":
+    if _PYDANTIC_VERSION < "2.0.0":
         return model.dict()
     if hasattr(model, "model_dump"):
         return model.model_dump()
@@ -76,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.33.6"
+__version__ = "0.48.0"

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

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-groq
-Version: 0.33.6
+Version: 0.48.0
 Summary: OpenTelemetry Groq instrumentation
-Home-page: https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-groq
 License: Apache-2.0
 Author: Gal Kleinman
 Author-email: gal@traceloop.com
@@ -14,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.27.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.48b0,<0.49)
-Requires-Dist: opentelemetry-semantic-conventions (>=0.48b0,<0.49)
-Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.2)
+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.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.33.6.dist-info → opentelemetry_instrumentation_groq-0.48.0.dist-info}/WHEEL

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

opentelemetry_instrumentation_groq-0.33.6.dist-info/RECORD

@@ -1,8 +0,0 @@
-opentelemetry/instrumentation/groq/__init__.py,sha256=JllxoBhhu4XKVTAeRE6_KvCNwvzJz-hQmNfQqHU4O_8,15885
-opentelemetry/instrumentation/groq/config.py,sha256=eN2YxQdWlAF-qWPwZZr0xFM-8tx9zUjmiparuB64jcU,170
-opentelemetry/instrumentation/groq/utils.py,sha256=goqxOrjnQgklCclkVjEekZWxUakuDgV_StB4XmP67sY,2112
-opentelemetry/instrumentation/groq/version.py,sha256=5Y0NtoRrd9Mt0esLjATqHKGOX_Jre-ex7yMzoNdSwtY,23
-opentelemetry_instrumentation_groq-0.33.6.dist-info/METADATA,sha256=RgoRVhcLpbC85wz6l5kNRx2-NHz9mIGGB-NWc8rjeqs,2235
-opentelemetry_instrumentation_groq-0.33.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-opentelemetry_instrumentation_groq-0.33.6.dist-info/entry_points.txt,sha256=uezQe06CpIK8xTZZSK0lF29nOKkz_w6VR4sQnb4IAFQ,87
-opentelemetry_instrumentation_groq-0.33.6.dist-info/RECORD,,