lmnr 0.4.53.dev0__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/sdk/browser/background_send_events.py

@@ -0,0 +1,158 @@
+"""
+Background sending for browser events.
+
+This module provides background execution for HTTP requests that send browser events,
+ensuring sends never block the main execution flow while guaranteeing completion at
+program exit.
+
+## Background Event Loop Architecture
+Uses a dedicated event loop running in a separate thread to handle async HTTP requests.
+This architecture provides:
+
+1. **Non-blocking execution**: Sends happen in the background, never blocking the main
+   thread or Playwright's event loop, allowing browser automation to continue smoothly.
+
+2. **Guaranteed completion**: When the program exits, all pending async sends are
+   awaited and complete successfully, even if they're slow. No events are dropped.
+
+3. **Lifecycle independence**: The background loop runs independently of Playwright's
+   event loop, so it survives when Playwright shuts down its internal loop before
+   program exit.
+
+The pattern uses `asyncio.run_coroutine_threadsafe()` to submit async coroutines
+from any thread (sync or async) to our background loop, maintaining pure async code
+while achieving cross-thread execution.
+"""
+
+import asyncio
+import atexit
+import threading
+from typing import Any
+
+from lmnr.sdk.log import get_default_logger
+
+logger = get_default_logger(__name__)
+
+# Timeout for waiting for each async send operation at exit
+ASYNC_SEND_TIMEOUT_SECONDS = 30
+
+# Timeout for background loop creation
+LOOP_CREATION_TIMEOUT_SECONDS = 5
+
+# Timeout for thread join during cleanup
+THREAD_JOIN_TIMEOUT_SECONDS = 5
+
+# ==============================================================================
+# Background event loop for async sends
+# ==============================================================================
+
+# Background event loop state
+_background_loop = None
+_background_loop_thread = None
+_background_loop_lock = threading.Lock()
+_background_loop_ready = threading.Event()
+_pending_async_futures: set[asyncio.Future[Any]] = set()
+
+
+def get_background_loop() -> asyncio.AbstractEventLoop:
+    """
+    Get or create the background event loop for async sends.
+
+    Creates a dedicated event loop running in a daemon thread on first call.
+    Subsequent calls return the same loop. Thread-safe.
+
+    Returns:
+        The background event loop running in a separate thread.
+    """
+    global _background_loop, _background_loop_thread
+
+    with _background_loop_lock:
+        if _background_loop is None:
+            # Create a new event loop in a background thread
+            def run_loop():
+                global _background_loop
+                _background_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(_background_loop)
+                _background_loop_ready.set()
+                _background_loop.run_forever()
+
+            _background_loop_thread = threading.Thread(
+                target=run_loop, daemon=True, name="lmnr-async-sends"
+            )
+            _background_loop_thread.start()
+
+            # Register cleanup handler
+            atexit.register(_cleanup_background_loop)
+
+    # Wait for loop to be created (outside the lock to avoid blocking other threads)
+    if not _background_loop_ready.wait(timeout=LOOP_CREATION_TIMEOUT_SECONDS):
+        raise RuntimeError("Background loop creation timed out")
+
+    return _background_loop
+
+
+def track_async_send(future: asyncio.Future) -> None:
+    """
+    Track an async send future for cleanup at exit.
+
+    The future is automatically removed from tracking when it completes,
+    preventing memory leaks.
+
+    Args:
+        future: The future returned by asyncio.run_coroutine_threadsafe()
+    """
+    with _background_loop_lock:
+        _pending_async_futures.add(future)
+
+    def remove_on_done(f):
+        """Remove the future from tracking when it completes."""
+        with _background_loop_lock:
+            _pending_async_futures.discard(f)
+
+    future.add_done_callback(remove_on_done)
+
+
+def _cleanup_background_loop():
+    """
+    Shutdown the background event loop and wait for all pending sends to complete.
+
+    Called automatically at program exit via atexit. Waits for each pending send
+    to complete with a timeout, then stops the background loop gracefully.
+    """
+    global _background_loop
+
+    # Create a snapshot of pending futures to avoid holding the lock during waits
+    with _background_loop_lock:
+        futures_to_wait = list(_pending_async_futures)
+
+    pending_count = len(futures_to_wait)
+
+    if pending_count > 0:
+        logger.info(
+            f"Finishing sending {pending_count} browser events... "
+            "Ctrl+C to cancel (may result in incomplete session recording)."
+        )
+
+        # Wait for all pending futures to complete
+        for future in futures_to_wait:
+            try:
+                future.result(timeout=ASYNC_SEND_TIMEOUT_SECONDS)
+            except TimeoutError:
+                logger.debug("Timeout waiting for async send to complete")
+            except KeyboardInterrupt:
+                logger.debug("Interrupted, cancelling pending async sends")
+                for f in futures_to_wait:
+                    f.cancel()
+                raise
+            except Exception as e:
+                logger.debug(f"Error in async send: {e}")
+
+    # Stop the background loop
+    if _background_loop is not None and not _background_loop.is_closed():
+        try:
+            _background_loop.call_soon_threadsafe(_background_loop.stop)
+            # Wait for thread to finish
+            if _background_loop_thread is not None:
+                _background_loop_thread.join(timeout=THREAD_JOIN_TIMEOUT_SECONDS)
+        except Exception as e:
+            logger.debug(f"Error stopping background loop: {e}")

