lmnr 0.7.10__py3-none-any.whl → 0.7.12__py3-none-any.whl

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.decorators import json_dumps
 from lmnr.opentelemetry_lib.tracing.context import (
     get_current_context,
     get_event_attributes_from_context,
@@ -139,6 +140,10 @@ class TracedData(pydantic.BaseModel):
     request_model: Optional[str] = pydantic.Field(default=None)
     response_model: Optional[str] = pydantic.Field(default=None)
 
+    # Reasoning attributes
+    request_reasoning_summary: Optional[str] = pydantic.Field(default=None)
+    request_reasoning_effort: Optional[str] = pydantic.Field(default=None)
+
 
 responses: dict[str, TracedData] = {}
 
@@ -204,7 +209,28 @@ def set_data_attributes(traced_response: TracedData, span: Span):
                 SpanAttributes.LLM_USAGE_CACHE_READ_INPUT_TOKENS,
                 usage.input_tokens_details.cached_tokens,
             )
-        # TODO: add reasoning tokens in output token details
+
+        reasoning_tokens = None
+        if usage.output_tokens_details:
+            reasoning_tokens = usage.output_tokens_details.reasoning_tokens
+
+        _set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_REASONING_TOKENS,
+            reasoning_tokens or 0,
+        )
+
+    _set_span_attribute(
+        span,
+        f"{SpanAttributes.LLM_REQUEST_REASONING_SUMMARY}",
+        traced_response.request_reasoning_summary or (),
+    )
+
+    _set_span_attribute(
+        span,
+        f"{SpanAttributes.LLM_REQUEST_REASONING_EFFORT}",
+        traced_response.request_reasoning_effort or (),
+    )
 
     if should_send_prompts():
         prompt_index = 0
@@ -275,7 +301,9 @@ def set_data_attributes(traced_response: TracedData, span: Span):
                     prompt_index += 1
                 elif block_dict.get("type") == "computer_call_output":
                     _set_span_attribute(
-                        span, f"{GEN_AI_PROMPT}.{prompt_index}.role", "computer-call"
+                        span,
+                        f"{GEN_AI_PROMPT}.{prompt_index}.role",
+                        "computer_call_output",
                     )
                     output_image_url = block_dict.get("output", {}).get("image_url")
                     if output_image_url:
@@ -299,16 +327,45 @@ def set_data_attributes(traced_response: TracedData, span: Span):
                     call_content = {}
                     if block_dict.get("id"):
                         call_content["id"] = block_dict.get("id")
-                    if block_dict.get("call_id"):
-                        call_content["call_id"] = block_dict.get("call_id")
                     if block_dict.get("action"):
                         call_content["action"] = block_dict.get("action")
                     _set_span_attribute(
                         span,
-                        f"{GEN_AI_PROMPT}.{prompt_index}.content",
+                        f"{GEN_AI_PROMPT}.{prompt_index}.tool_calls.0.arguments",
                         json.dumps(call_content),
                     )
+                    _set_span_attribute(
+                        span,
+                        f"{GEN_AI_PROMPT}.{prompt_index}.tool_calls.0.id",
+                        block_dict.get("call_id"),
+                    )
+                    _set_span_attribute(
+                        span,
+                        f"{GEN_AI_PROMPT}.{prompt_index}.tool_calls.0.name",
+                        "computer_call",
+                    )
                     prompt_index += 1
+                elif block_dict.get("type") == "reasoning":
+                    reasoning_summary = block_dict.get("summary")
+                    if reasoning_summary and isinstance(reasoning_summary, list):
+                        processed_chunks = [
+                            {"type": "text", "text": chunk.get("text")}
+                            for chunk in reasoning_summary
+                            if isinstance(chunk, dict)
+                            and chunk.get("type") == "summary_text"
+                        ]
+                        _set_span_attribute(
+                            span,
+                            f"{GEN_AI_PROMPT}.{prompt_index}.reasoning",
+                            json_dumps(processed_chunks),
+                        )
+                        _set_span_attribute(
+                            span,
+                            f"{GEN_AI_PROMPT}.{prompt_index}.role",
+                            "assistant",
+                        )
+                    # reasoning is followed by other content parts in the same messge,
+                    # so we don't increment the prompt index
                 # TODO: handle other block types
 
         _set_span_attribute(span, f"{GEN_AI_COMPLETION}.0.role", "assistant")
