lmnr 0.4.64__py3-none-any.whl → 0.4.66__py3-none-any.whl

lmnr/openllmetry_sdk/instruments.py

@@ -7,6 +7,7 @@ class Instruments(Enum):
     ALEPHALPHA = "alephalpha"
     ANTHROPIC = "anthropic"
     BEDROCK = "bedrock"
+    BROWSER_USE = "browser_use"
     CHROMA = "chroma"
     COHERE = "cohere"
     GOOGLE_GENERATIVEAI = "google_generativeai"

lmnr/openllmetry_sdk/tracing/tracing.py

@@ -6,7 +6,6 @@ import uuid
 from contextvars import Context
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.openllmetry_sdk.instruments import Instruments
-from lmnr.sdk.browser import init_browser_tracing
 from lmnr.openllmetry_sdk.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     SPAN_IDS_PATH,
@@ -28,7 +27,7 @@ from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
 )
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import Compression
 from opentelemetry.instrumentation.threading import ThreadingInstrumentor
-from opentelemetry.context import get_value, attach, get_current, set_value, Context
+from opentelemetry.context import get_value, attach, get_current, set_value
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.propagators.textmap import TextMapPropagator
 from opentelemetry.sdk.resources import Resource
@@ -38,7 +37,7 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
     BatchSpanProcessor,
 )
-from opentelemetry.sdk.trace import SpanLimits
+from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 
 from typing import Dict, Optional, Set
 
@@ -238,6 +237,10 @@ def set_association_properties(properties: dict) -> None:
     _set_association_properties_attributes(span, properties)
 
 
