lmnr 0.6.20__py3-none-any.whl → 0.7.0__py3-none-any.whl

lmnr/opentelemetry_lib/opentelemetry/instrumentation/groq/span_utils.py

@@ -0,0 +1,229 @@
+import json
+
+from .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_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"{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")
+                )
+
+
+@dont_throw
+def set_model_input_attributes(span, kwargs):
+    if not span.is_recording():
+        return
+
+    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
+    )
+
+
+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"{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)
+
+
+def set_model_streaming_response_attributes(span, usage):
+    if not span.is_recording():
+        return
+
+    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
+        )
+
+
+@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, 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"),
+            },
+        )
+
+
+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"{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"),
+                )
+
+
+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 image_url := item.get("image_url"):
+            json_serializable.append(
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": image_url.get("url"),
+                        "detail": image_url.get("detail"),
+                    },
+                }
+            )
+    return json.dumps(json_serializable)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/groq/utils.py

@@ -0,0 +1,92 @@
+import logging
+import os
+import traceback
+from importlib.metadata import version
+
+from opentelemetry import context as context_api
+from .config import Config
+from opentelemetry.semconv_ai import SpanAttributes
+
+GEN_AI_SYSTEM = "gen_ai.system"
+GEN_AI_SYSTEM_GROQ = "groq"
+
+_PYDANTIC_VERSION = version("pydantic")
+
+LMNR_TRACE_CONTENT = "LMNR_TRACE_CONTENT"
+
+
+def set_span_attribute(span, name, value):
+    if value is not None and value != "":
+        span.set_attribute(name, value)
+
+
+def should_send_prompts():
+    return (
+        os.getenv(LMNR_TRACE_CONTENT) or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.debug(
+                "OpenLLMetry failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+            if Config.exception_logger:
+                Config.exception_logger(e)
+
+    return wrapper
+
+
+@dont_throw
+def shared_metrics_attributes(response):
+    response_dict = model_as_dict(response)
+
+    common_attributes = Config.get_common_metrics_attributes()
+
+    return {
+        **common_attributes,
+        GEN_AI_SYSTEM: GEN_AI_SYSTEM_GROQ,
+        SpanAttributes.LLM_RESPONSE_MODEL: response_dict.get("model"),
+    }
+
+
+@dont_throw
+def error_metrics_attributes(exception):
+    return {
+        GEN_AI_SYSTEM: GEN_AI_SYSTEM_GROQ,
+        "error.type": exception.__class__.__name__,
+    }
+
+
+def model_as_dict(model):
+    if _PYDANTIC_VERSION < "2.0.0":
+        return model.dict()
+    if hasattr(model, "model_dump"):
+        return model.model_dump()
+    elif hasattr(model, "parse"):  # Raw API response
+        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

lmnr/opentelemetry_lib/opentelemetry/instrumentation/groq/version.py

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

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py

@@ -12,10 +12,7 @@ from langchain_core.runnables.graph import Graph
 from opentelemetry.trace import Tracer
 from wrapt import wrap_function_wrapper
 from opentelemetry.trace import get_tracer
-
-from lmnr.opentelemetry_lib.tracing.context_properties import (
-    update_association_properties,
-)
+from opentelemetry.context import get_value, attach, set_value
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import unwrap
@@ -45,12 +42,13 @@ def wrap_pregel_stream(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs)
         }
         for edge in graph.edges
     ]
-    update_association_properties(
-        {
-            "langgraph.edges": json.dumps(edges),
-            "langgraph.nodes": json.dumps(nodes),
-        },
-    )
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
     return wrapped(*args, **kwargs)
 
 
@@ -75,12 +73,14 @@ async def async_wrap_pregel_stream(
         }
         for edge in graph.edges
     ]
-    update_association_properties(
-        {
-            "langgraph.edges": json.dumps(edges),
-            "langgraph.nodes": json.dumps(nodes),
-        },
-    )
+
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
 
     async for item in wrapped(*args, **kwargs):
         yield item

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -39,6 +39,7 @@ from ..utils import (
     should_emit_events,
     should_send_prompts,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.metrics import Counter, Histogram
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
@@ -87,6 +88,7 @@ def chat_wrapper(
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     run_async(_handle_request(span, kwargs, instance))
@@ -184,6 +186,7 @@ async def achat_wrapper(
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     await _handle_request(span, kwargs, instance)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/completion_wrappers.py

@@ -27,6 +27,7 @@ from ..utils import (
     should_emit_events,
     should_send_prompts,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv_ai import (
@@ -55,6 +56,7 @@ def completion_wrapper(tracer, wrapped, instance, args, kwargs):
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     _handle_request(span, kwargs, instance)
@@ -89,6 +91,7 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
         name=SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     _handle_request(span, kwargs, instance)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/utils.py

@@ -14,7 +14,7 @@ import openai
 
 _OPENAI_VERSION = version("openai")
 
-TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+LMNR_TRACE_CONTENT = "LMNR_TRACE_CONTENT"
 
 
 def is_openai_v1():
@@ -28,7 +28,7 @@ def is_azure_openai(instance):
 
 
 def is_metrics_enabled() -> bool:
-    return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"
+    return False
 
 
 def should_record_stream_token_usage():
@@ -171,7 +171,7 @@ def run_async(method):
 
 def should_send_prompts():
     return (
-        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
+        os.getenv(LMNR_TRACE_CONTENT) or "true"
     ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
 
 

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -17,6 +17,7 @@ from ..utils import (
     dont_throw,
     should_emit_events,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes
@@ -126,6 +127,7 @@ def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
         start_time=run.get("start_time"),
+        context=get_current_context(),
     )
 
     if exception := run.get("exception"):
@@ -250,6 +252,7 @@ def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
         "openai.assistant.run_stream",
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
+        context=get_current_context(),
     )
 
     i = 0

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/responses_wrappers.py

@@ -36,6 +36,7 @@ except ImportError:
     ResponseOutputMessageParam = Dict[str, Any]
     RESPONSES_AVAILABLE = False
 
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from openai._legacy_response import LegacyAPIResponse
 from opentelemetry import context as context_api
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
@@ -429,6 +430,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=get_current_context(),
         )
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
@@ -472,6 +474,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=get_current_context(),
         )
         set_data_attributes(traced_data, span)
         span.end()
@@ -523,6 +526,7 @@ async def async_responses_get_or_create_wrapper(
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=get_current_context(),
         )
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
@@ -566,6 +570,7 @@ async def async_responses_get_or_create_wrapper(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=get_current_context(),
         )
         set_data_attributes(traced_data, span)
         span.end()
@@ -590,6 +595,7 @@ def responses_cancel_wrapper(tracer: Tracer, wrapped, instance, args, kwargs):
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=get_current_context(),
         )
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)
@@ -616,6 +622,7 @@ async def async_responses_cancel_wrapper(
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=get_current_context(),
         )
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)