@@ -381,9 +438,19 @@ def set_data_attributes(traced_response: TracedData, span: Span):
                 )
                 tool_call_index += 1
             elif block_dict.get("type") == "reasoning":
-                _set_span_attribute(
-                    span, f"{GEN_AI_COMPLETION}.0.reasoning", block_dict.get("summary")
-                )
+                reasoning_summary = block_dict.get("summary")
+                if reasoning_summary and isinstance(reasoning_summary, list):
+                    processed_chunks = [
+                        {"type": "text", "text": chunk.get("text")}
+                        for chunk in reasoning_summary
+                        if isinstance(chunk, dict)
+                        and chunk.get("type") == "summary_text"
+                    ]
+                    _set_span_attribute(
+                        span,
+                        "gen_ai.completion.0.reasoning",
+                        json_dumps(processed_chunks),
+                    )
             # TODO: handle other block types, in particular other calls
 
 
@@ -423,6 +490,12 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
                     "model", existing_data.get("request_model", "")
                 ),
                 response_model=existing_data.get("response_model", ""),
+                request_reasoning_summary=kwargs.get("reasoning", {}).get(
+                    "summary", existing_data.get("request_reasoning_summary")
+                ),
+                request_reasoning_effort=kwargs.get("reasoning", {}).get(
+                    "effort", existing_data.get("request_reasoning_effort")
+                ),
             )
         except Exception:
             traced_data = None
@@ -469,9 +542,16 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             ),
             request_model=existing_data.get("request_model", kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
+            request_reasoning_summary=existing_data.get(
+                "request_reasoning_summary", kwargs.get("reasoning", {}).get("summary")
+            ),
+            request_reasoning_effort=existing_data.get(
+                "request_reasoning_effort", kwargs.get("reasoning", {}).get("effort")
+            ),
         )
         responses[parsed_response.id] = traced_data
     except Exception:
+        raise
         return response
 
     if parsed_response.status == "completed":
@@ -521,6 +601,12 @@ async def async_responses_get_or_create_wrapper(
                 output_text=kwargs.get("output_text", existing_data.get("output_text")),
                 request_model=kwargs.get("model", existing_data.get("request_model")),
                 response_model=existing_data.get("response_model"),
+                request_reasoning_summary=kwargs.get("reasoning", {}).get(
+                    "summary", existing_data.get("request_reasoning_summary")
+                ),
+                request_reasoning_effort=kwargs.get("reasoning", {}).get(
+                    "effort", existing_data.get("request_reasoning_effort")
+                ),
             )
         except Exception:
             traced_data = None
@@ -567,6 +653,12 @@ async def async_responses_get_or_create_wrapper(
             ),
             request_model=existing_data.get("request_model", kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
+            request_reasoning_summary=existing_data.get(
+                "request_reasoning_summary", kwargs.get("reasoning", {}).get("summary")
+            ),
+            request_reasoning_effort=existing_data.get(
+                "request_reasoning_effort", kwargs.get("reasoning", {}).get("effort")
+            ),
         )
         responses[parsed_response.id] = traced_data
     except Exception:

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -261,6 +261,15 @@ class TracerWrapper(object):
             return False
         return self._span_processor.force_flush()
 
+    def force_reinit_processor(self):
+        if isinstance(self._span_processor, LaminarSpanProcessor):
+            self._span_processor.force_flush()
+            self._span_processor.force_reinit()
+        else:
+            self._logger.warning(
+                "Not using LaminarSpanProcessor, cannot force reinit processor"
+            )
+
     @classmethod
     def get_session_recording_options(cls) -> SessionRecordingOptions:
         """Get the session recording options set during initialization."""

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -51,9 +51,19 @@ class BedrockInstrumentorInitializer(InstrumentorInitializer):
 
 
 class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
