lmnr 0.6.20__py3-none-any.whl → 0.6.21__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/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/tracing/__init__.py

@@ -45,7 +45,7 @@ class TracerWrapper(object):
         project_api_key: str | None = None,
         max_export_batch_size: int | None = None,
         force_http: bool = False,
-        timeout_seconds: int = 10,
+        timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
     ) -> "TracerWrapper":

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -2,7 +2,10 @@ import abc
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 
-from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
+from lmnr.opentelemetry_lib.utils.package_check import (
+    get_package_version,
+    is_package_installed,
+)
 
 
 class InstrumentorInitializer(abc.ABC):
@@ -27,10 +30,8 @@ class AnthropicInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("anthropic"):
             return None
-        if not is_package_installed("opentelemetry-instrumentation-anthropic"):
-            return None
 
-        from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+        from ..opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
 
         return AnthropicInstrumentor(
             upload_base64_image=None,
@@ -54,6 +55,12 @@ class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
         if not is_package_installed("browser-use"):
             return None
 
+        version = get_package_version("browser-use")
+        from packaging.version import parse
+
+        if version and parse(version) >= parse("0.5.0"):
+            return None
+
         from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
 
         return BrowserUseInstrumentor()
@@ -127,10 +134,8 @@ class GroqInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("groq"):
             return None
-        if not is_package_installed("opentelemetry-instrumentation-groq"):
-            return None
 
-        from opentelemetry.instrumentation.groq import GroqInstrumentor
+        from ..opentelemetry.instrumentation.groq import GroqInstrumentor
 
         return GroqInstrumentor()
 

lmnr/opentelemetry_lib/tracing/processor.py

@@ -35,7 +35,7 @@ class LaminarSpanProcessor(SpanProcessor):
         api_key: str | None = None,
         timeout_seconds: int = 30,
         force_http: bool = False,
-        max_export_batch_size: int = 512,
+        max_export_batch_size: int = 64,
         disable_batch: bool = False,
         exporter: SpanExporter | None = None,
     ):

lmnr/opentelemetry_lib/utils/package_check.py

@@ -1,5 +1,7 @@
 from importlib.metadata import distributions
 
+from typing import Optional
+
 installed_packages = {
     (dist.name or dist.metadata.get("Name", "")).lower() for dist in distributions()
 }
@@ -7,3 +9,10 @@ installed_packages = {
 
 def is_package_installed(package_name: str) -> bool:
     return package_name.lower() in installed_packages
+
+
+def get_package_version(package_name: str) -> Optional[str]:
+    for dist in distributions():
+        if (dist.name or dist.metadata.get("Name", "")).lower() == package_name.lower():
+            return dist.version
+    return None

lmnr/sdk/browser/browser_use_otel.py

@@ -1,4 +1,5 @@
 from lmnr.opentelemetry_lib.decorators import json_dumps
+from lmnr.sdk.laminar import Laminar
 from lmnr.sdk.browser.utils import with_tracer_wrapper
 from lmnr.sdk.utils import get_input_from_func_args
 from lmnr.version import __version__
@@ -19,7 +20,7 @@ except ImportError as e:
         "to install Browser Use or remove this import."
     ) from e
 
-_instruments = ("browser-use < 0.5.0",)
+_instruments = ("browser-use >= 0.1.0",)
 
 WRAPPED_METHODS = [
     {
@@ -86,7 +87,8 @@ async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         step_info = kwargs.get("step_info", args[0] if len(args) > 0 else None)
         if step_info and hasattr(step_info, "step_number"):
             span_name = f"agent.step.{step_info.step_number}"
-    with tracer.start_as_current_span(span_name, attributes=attributes) as span:
+
+    with Laminar.start_as_current_span(span_name) as span:
         span.set_attributes(attributes)
         result = await wrapped(*args, **kwargs)
         if not to_wrap.get("ignore_output"):

lmnr/sdk/browser/patchright_otel.py

@@ -1,6 +1,4 @@
 from lmnr.sdk.browser.playwright_otel import (
-    _wrap_new_page,
-    _wrap_new_page_async,
     _wrap_new_browser_sync,
     _wrap_new_browser_async,
     _wrap_new_context_sync,
@@ -18,18 +16,6 @@ from wrapt import wrap_function_wrapper
 _instruments = ("patchright >= 1.9.0",)
 
 WRAPPED_METHODS = [
-    {
-        "package": "patchright.sync_api",
-        "object": "BrowserContext",
-        "method": "new_page",
-        "wrapper": _wrap_new_page,
-    },
-    {
-        "package": "patchright.sync_api",
-        "object": "Browser",
-        "method": "new_page",
-        "wrapper": _wrap_new_page,
-    },
     {
         "package": "patchright.sync_api",
         "object": "BrowserType",
@@ -63,18 +49,6 @@ WRAPPED_METHODS = [
 ]
 
 WRAPPED_METHODS_ASYNC = [
-    {
-        "package": "patchright.async_api",
-        "object": "BrowserContext",
-        "method": "new_page",
-        "wrapper": _wrap_new_page_async,
-    },
-    {
-        "package": "patchright.async_api",
-        "object": "Browser",
-        "method": "new_page",
-        "wrapper": _wrap_new_page_async,
-    },
     {
         "package": "patchright.async_api",
         "object": "BrowserType",