lmnr 0.7.6__tar.gz → 0.7.7__tar.gz

{lmnr-0.7.6 → lmnr-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.6
+Version: 0.7.7
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>

{lmnr-0.7.6 → lmnr-0.7.7}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.6"
+version = "0.7.7"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/opentelemetry_lib/decorators/__init__.py

@@ -1,5 +1,4 @@
 from functools import wraps
-import logging
 import pydantic
 import orjson
 import types
@@ -60,7 +59,7 @@ def json_dumps(data: dict) -> str:
         ).decode("utf-8")
     except Exception:
         # Log the exception and return a placeholder if serialization completely fails
-        logging.warning("Failed to serialize data to JSON, type: %s", type(data))
+        logger.info("Failed to serialize data to JSON, type: %s", type(data))
         return "{}"  # Return an empty JSON object as a fallback
 
 

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/opentelemetry_lib/litellm/__init__.py

@@ -7,14 +7,13 @@ from opentelemetry.trace import SpanKind, Status, StatusCode, Tracer
 from lmnr.opentelemetry_lib.litellm.utils import model_as_dict, set_span_attribute
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
-from lmnr.opentelemetry_lib.tracing.context import get_event_attributes_from_context
+from lmnr.opentelemetry_lib.tracing.context import (
+    get_current_context,
+    get_event_attributes_from_context,
+)
 from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 from lmnr.sdk.log import get_default_logger
 
-from lmnr.opentelemetry_lib.opentelemetry.instrumentation.openai import (
-    OpenAIInstrumentor,
-)
-
 logger = get_default_logger(__name__)
 
 SUPPORTED_CALL_TYPES = ["completion", "acompletion"]
@@ -46,6 +45,10 @@ try:
                 raise ValueError("Laminar must be initialized before LiteLLM callback")
 
             if is_package_installed("openai"):
+                from lmnr.opentelemetry_lib.opentelemetry.instrumentation.openai import (
+                    OpenAIInstrumentor,
+                )
+
                 openai_instrumentor = OpenAIInstrumentor()
                 if (
                     openai_instrumentor
@@ -117,6 +120,7 @@ try:
                 attributes={
                     "lmnr.internal.provider": "litellm",
                 },
+                context=get_current_context(),
             )
             try:
                 model = kwargs.get("model", "unknown")

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/utils.py

@@ -12,6 +12,7 @@ from .shared.config import Config
 
 import openai
 
+
 _OPENAI_VERSION = version("openai")
 
 LMNR_TRACE_CONTENT = "LMNR_TRACE_CONTENT"
@@ -22,6 +23,7 @@ def is_openai_v1():
 
 
 def is_azure_openai(instance):
+
     return is_openai_v1() and isinstance(
         instance._client, (openai.AsyncAzureOpenAI, openai.AzureOpenAI)
     )

lmnr-0.7.7/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/openhands_ai/__init__.py