-    def init_instrumentor(
-        self, client, async_client, *args, **kwargs
-    ) -> BaseInstrumentor | None:
+    """Instruments for different versions of browser-use:
+
+    - browser-use < 0.5: BrowserUseLegacyInstrumentor to track agent_step and
+      other structure spans. Session instrumentation is controlled by
+      Instruments.PLAYWRIGHT (or Instruments.PATCHRIGHT for several versions
+      in 0.4.* that used patchright)
+    - browser-use ~= 0.5: Structure spans live in browser_use package itself.
+      Session instrumentation is controlled by Instruments.PLAYWRIGHT
+    - browser-use >= 0.6.0rc1: BubusInstrumentor to keep spans structure.
+      Session instrumentation is controlled by Instruments.BROWSER_USE_SESSION
+    """
+
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("browser-use"):
             return None
 
@@ -65,6 +75,19 @@ class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
 
             return BrowserUseLegacyInstrumentor()
 
+        return None
+
+
+class BrowserUseSessionInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(
+        self, client, async_client, *args, **kwargs
+    ) -> BaseInstrumentor | None:
+        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.6.0rc1"):
             from lmnr.sdk.browser.browser_use_cdp_otel import BrowserUseInstrumentor
 
@@ -73,6 +96,16 @@ class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
         return None
 
 
+class BubusInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("bubus"):
+            return None
+
+        from lmnr.sdk.browser.bubus_otel import BubusInstrumentor
+
+        return BubusInstrumentor()
+
+
 class ChromaInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("chromadb"):
@@ -109,6 +142,26 @@ class CrewAIInstrumentorInitializer(InstrumentorInitializer):
         return CrewAiInstrumentor()
 
 
+class CuaAgentInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("cua-agent"):
+            return None
+
+        from ..opentelemetry.instrumentation.cua_agent import CuaAgentInstrumentor
+
+        return CuaAgentInstrumentor()
+
+
+class CuaComputerInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("cua-computer"):
+            return None
+
+        from ..opentelemetry.instrumentation.cua_computer import CuaComputerInstrumentor
+
+        return CuaComputerInstrumentor()
+
+
 class GoogleGenAIInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("google-genai"):

lmnr/opentelemetry_lib/tracing/exporter.py

@@ -5,7 +5,7 @@ from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter,
 )
-from opentelemetry.exporter.otlp.proto.http import Compression
+from opentelemetry.exporter.otlp.proto.http import Compression as HTTPCompression
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter as HTTPOTLPSpanExporter,
 )
@@ -15,6 +15,10 @@ from lmnr.sdk.utils import from_env
 
 class LaminarSpanExporter(SpanExporter):
     instance: OTLPSpanExporter | HTTPOTLPSpanExporter
