lmnr 0.4.53.dev0__py3-none-any.whl → 0.7.26__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/kernel/__init__.py

@@ -0,0 +1,381 @@
+"""OpenTelemetry Kernel instrumentation"""
+
+import functools
+from typing import Collection
+
+from lmnr.opentelemetry_lib.opentelemetry.instrumentation.kernel.utils import (
+    process_tool_output_formatter,
+    screenshot_tool_output_formatter,
+)
+from lmnr.sdk.decorators import observe
+from lmnr.sdk.utils import get_input_from_func_args, is_async, json_dumps
+from lmnr import Laminar
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import wrap_function_wrapper
+
+_instruments = ("kernel >= 0.2.0",)
+
+
+WRAPPED_METHODS = [
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "create",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "retrieve",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "list",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "delete",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "delete_by_id",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers",
+        "object": "BrowsersResource",
+        "method": "load_extensions",
+        "class_name": "Browser",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "capture_screenshot",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+        "output_formatter": screenshot_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "click_mouse",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "drag_mouse",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "move_mouse",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "press_key",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "scroll",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.computer",
+        "object": "ComputerResource",
+        "method": "type_text",
+        "class_name": "Computer",
+        "span_type": "TOOL",
+    },
+    {
+        "package": "kernel.resources.browsers.playwright",
+        "object": "PlaywrightResource",
+        "method": "execute",
+        "class_name": "Playwright",
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "exec",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "kill",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "spawn",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "status",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "stdin",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+    {
+        "package": "kernel.resources.browsers.process",
+        "object": "ProcessResource",
+        "method": "stdout_stream",
+        "class_name": "Process",
+        "span_type": "TOOL",
+        "output_formatter": process_tool_output_formatter,
+    },
+]
+
+
+def _with_wrapper(func):
+    """Helper for providing tracer for wrapper functions. Includes metric collectors."""
+
+    def wrapper(
+        to_wrap,
+    ):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(
+                to_wrap,
+                wrapped,
+                instance,
+                args,
+                kwargs,
+            )
+
+        return wrapper
+
+    return wrapper
+
+
+@_with_wrapper
+def _wrap(
+    to_wrap,
+    wrapped,
+    instance,
+    args,
+    kwargs,
+):
+    with Laminar.start_as_current_span(
+        f"{to_wrap.get('class_name')}.{to_wrap.get('method')}",
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+    ) as span:
+        input_kv = get_input_from_func_args(wrapped, True, args, kwargs)
+        if "id" in input_kv:
+            input_kv["session_id"] = input_kv.get("id")
+            input_kv.pop("id")
+        span.set_attribute(
+            "lmnr.span.input",
+            json_dumps(input_kv),
+        )
+        try:
+            result = wrapped(*args, **kwargs)
+        except Exception as e:  # pylint: disable=broad-except
+            span.set_status(Status(StatusCode.ERROR))
+            span.record_exception(e)
+            raise
+        output_formatter = to_wrap.get("output_formatter") or (lambda x: json_dumps(x))
+        span.set_attribute("lmnr.span.output", output_formatter(result))
+        return result
+
+
+@_with_wrapper
+async def _wrap_async(
+    to_wrap,
+    wrapped,
+    instance,
+    args,
+    kwargs,
+):
+    with Laminar.start_as_current_span(
+        f"{to_wrap.get('class_name')}.{to_wrap.get('method')}",
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+    ) as span:
+        input_kv = get_input_from_func_args(wrapped, True, args, kwargs)
+        if "id" in input_kv:
+            input_kv["session_id"] = input_kv.get("id")
+            input_kv.pop("id")
+        span.set_attribute(
+            "lmnr.span.input",
+            json_dumps(input_kv),
+        )
+        try:
+            result = await wrapped(*args, **kwargs)
+        except Exception as e:  # pylint: disable=broad-except
+            span.set_status(Status(StatusCode.ERROR))
+            span.record_exception(e)
+            raise
+        output_formatter = to_wrap.get("output_formatter") or (lambda x: json_dumps(x))
+        span.set_attribute("lmnr.span.output", output_formatter(result))
+        return result
+
+
+@_with_wrapper
+def _wrap_app_action(
+    to_wrap,
+    wrapped,
+    instance,
+    args,
+    kwargs,
+):
+    """
+    Wraps app.action() decorator factory to add tracing to action handlers.
+
+    wrapped: the original `action` method
+    args: (name,) - the action name
+    kwargs: potentially {'name': ...}
+
+    Returns a decorator that wraps handlers with tracing before registering them.
+    """
+
+    # Call the original action method to get the decorator
+    original_decorator = wrapped(*args, **kwargs)
+
+    # Get the action name from args
+    action_name = args[0] if args else kwargs.get("name", "unknown")
+
+    # Create a wrapper for the decorator that intercepts the handler
+    def tracing_decorator(handler):
+        # Apply the observe decorator to add tracing
+        observed_handler = observe(
+            name=f"action.{action_name}",
+            span_type="DEFAULT",
+        )(handler)
+
+        # Create an additional wrapper to add post-execution logic
+        if is_async(handler):
+
+            @functools.wraps(handler)
+            async def async_wrapper_with_flush(*handler_args, **handler_kwargs):
+                # Execute the observed handler (tracing happens here)
+                result = await observed_handler(*handler_args, **handler_kwargs)
+
+                Laminar.flush()
+
+                return result
+
+            # Register the wrapper with the original decorator
+            return original_decorator(async_wrapper_with_flush)
+        else:
+
+            @functools.wraps(handler)
+            def sync_wrapper_with_flush(*handler_args, **handler_kwargs):
+                # Execute the observed handler (tracing happens here)
+                result = observed_handler(*handler_args, **handler_kwargs)
+
+                Laminar.flush()
+
+                return result
+
+            # Register the wrapper with the original decorator
+            return original_decorator(sync_wrapper_with_flush)
+
+    return tracing_decorator
+
+
+class KernelInstrumentor(BaseInstrumentor):
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+
+            try:
+                wrap_function_wrapper(
+                    wrap_package,
+                    f"{wrap_object}.{wrap_method}",
+                    _wrap(wrapped_method),
+                )
+            except (ModuleNotFoundError, AttributeError):
+                pass  # that's ok, we don't want to fail if some methods do not exist
+
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = f"Async{wrapped_method.get('object')}"
+            wrap_method = wrapped_method.get("method")
+            try:
+                wrap_function_wrapper(
+                    wrap_package,
+                    f"{wrap_object}.{wrap_method}",
+                    _wrap_async(wrapped_method),
+                )
+            except (ModuleNotFoundError, AttributeError):
+                pass  # that's ok, we don't want to fail if some methods do not exist
+
+        try:
+            wrap_function_wrapper(
+                "kernel.app_framework",
+                "KernelApp.action",
+                _wrap_app_action({}),
+            )
+        except (ModuleNotFoundError, AttributeError):
+            pass
+
+    def _uninstrument(self, **kwargs):
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            try:
+                unwrap(
+                    f"{wrap_package}.{wrap_object}",
+                    wrapped_method.get("method"),
+                )
+            except (ModuleNotFoundError, AttributeError):
+                pass  # that's ok, we don't want to fail if some methods do not exist
+
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = f"Async{wrapped_method.get('object')}"
+            try:
+                unwrap(
+                    f"{wrap_package}.{wrap_object}",
+                    wrapped_method.get("method"),
+                )
+            except (ModuleNotFoundError, AttributeError):
+                pass  # that's ok, we don't want to fail if some methods do not exist
+
+        try:
+            unwrap("kernel.app_framework.KernelApp", "action")
+        except (ModuleNotFoundError, AttributeError):
+            pass