lmnr/sdk/browser/browser_use_cdp_otel.py

@@ -0,0 +1,100 @@
+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__
+from lmnr.sdk.browser.cdp_utils import (
+    is_recorder_present,
+    start_recording_events,
+    take_full_snapshot,
+)
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer, Tracer
+from typing import Collection
+from wrapt import wrap_function_wrapper
+
+# Stable versions, e.g. 0.6.0, satisfy this condition too
+_instruments = ("browser-use >= 0.6.0rc1",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "browser_use.browser.session",
+        "object": "BrowserSession",
+        "method": "get_or_create_cdp_session",
+        "action": "inject_session_recorder",
+    },
+    {
+        "package": "browser_use.browser.session",
+        "object": "BrowserSession",
+        "method": "on_SwitchTabEvent",
+        "action": "take_full_snapshot",
+    },
+]
+
+
+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:
+            await start_recording_events(result, str(uuid.uuid4()), client)
+
+    if to_wrap.get("action") == "take_full_snapshot":
+        target_id = result
+        if target_id:
+            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
+
+
+class BrowserUseInstrumentor(BaseInstrumentor):
+    def __init__(self, async_client: AsyncLaminarClient):
+        super().__init__()
+        self.async_client = async_client
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        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(
+                        tracer,
+                        self.async_client,
+                        wrapped_method,
+                    ),
+                )
+            except (ModuleNotFoundError, ImportError):
+                pass  # that's ok, we're not instrumenting everything
+
+    def _uninstrument(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")
+
+            unwrap(
+                f"{wrap_package}.{wrap_object}" if wrap_object else wrap_package,
+                wrap_method,
+            )

lmnr/sdk/browser/browser_use_otel.py

@@ -0,0 +1,142 @@
+from lmnr import Laminar
+from lmnr.sdk.browser.utils import with_tracer_wrapper
+from lmnr.sdk.utils import get_input_from_func_args, json_dumps
+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 typing import Collection
+from wrapt import wrap_function_wrapper
+import pydantic
+
+try:
+    from browser_use import AgentHistoryList
+except ImportError as e:
+    raise ImportError(
+        f"Attempted to import {__file__}, but it is designed "
+        "to patch Browser Use < 0.5.0, which is not installed. Use `pip install browser-use` "
+        "to install Browser Use or remove this import."
+    ) from e
+
+_instruments = ("browser-use < 0.5.0",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "browser_use.agent.service",
+        "object": "Agent",
+        "method": "run",
+        "span_name": "agent.run",
+        "ignore_input": True,
+        "ignore_output": True,
+        "span_type": "DEFAULT",
+    },
+    {
+        "package": "browser_use.agent.service",
+        "object": "Agent",
+        "method": "step",
+        "span_name": "agent.step",
+        "ignore_input": True,
+        "ignore_output": True,
+        "span_type": "DEFAULT",
+    },
+    {
+        "package": "browser_use.controller.service",
+        "object": "Controller",
+        "method": "act",
+        "span_name": "controller.act",
+        "ignore_input": True,
+        "ignore_output": True,
+        "span_type": "DEFAULT",
+    },
+    {
+        "package": "browser_use.controller.registry.service",
+        "object": "Registry",
+        "method": "execute_action",
+        "ignore_input": True,
+        "ignore_output": True,
+        "span_type": "TOOL",
+    },
+]
+
+
+@with_tracer_wrapper
+async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    span_name = to_wrap.get("span_name")
+    attributes = {
+        "lmnr.span.type": to_wrap.get("span_type"),
+    }
+    if to_wrap.get("method") == "execute_action":
+        span_name = args[0] if len(args) > 0 else kwargs.get("action_name", "action")
+        attributes["lmnr.span.input"] = json_dumps(
+            {
+                "action": span_name,
+                "params": args[1] if len(args) > 1 else kwargs.get("params", {}),
+            }
+        )
+    else:
+        if not to_wrap.get("ignore_input"):
+            inp_dict = get_input_from_func_args(wrapped, True, args, kwargs)
+            # Add task to the `agent.run` span input
+            if to_wrap.get("method") == "run" and hasattr(instance, "task"):
+                inp_dict["task"] = instance.task
+            attributes["lmnr.span.input"] = json_dumps(inp_dict)
+    if to_wrap.get("method") == "step" and to_wrap.get("object") == "Agent":
+        # Add step number to the `agent.step` span name
+        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 Laminar.start_as_current_span(span_name) as span:
+        result = await wrapped(*args, **kwargs)
+        if not to_wrap.get("ignore_output"):
+            to_serialize = result
+            if isinstance(result, AgentHistoryList):
+                to_serialize = result.final_result()
+            serialized = (
+                to_serialize.model_dump_json()
+                if isinstance(to_serialize, pydantic.BaseModel)
+                else json_dumps(to_serialize)
+            )
+            span.set_attribute("lmnr.span.output", serialized)
+        return result
+
+
+class BrowserUseLegacyInstrumentor(BaseInstrumentor):
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        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(
+                        tracer,
+                        wrapped_method,
+                    ),
+                )
+            except ModuleNotFoundError:
+                pass  # that's ok, we're not instrumenting everything
+
+    def _uninstrument(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")
+
+            unwrap(
+                f"{wrap_package}.{wrap_object}" if wrap_object else wrap_package,
+                wrap_method,
+            )

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()