+    endpoint: str
+    headers: dict[str, str]
+    timeout: float
+    force_http: bool
 
     def __init__(
         self,
@@ -34,19 +38,30 @@ class LaminarSpanExporter(SpanExporter):
             port = 443 if force_http else 8443
         final_url = f"{url}:{port or 443}"
         api_key = api_key or from_env("LMNR_PROJECT_API_KEY")
-        if force_http:
+        self.endpoint = final_url
+        self.headers = (
+            {"Authorization": f"Bearer {api_key}"}
+            if force_http
+            else {"authorization": f"Bearer {api_key}"}
+        )
+        self.timeout = timeout_seconds
+        self.force_http = force_http
+        self._init_instance()
+
+    def _init_instance(self):
+        if self.force_http:
             self.instance = HTTPOTLPSpanExporter(
-                endpoint=f"{final_url}/v1/traces",
-                headers={"Authorization": f"Bearer {api_key}"},
-                compression=Compression.Gzip,
-                timeout=timeout_seconds,
+                endpoint=self.endpoint,
+                headers=self.headers,
+                compression=HTTPCompression.Gzip,
+                timeout=self.timeout,
             )
         else:
             self.instance = OTLPSpanExporter(
-                endpoint=final_url,
-                headers={"authorization": f"Bearer {api_key}"},
+                endpoint=self.endpoint,
+                headers=self.headers,
+                timeout=self.timeout,
                 compression=grpc.Compression.Gzip,
-                timeout=timeout_seconds,
             )
 
     def export(self, spans: list[ReadableSpan]) -> SpanExportResult:

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -17,9 +17,13 @@ class Instruments(Enum):
     ANTHROPIC = "anthropic"
     BEDROCK = "bedrock"
     BROWSER_USE = "browser_use"
+    BROWSER_USE_SESSION = "browser_use_session"
+    BUBUS = "bubus"
     CHROMA = "chroma"
     COHERE = "cohere"
     CREWAI = "crewai"
+    CUA_AGENT = "cua_agent"
+    CUA_COMPUTER = "cua_computer"
     GOOGLE_GENAI = "google_genai"
     GROQ = "groq"
     HAYSTACK = "haystack"
@@ -60,9 +64,13 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.ANTHROPIC: initializers.AnthropicInstrumentorInitializer(),
     Instruments.BEDROCK: initializers.BedrockInstrumentorInitializer(),
     Instruments.BROWSER_USE: initializers.BrowserUseInstrumentorInitializer(),
+    Instruments.BROWSER_USE_SESSION: initializers.BrowserUseSessionInstrumentorInitializer(),
+    Instruments.BUBUS: initializers.BubusInstrumentorInitializer(),
     Instruments.CHROMA: initializers.ChromaInstrumentorInitializer(),
     Instruments.COHERE: initializers.CohereInstrumentorInitializer(),
     Instruments.CREWAI: initializers.CrewAIInstrumentorInitializer(),
+    Instruments.CUA_AGENT: initializers.CuaAgentInstrumentorInitializer(),
+    Instruments.CUA_COMPUTER: initializers.CuaComputerInstrumentorInitializer(),
     Instruments.GOOGLE_GENAI: initializers.GoogleGenAIInstrumentorInitializer(),
     Instruments.GROQ: initializers.GroqInstrumentorInitializer(),
     Instruments.HAYSTACK: initializers.HaystackInstrumentorInitializer(),

lmnr/opentelemetry_lib/tracing/processor.py

@@ -1,3 +1,4 @@
+import logging
 import uuid
 
 from opentelemetry.sdk.trace.export import (
@@ -19,13 +20,16 @@ from lmnr.opentelemetry_lib.tracing.attributes import (
     SPAN_SDK_VERSION,
 )
 from lmnr.opentelemetry_lib.tracing.exporter import LaminarSpanExporter
+from lmnr.sdk.log import get_default_logger
 from lmnr.version import PYTHON_VERSION, __version__
 
 
 class LaminarSpanProcessor(SpanProcessor):
     instance: BatchSpanProcessor | SimpleSpanProcessor
+    logger: logging.Logger
     __span_id_to_path: dict[int, list[str]] = {}
     __span_id_lists: dict[int, list[str]] = {}
+    max_export_batch_size: int
 
     def __init__(
         self,
@@ -38,6 +42,8 @@ class LaminarSpanProcessor(SpanProcessor):
         disable_batch: bool = False,
         exporter: SpanExporter | None = None,
     ):
+        self.logger = get_default_logger(__name__)
+        self.max_export_batch_size = max_export_batch_size
         self.exporter = exporter or LaminarSpanExporter(
             base_url=base_url,
             port=port,
@@ -86,6 +92,26 @@ class LaminarSpanProcessor(SpanProcessor):
     def force_flush(self, timeout_millis: int = 30000) -> bool:
         return self.instance.force_flush(timeout_millis)
 
+    def force_reinit(self):
+        if not isinstance(self.exporter, LaminarSpanExporter):
+            self.logger.warning(
+                "LaminarSpanProcessor is not using LaminarSpanExporter, cannot force reinit"
+            )
+            return
+        self.instance.shutdown()
+        disable_batch = isinstance(self.instance, SimpleSpanProcessor)
+        del self.exporter.instance
+        del self.instance
+
+        self.exporter._init_instance()
+        self.instance = (
+            SimpleSpanProcessor(self.exporter)
+            if disable_batch
+            else BatchSpanProcessor(
+                self.exporter, max_export_batch_size=self.max_export_batch_size
+            )
+        )
+
     def shutdown(self):
         self.instance.shutdown()
 

lmnr/sdk/browser/browser_use_cdp_otel.py

@@ -1,3 +1,6 @@
+import asyncio
+import uuid
+
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 from lmnr.sdk.browser.utils import with_tracer_and_client_wrapper
 from lmnr.version import __version__
@@ -12,7 +15,6 @@ from opentelemetry.instrumentation.utils import unwrap
 from opentelemetry.trace import get_tracer, Tracer
 from typing import Collection
 from wrapt import wrap_function_wrapper
-import uuid
 
 # Stable versions, e.g. 0.6.0, satisfy this condition too
 _instruments = ("browser-use >= 0.6.0rc1",)
@@ -33,12 +35,7 @@ WRAPPED_METHODS = [
 ]
 
 
-@with_tracer_and_client_wrapper
-async def _wrap(
-    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
-):
-    result = await wrapped(*args, **kwargs)
-
+async def process_wrapped_result(result, instance, client, to_wrap):
     if to_wrap.get("action") == "inject_session_recorder":
         is_registered = await is_recorder_present(result)
         if not is_registered:
@@ -50,6 +47,14 @@ async def _wrap(
             cdp_session = await instance.get_or_create_cdp_session(target_id)
             await take_full_snapshot(cdp_session)
 
+
+@with_tracer_and_client_wrapper
+async def _wrap(
+    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
+    result = await wrapped(*args, **kwargs)
+    asyncio.create_task(process_wrapped_result(result, instance, client, to_wrap))
+
     return result
 
 

lmnr/sdk/browser/bubus_otel.py

@@ -0,0 +1,71 @@
+from typing import Collection
+
+from lmnr import Laminar
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
+from lmnr.sdk.log import get_default_logger
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import NonRecordingSpan, get_current_span
+from wrapt import wrap_function_wrapper
+
+
+_instruments = ("bubus >= 1.3.0",)
+event_id_to_span_context = {}
+logger = get_default_logger(__name__)
+
+
+def wrap_dispatch(wrapped, instance, args, kwargs):
+    event = args[0] if args and len(args) > 0 else kwargs.get("event", None)
+    if event and hasattr(event, "event_id"):
+        event_id = event.event_id
+        if event_id:
+            span = get_current_span(get_current_context())
+            event_id_to_span_context[event_id] = span.get_span_context()
+    return wrapped(*args, **kwargs)
+
+
+async def wrap_process_event(wrapped, instance, args, kwargs):
+    event = args[0] if args and len(args) > 0 else kwargs.get("event", None)
+    span_context = None
+    if event and hasattr(event, "event_id"):
+        event_id = event.event_id
+        if event_id:
+            span_context = event_id_to_span_context.get(event_id)
+    if not span_context:
+        return await wrapped(*args, **kwargs)
+    if not Laminar.is_initialized():
+        return await wrapped(*args, **kwargs)
+    with Laminar.use_span(NonRecordingSpan(span_context)):
+        return await wrapped(*args, **kwargs)
+
+
+class BubusInstrumentor(BaseInstrumentor):
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        try:
+            wrap_function_wrapper("bubus.service", "EventBus.dispatch", wrap_dispatch)
+        except (ModuleNotFoundError, ImportError):
+            pass
+        try:
+            wrap_function_wrapper(
+                "bubus.service", "EventBus.process_event", wrap_process_event
+            )
+        except (ModuleNotFoundError, ImportError):
+            pass
+
+    def _uninstrument(self, **kwargs):
+        try:
+            unwrap("bubus.service", "EventBus.dispatch")
+        except (ModuleNotFoundError, ImportError):
+            pass
+        try:
+            unwrap("bubus.service", "EventBus.process_event")
+        except (ModuleNotFoundError, ImportError):
+            pass
+        event_id_to_span_context.clear()