@@ -0,0 +1,389 @@
+"""OpenTelemetry OpenHands AI instrumentation"""
+
+import sys
+from typing import Collection
+
+from lmnr.opentelemetry_lib.decorators import json_dumps
+from lmnr.opentelemetry_lib.tracing.attributes import (
+    ASSOCIATION_PROPERTIES,
+    SESSION_ID,
+    USER_ID,
+)
+from lmnr.opentelemetry_lib.utils.wrappers import _with_tracer_wrapper
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.utils import get_input_from_func_args
+from lmnr import Laminar
+from lmnr.version import __version__
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer, Tracer
+from wrapt import wrap_function_wrapper
+
+logger = get_default_logger(__name__)
+
+_instruments = ("openhands-ai >= 0.9.0", "openhands-aci >= 0.1.0")
+parent_spans = {}
+
+
+def is_message_action(event) -> bool:
+    """Check if event has action attribute equal to 'message'."""
+    return event and hasattr(event, "action") and event.action == "message"
+
+
+def is_user_message(event) -> bool:
+    """Check if event is a message action from user source."""
+    return (
+        is_message_action(event) and hasattr(event, "source") and event.source == "user"
+    )
+
+
+def is_agent_message(event) -> bool:
+    """Check if event is a message action from agent source."""
+    return (
+        is_message_action(event)
+        and hasattr(event, "source")
+        and event.source == "agent"
+    )
+
+
+def is_agent_state_changed_to(event, state: str) -> bool:
+    """Check if event is an agent_state_changed observation with specific state."""
+    return (
+        event
+        and hasattr(event, "observation")
+        and event.observation == "agent_state_changed"
+        and hasattr(event, "agent_state")
+        and event.agent_state == state
+    )
+
+
+def get_handle_action_action(event) -> str:
+    """Get the action of the handle_action event."""
+    if event and hasattr(event, "action"):
+        try:
+            return event.action.value
+        except Exception:
+            return event.action
+    return None
+
+
+WRAPPED_METHODS = [
+    {
+        "package": "openhands.agenthub.codeact_agent.codeact_agent",
+        "object": "CodeActAgent",
+        "methods": [
+            {"method": "step"},
+            {"method": "response_to_actions"},
+        ],
+    },
+    {
+        "package": "openhands.controller.agent_controller",
+        "object": "AgentController",
+        "methods": [
+            {"method": "_step", "async": True},
+            {
+                "method": "_handle_action",
+                "async": True,
+                "span_type": "TOOL",
+            },
+            {"method": "_handle_observation", "async": True},
+            {"method": "_handle_message_action", "async": True},
+            {"method": "on_event"},
+            {"method": "save_state"},
+            {"method": "get_trajectory"},
+            {"method": "start_delegate"},
+            {"method": "end_delegate"},
+            {"method": "_is_stuck"},
+        ],
+    },
+]
+
+
+@_with_tracer_wrapper
+def _wrap_on_event(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for on_event."""
+    controller_id = instance.id
+    user_id = instance.user_id
+    event = kwargs.get("event", args[0] if len(args) > 0 else None)
+    start_event = False
+    finish_event = False
+    user_message = ""
+    agent_message = ""
+    span_name = to_wrap.get("span_name")
+    span_type = to_wrap.get("span_type", "DEFAULT")
+    if event and hasattr(event, "action") and event.action == "system":
+        return wrapped(*args, **kwargs)
+
+    event_type = None
+    subtype = None
+    if event and hasattr(event, "action"):
+        event_type = "action"
+        try:
+            subtype = event.action.value
+        except Exception:
+            subtype = event.action
+    elif event and hasattr(event, "observation"):
+        event_type = "observation"
+        try:
+            subtype = event.observation.value
+        except Exception:
+            subtype = event.observation
+    if event_type and subtype:
+        span_name = f"event.{event_type}.{subtype}"
+        span_type = "EVENT"
+
+    # start trace on user message
+    if is_user_message(event):
+        user_message = event.content if hasattr(event, "content") else ""
+        start_event = True
+    # end trace on agent state change to finished or error
+    if is_agent_state_changed_to(event, "stopped") or is_agent_state_changed_to(
+        event, "awaiting_user_input"
+    ):
+        finish_event = True
+
+    if is_agent_state_changed_to(event, "user_rejected"):
+        agent_message = "<user_rejected>"
+
+    if is_agent_message(event):
+        agent_message = event.content if hasattr(event, "content") else ""
+
+    if start_event:
+        if controller_id in parent_spans:
+            logger.debug(
+                "Received a message, but already have a span for this trace. Resetting span."
+            )
+            parent_spans[controller_id].end()
+            del parent_spans[controller_id]
+        parent_span = Laminar.start_span("conversation.turn", span_type="DEFAULT")
+        if user_id:
+            parent_span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{USER_ID}", user_id)
+        if user_message:
+            parent_span.set_attribute("lmnr.span.input", user_message)
+        parent_span.set_attribute(
+            f"{ASSOCIATION_PROPERTIES}.{SESSION_ID}", controller_id
+        )
+        parent_spans[controller_id] = parent_span
+
+    if controller_id in parent_spans:
+        with Laminar.use_span(parent_spans[controller_id]):
+            result = _wrap_sync_method_inner(
+                tracer,
+                {**to_wrap, "span_name": span_name, "span_type": span_type},
+                wrapped,
+                instance,
+                args,
+                kwargs,
+            )
+            if agent_message:
+                parent_spans[controller_id].set_attribute(
+                    "lmnr.span.output", agent_message
+                )
+            if finish_event:
+                parent_spans[controller_id].end()
+                del parent_spans[controller_id]
+            return result
+
+    return wrapped(*args, **kwargs)
+
+
+@_with_tracer_wrapper
+async def _wrap_handle_action(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for on_event."""
+    event = kwargs.get("event", args[0] if len(args) > 0 else None)
+    if event and hasattr(event, "action"):
+        if event.action == "system":
+            return await wrapped(*args, **kwargs)
+    action_name = get_handle_action_action(event)
+    if action_name and action_name != "message":
+        to_wrap["span_name"] = f"action.{action_name}"
+    controller_id = instance.id
+    if controller_id not in parent_spans:
+        return await wrapped(*args, **kwargs)
+    return await _wrap_async_method_inner(
+        tracer, to_wrap, wrapped, instance, args, kwargs
+    )
+
+
+def _wrap_sync_method_inner(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for synchronous methods."""
+    span_name = to_wrap.get("span_name")
+
+    with Laminar.start_as_current_span(
+        span_name,
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+        input=json_dumps(
+            get_input_from_func_args(
+                wrapped, to_wrap.get("object") is not None, args, kwargs
+            )
+        ),
+    ) as span:
+        try:
+            result = wrapped(*args, **kwargs)
+
+            # Capture output
+            if not to_wrap.get("ignore_output"):
+                span.set_attribute("lmnr.span.output", json_dumps(result))
+            return result
+
+        except Exception as e:
+            span.record_exception(e)
+            raise
+
+
+@_with_tracer_wrapper
+def _wrap_sync_method(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    instance_id = None
+    if to_wrap.get("object") == "AgentController":
+        instance_id = instance.id
+    if to_wrap.get("object") == "ActionExecutionClient" and hasattr(instance, "sid"):
+        instance_id = instance.sid
+    if instance_id is not None and instance_id not in parent_spans:
+        return wrapped(*args, **kwargs)
+    return _wrap_sync_method_inner(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+
+async def _wrap_async_method_inner(
+    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+):
+    """Wrapper for asynchronous methods."""
+    span_name = to_wrap.get("span_name")
+    instance_id = None
+    if to_wrap.get("object") == "AgentController":
+        instance_id = instance.id
+    if to_wrap.get("object") == "ActionExecutionClient" and hasattr(instance, "sid"):
+        instance_id = instance.sid
+    if instance_id is not None and instance_id not in parent_spans:
+        return await wrapped(*args, **kwargs)
+
+    with Laminar.start_as_current_span(
+        span_name,
+        span_type=to_wrap.get("span_type", "DEFAULT"),
+        input=json_dumps(
+            get_input_from_func_args(
+                wrapped, to_wrap.get("object") is not None, args, kwargs
+            )
+        ),
+    ) as span:
+        try:
+            result = await wrapped(*args, **kwargs)
+
+            # Capture output
+            if not to_wrap.get("ignore_output"):
+                span.set_attribute("lmnr.span.output", json_dumps(result))
+            return result
+
+        except Exception as e:
+            span.record_exception(e)
+            raise
+
+
+@_with_tracer_wrapper
+async def _wrap_async_method(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    """Wrapper for asynchronous methods."""
+    return await _wrap_async_method_inner(
+        tracer, to_wrap, wrapped, instance, args, kwargs
+    )
+
+
+class OpenHandsInstrumentor(BaseInstrumentor):
+    """An instrumentor for OpenHands AI."""
+
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        """Instrument OpenHands AI methods."""
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        for wrapped_config in WRAPPED_METHODS:
+            wrap_package = wrapped_config.get("package")
+
+            wrap_object = wrapped_config.get("object")
+            methods = wrapped_config.get("methods", [])
+
+            for method_config in methods:
+
+                wrap_method = method_config.get("method")
+                async_wrap = method_config.get("async", False)
+                windows_only = method_config.get("windows_only", False)
+                if windows_only and sys.platform != "win32":
+                    continue
+
+                # Create the method configuration for the wrapper
+                method_wrapper_config = {
+                    "package": wrap_package,
+                    "object": wrap_object,
+                    "method": wrap_method,
+                    "span_name": method_config.get(
+                        "span_name",
+                        f"{wrap_object}.{wrap_method}" if wrap_object else wrap_method,
+                    ),
+                    "span_type": method_config.get("span_type", "DEFAULT"),
+                    "async": async_wrap,
+                }
+
+                # Determine the target for wrapping
+                if wrap_object:
+                    target = f"{wrap_object}.{wrap_method}"
+                else:
+                    target = wrap_method
+
+                if wrap_object == "AgentController" and wrap_method == "on_event":
+                    wrap_function_wrapper(
+                        wrap_package,
+                        target,
+                        _wrap_on_event(tracer, method_wrapper_config),
+                    )
+                    continue
+                if wrap_object == "AgentController" and wrap_method == "_handle_action":
+                    wrap_function_wrapper(
+                        wrap_package,
+                        target,
+                        _wrap_handle_action(tracer, method_wrapper_config),
+                    )
+                    continue
+
+                try:
+                    if async_wrap:
+                        wrap_function_wrapper(
+                            wrap_package,
+                            target,
+                            _wrap_async_method(tracer, method_wrapper_config),
+                        )
+                    else:
+                        wrap_function_wrapper(
+                            wrap_package,
+                            target,
+                            _wrap_sync_method(tracer, method_wrapper_config),
+                        )
+                except (ModuleNotFoundError, AttributeError) as e:
+                    logger.debug(f"Could not instrument {wrap_package}.{target}: {e}")
+
+    def _uninstrument(self, **kwargs):
+        """Remove OpenHands AI instrumentation."""
+        for wrapped_config in WRAPPED_METHODS:
+            wrap_package = wrapped_config.get("package")
+            wrap_object = wrapped_config.get("object")
+            methods = wrapped_config.get("methods", [])
+
+            for method_config in methods:
+                wrap_method = method_config.get("method")
+
+                # Determine the module path for unwrapping
+                if wrap_object:
+                    module_path = f"{wrap_package}.{wrap_object}"
+                else:
+                    module_path = wrap_package
+
+                try:
+                    unwrap(module_path, wrap_method)
+                except (AttributeError, ValueError) as e:
+                    logger.debug(
+                        f"Could not uninstrument {module_path}.{wrap_method}: {e}"
+                    )

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -268,6 +268,15 @@ class OpenAIInstrumentorInitializer(InstrumentorInitializer):
         )
 
 
+class OpenHandsAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("openhands-ai"):
+            return None
+        from ..opentelemetry.instrumentation.openhands_ai import OpenHandsInstrumentor
+
+        return OpenHandsInstrumentor()
+
+
 class OpenTelemetryInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         from ..opentelemetry.instrumentation.opentelemetry import (

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/opentelemetry_lib/tracing/instruments.py

@@ -33,6 +33,7 @@ class Instruments(Enum):
     MISTRAL = "mistral"
     OLLAMA = "ollama"
     OPENAI = "openai"
+    OPENHANDS = "openhands"
     # Patch OpenTelemetry to fix DataDog's broken Span context
     # See lmnr.opentelemetry_lib.opentelemetry.instrumentation.opentelemetry
     # for more details.
@@ -75,6 +76,7 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.MISTRAL: initializers.MistralInstrumentorInitializer(),
     Instruments.OLLAMA: initializers.OllamaInstrumentorInitializer(),
     Instruments.OPENAI: initializers.OpenAIInstrumentorInitializer(),
+    Instruments.OPENHANDS: initializers.OpenHandsAIInstrumentorInitializer(),
     Instruments.OPENTELEMETRY: initializers.OpenTelemetryInstrumentorInitializer(),
     Instruments.PATCHRIGHT: initializers.PatchrightInstrumentorInitializer(),
     Instruments.PINECONE: initializers.PineconeInstrumentorInitializer(),

lmnr-0.7.7/src/lmnr/opentelemetry_lib/utils/wrappers.py

@@ -0,0 +1,11 @@
+# TODO: Remove the same thing from openai, anthropic, etc, and use this instead
+
+
+def _with_tracer_wrapper(func):
+    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

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/sdk/browser/playwright_otel.py

@@ -154,6 +154,26 @@ async def _wrap_bring_to_front_async(
     await take_full_snapshot_async(instance)
 
 
+@with_tracer_and_client_wrapper
+def _wrap_browser_new_page_sync(
+    tracer: Tracer, client: LaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
+    page = wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    start_recording_events_sync(page, session_id, client)
+    return page
+
+
+@with_tracer_and_client_wrapper
+async def _wrap_browser_new_page_async(
+    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
+    page = await wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    await start_recording_events_async(page, session_id, client)
+    return page
+
+
 WRAPPED_METHODS = [
     {
         "package": "playwright.sync_api",
@@ -191,6 +211,12 @@ WRAPPED_METHODS = [
         "method": "bring_to_front",
         "wrapper": _wrap_bring_to_front_sync,
     },
+    {
+        "package": "playwright.sync_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_browser_new_page_sync,
+    },
 ]
 
 WRAPPED_METHODS_ASYNC = [
@@ -230,6 +256,12 @@ WRAPPED_METHODS_ASYNC = [
         "method": "bring_to_front",
         "wrapper": _wrap_bring_to_front_async,
     },
+    {
+        "package": "playwright.async_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_browser_new_page_async,
+    },
 ]
 
 

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/sdk/utils.py

@@ -132,13 +132,13 @@ def is_otel_attribute_value_type(value: typing.Any) -> bool:
 
 def format_id(id_value: str | int | uuid.UUID) -> str:
     """Format trace/span/evaluation ID to a UUID string, or return valid UUID strings as-is.
-    
+
     Args:
         id_value: The ID in various formats (UUID, int, or valid UUID string)
-        
+
     Returns:
         str: UUID string representation
-        
+
     Raises:
         ValueError: If id_value cannot be converted to a valid UUID
     """

{lmnr-0.7.6 → lmnr-0.7.7}/src/lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.7.6"
+__version__ = "0.7.7"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"