+def get_association_properties(context: Optional[Context] = None) -> dict:
+    return get_value("association_properties", context) or {}
+
+
 def update_association_properties(
     properties: dict,
     set_on_current_span: bool = True,
@@ -296,18 +299,21 @@ def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExpor
 # TODO: check if it's safer to use the default tracer provider obtained from
 # get_tracer_provider()
 def init_tracer_provider(resource: Resource) -> TracerProvider:
-    tracer_provider = TracerProvider(
-        resource=resource,
-        span_limits=SpanLimits(
-            # this defaults to 128, which causes us to drop messages
-            max_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
-            max_span_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
-            max_event_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
-            max_events=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
-        ),
-    )
+    provider: TracerProvider = None
+    default_provider: TracerProvider = get_tracer_provider()
+
+    if isinstance(default_provider, ProxyTracerProvider):
+        provider = TracerProvider(resource=resource)
+        trace.set_tracer_provider(provider)
+    elif not hasattr(default_provider, "add_span_processor"):
+        module_logger.error(
+            "Cannot add span processor to the default provider since it doesn't support it"
+        )
+        return
+    else:
+        provider = default_provider
 
-    return tracer_provider
+    return provider
 
 
 def init_instrumentations(
@@ -428,7 +434,10 @@ def init_instrumentations(
             if init_weaviate_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.PLAYWRIGHT:
-            if init_browser_tracing(base_http_url, project_api_key):
+            if init_playwright_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.BROWSER_USE:
+            if init_browser_use_instrumentor():
                 instrument_set = True
         else:
             module_logger.warning(
@@ -443,6 +452,32 @@ def init_instrumentations(
     return instrument_set
 
 
+def init_browser_use_instrumentor():
+    try:
+        if is_package_installed("browser-use"):
+            from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
+
+            instrumentor = BrowserUseInstrumentor()
+            instrumentor.instrument()
+        return True
+    except Exception as e:
+        module_logger.error(f"Error initializing BrowserUse instrumentor: {e}")
+        return False
+
+
+def init_playwright_instrumentor():
+    try:
+        if is_package_installed("playwright"):
+            from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
+
+            instrumentor = PlaywrightInstrumentor()
+            instrumentor.instrument()
+        return True
+    except Exception as e:
+        module_logger.error(f"Error initializing Playwright instrumentor: {e}")
+        return False
+
+
 def init_openai_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("openai") and is_package_installed(

lmnr/sdk/browser/__init__.py

@@ -1,9 +0,0 @@
-from lmnr.openllmetry_sdk.utils.package_check import is_package_installed
-
-
-def init_browser_tracing(http_url: str, project_api_key: str):
-    if is_package_installed("playwright"):
-        from .playwright_patch import init_playwright_tracing
-
-        init_playwright_tracing(http_url, project_api_key)
-    # Other browsers can be added here

lmnr/sdk/browser/browser_use_otel.py

@@ -0,0 +1,117 @@
+from lmnr.openllmetry_sdk.decorators.base import json_dumps
+from lmnr.sdk.browser.utils import _with_tracer_wrapper
+from lmnr.sdk.utils import get_input_from_func_args
+from lmnr.version import SDK_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
+
+_instruments = ("browser-use >= 0.1.0",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "browser_use.agent.service",
+        "object": "Agent",
+        "method": "run",
+        "span_name": "agent.run",
+        "ignore_input": False,
+        "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": False,
+        "span_type": "DEFAULT",
+    },
+    {
+        "package": "browser_use.controller.registry.service",
+        "object": "Registry",
+        "method": "execute_action",
+        "ignore_input": False,
+        "ignore_output": False,
+        "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"):
+            attributes["lmnr.span.input"] = json_dumps(
+                get_input_from_func_args(wrapped, True, args, kwargs)
+            )
+    with tracer.start_as_current_span(span_name, attributes=attributes) as span:
+        span.set_attributes(attributes)
+        result = await wrapped(*args, **kwargs)
+        if not to_wrap.get("ignore_output"):
+            span.set_attribute("lmnr.span.output", json_dumps(result))
+        return result
+
+
+class BrowserUseInstrumentor(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__, SDK_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/playwright_otel.py

@@ -0,0 +1,310 @@
+import asyncio
+import logging
+import os
+import threading
+import time
+import uuid
+
+from lmnr.sdk.browser.utils import (
+    INJECT_PLACEHOLDER,
+    _with_tracer_wrapper,
+    retry_sync,
+    retry_async,
+)
+from lmnr.sdk.client import LaminarClient
+from lmnr.version import PYTHON_VERSION, SDK_VERSION
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer, Tracer, get_current_span
+from typing import Collection
+from wrapt import wrap_function_wrapper
+
+try:
+    from playwright.async_api import Page
+    from playwright.sync_api import Page as SyncPage
+except ImportError as e:
+    raise ImportError(
+        f"Attempted to import {__file__}, but it is designed "
+        "to patch Playwright, which is not installed. Use `pip install playwright` "
+        "to install Playwright or remove this import."
+    ) from e
+
+# all available versions at https://pypi.org/project/playwright/#history
+_instruments = ("playwright >= 1.9.0",)
+logger = logging.getLogger(__name__)
+
+WRAPPED_METHODS = [
+    {
+        "package": "playwright.sync_api",
+        "object": "BrowserContext",
+        "method": "new_page",
+    }
+]
+
+WRAPPED_METHODS_ASYNC = [
+    {
+        "package": "playwright.async_api",
+        "object": "BrowserContext",
+        "method": "new_page",
+    }
+]
+
+_original_new_page = None
+_original_new_page_async = None
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(current_dir, "rrweb", "rrweb.min.js"), "r") as f:
+    RRWEB_CONTENT = f"() => {{ {f.read()} }}"
+
+
+async def send_events_async(page: Page, session_id: str, trace_id: str):
+    """Fetch events from the page and send them to the server"""
+    try:
+        # Check if function exists first
+        has_function = await page.evaluate(
+            """
+            () => typeof window.lmnrGetAndClearEvents === 'function'
+        """
+        )
+        if not has_function:
+            return
+
+        events = await page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
+            return
+
+        await LaminarClient.send_browser_events(
+            session_id, trace_id, events, f"python@{PYTHON_VERSION}"
+        )
+
+    except Exception as e:
+        logger.error(f"Error sending events: {e}")
+
+
+def send_events_sync(page: SyncPage, session_id: str, trace_id: str):
+    """Synchronous version of send_events"""
+    try:
+        # Check if function exists first
+        has_function = page.evaluate(
+            """
+            () => typeof window.lmnrGetAndClearEvents === 'function'
+        """
+        )
+        if not has_function:
+            return
+
+        events = page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
+            return
+
+        LaminarClient.send_browser_events_sync(
+            session_id, trace_id, events, f"python@{PYTHON_VERSION}"
+        )
+
+    except Exception as e:
+        logger.error(f"Error sending events: {e}")
+
+
+def inject_rrweb(page: SyncPage):
+    try:
+        page.wait_for_load_state("domcontentloaded")
+
+        # Wrap the evaluate call in a try-catch
+        try:
+            is_loaded = page.evaluate(
+                """() => typeof window.lmnrRrweb !== 'undefined'"""
+            )
+        except Exception as e:
+            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            is_loaded = False
+
+        if not is_loaded:
+
+            def load_rrweb():
+                try:
+                    page.evaluate(RRWEB_CONTENT)
+                    page.wait_for_function(
+                        """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                        timeout=5000,
+                    )
+                    return True
+                except Exception as e:
+                    logger.debug(f"Failed to load rrweb: {e}")
+                    return False
+
+            if not retry_sync(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        try:
+            page.evaluate(INJECT_PLACEHOLDER)
+        except Exception as e:
+            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+    except Exception as e:
+        logger.error(f"Error during rrweb injection: {e}")
+
+
+async def inject_rrweb_async(page: Page):
+    try:
+        await page.wait_for_load_state("domcontentloaded")
+
+        # Wrap the evaluate call in a try-catch
+        try:
+            is_loaded = await page.evaluate(
+                """() => typeof window.lmnrRrweb !== 'undefined'"""
+            )
+        except Exception as e:
+            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            is_loaded = False
+
+        if not is_loaded:
+
+            async def load_rrweb():
+                try:
+                    await page.evaluate(RRWEB_CONTENT)
+                    await page.wait_for_function(
+                        """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                        timeout=5000,
+                    )
+                    return True
+                except Exception as e:
+                    logger.debug(f"Failed to load rrweb: {e}")
+                    return False
+
+            if not await retry_async(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        try:
+            await page.evaluate(INJECT_PLACEHOLDER)
+        except Exception as e:
+            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+    except Exception as e:
+        logger.error(f"Error during rrweb injection: {e}")
+
+
+def handle_navigation(page: SyncPage, session_id: str, trace_id: str):
+    def on_load():
+        try:
+            inject_rrweb(page)
+        except Exception as e:
+            logger.error(f"Error in on_load handler: {e}")
+
+    page.on("load", on_load)
+    inject_rrweb(page)
+
+    def collection_loop():
+        while not page.is_closed():  # Stop when page closes
+            send_events_sync(page, session_id, trace_id)
+            time.sleep(2)
+
+    thread = threading.Thread(target=collection_loop, daemon=True)
+    thread.start()
+
+
+async def handle_navigation_async(page: Page, session_id: str, trace_id: str):
+    async def on_load():
+        try:
+            await inject_rrweb_async(page)
+        except Exception as e:
+            logger.error(f"Error in on_load handler: {e}")
+
+    page.on("load", lambda: asyncio.create_task(on_load()))
+    await inject_rrweb_async(page)
+
+    async def collection_loop():
+        try:
+            while not page.is_closed():  # Stop when page closes
+                await send_events_async(page, session_id, trace_id)
+                await asyncio.sleep(2)
+            logger.info("Event collection stopped")
+        except Exception as e:
+            logger.error(f"Event collection stopped: {e}")
+
+    # Create and store task
+    task = asyncio.create_task(collection_loop())
+
+    # Clean up task when page closes
+    page.on("close", lambda: task.cancel())
+
+
+@_with_tracer_wrapper
+def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(
+        f"browser_context.{to_wrap.get('method')}"
+    ) as span:
+        page = wrapped(*args, **kwargs)
+        session_id = str(uuid.uuid4().hex)
+        trace_id = format(get_current_span().get_span_context().trace_id, "032x")
+        span.set_attribute("lmnr.internal.has_browser_session", True)
+        handle_navigation(page, session_id, trace_id)
+        return page
+
+
+@_with_tracer_wrapper
+async def _wrap_async(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(
+        f"browser_context.{to_wrap.get('method')}"
+    ) as span:
+        page = await wrapped(*args, **kwargs)
+        session_id = str(uuid.uuid4().hex)
+        trace_id = format(get_current_span().get_span_context().trace_id, "032x")
+        span.set_attribute("lmnr.internal.has_browser_session", True)
+        await handle_navigation_async(page, session_id, trace_id)
+        return page
+
+
+class PlaywrightInstrumentor(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__, SDK_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
+
+        for wrapped_method in WRAPPED_METHODS_ASYNC:
+            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_async(
+                        tracer,
+                        wrapped_method,
+                    ),
+                )
+            except ModuleNotFoundError:
+                pass  # that's ok, we're not instrumenting everything
+
+    def _uninstrument(self, **kwargs):
+        for wrapped_method in [*WRAPPED_METHODS, *WRAPPED_METHODS_ASYNC]:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+            unwrap(wrap_package, f"{wrap_object}.{wrap_method}")

lmnr/sdk/browser/utils.py

@@ -0,0 +1,104 @@
+import asyncio
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+
+INJECT_PLACEHOLDER = """
+() => {
+    const BATCH_SIZE = 1000;  // Maximum events to store in memory
+    
+    window.lmnrRrwebEventsBatch = [];
+    
+    // Utility function to compress individual event data
+    async function compressEventData(data) {
+        const jsonString = JSON.stringify(data);
+        const blob = new Blob([jsonString], { type: 'application/json' });
+        const compressedStream = blob.stream().pipeThrough(new CompressionStream('gzip'));
+        const compressedResponse = new Response(compressedStream);
+        const compressedData = await compressedResponse.arrayBuffer();
+        return Array.from(new Uint8Array(compressedData));
+    }
+    
+    window.lmnrGetAndClearEvents = () => {
+        const events = window.lmnrRrwebEventsBatch;
+        window.lmnrRrwebEventsBatch = [];
+        return events;
+    };
+
+    // Add heartbeat events
+    setInterval(async () => {
+        const heartbeat = {
+            type: 6,
+            data: await compressEventData({ source: 'heartbeat' }),
+            timestamp: Date.now()
+        };
+        
+        window.lmnrRrwebEventsBatch.push(heartbeat);
+        
+        // Prevent memory issues by limiting batch size
+        if (window.lmnrRrwebEventsBatch.length > BATCH_SIZE) {
+            window.lmnrRrwebEventsBatch = window.lmnrRrwebEventsBatch.slice(-BATCH_SIZE);
+        }
+    }, 1000);
+
+    window.lmnrRrweb.record({
+        async emit(event) {
+            // Compress the data field
+            const compressedEvent = {
+                ...event,
+                data: await compressEventData(event.data)
+            };
+            window.lmnrRrwebEventsBatch.push(compressedEvent);
+        }
+    });
+}
+"""
+
+
+def _with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    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
+
+
+def retry_sync(func, retries=5, delay=0.5, error_message="Operation failed"):
+    """Utility function for retry logic in synchronous operations"""
+    for attempt in range(retries):
+        try:
+            result = func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        time.sleep(delay)
+    return None
+
+
+async def retry_async(func, retries=5, delay=0.5, error_message="Operation failed"):
+    """Utility function for retry logic in asynchronous operations"""
+    for attempt in range(retries):
+        try:
+            result = await func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        await asyncio.sleep(delay)
+    return None