lmnr 0.7.9__py3-none-any.whl → 0.7.11__py3-none-any.whl

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -219,8 +219,19 @@ class TracerWrapper(object):
 
     @classmethod
     def verify_initialized(cls) -> bool:
-        with cls._lock:
-            return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
+        # This is not using lock, but it is fine to return False from here
+        # even if initialization is going on.
+
+        # If we try to acquire the lock here, it may deadlock if an automatic
+        # instrumentation is importing a file that (at the top level) has a
+        # function annotated with Laminar's `observe` decorator.
+        # The decorator is evaluated at import time, inside `init_instrumentations`,
+        # which is called by the `TracerWrapper` constructor while holding the lock.
+        # Without the lock here, we will simply return False, which will cause
+        # the decorator to return the original function. This is fine, at runtime,
+        # the next import statement will re-evaluate the decorator, and Laminar will
+        # have been initialized by that time.
+        return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
 
     @classmethod
     def clear(cls):

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"):

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -17,6 +17,8 @@ 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"
@@ -60,6 +62,8 @@ 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(),

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

lmnr/sdk/browser/cdp_utils.py

@@ -1,8 +1,8 @@
-import orjson
+import asyncio
 import logging
+import orjson
 import os
 import time
-import asyncio
 
 from opentelemetry import trace
 
@@ -16,6 +16,11 @@ from lmnr.sdk.types import MaskInputOptions
 logger = logging.getLogger(__name__)
 
 OLD_BUFFER_TIMEOUT = 60
+CDP_OPERATION_TIMEOUT_SECONDS = 10
+
+# CDP ContextId is int
+frame_to_isolated_context_id: dict[str, int] = {}
+lock = asyncio.Lock()
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 with open(os.path.join(current_dir, "recorder", "record.umd.min.cjs"), "r") as f:
@@ -448,8 +453,6 @@ INJECT_PLACEHOLDER = """
         }
     }
 
-    setInterval(sendBatchIfReady, BATCH_TIMEOUT);
-
     async function bufferToBase64(buffer) {
         const base64url = await new Promise(r => {
             const reader = new FileReader()
@@ -458,55 +461,152 @@ INJECT_PLACEHOLDER = """
         });
         return base64url.slice(base64url.indexOf(',') + 1);
     }
- 
-    window.lmnrRrweb.record({
-        async emit(event) {
-            try {
-                const isLarge = isLargeEvent(event.type);
-                const compressedResult = isLarge ?
-                    await compressLargeObject(event.data) :
-                    await compressSmallObject(event.data);
-
-                const base64Data = await bufferToBase64(compressedResult);
-                const eventToSend = {
-                    ...event,
-                    data: base64Data,
-                };
-                window.lmnrRrwebEventsBatch.push(eventToSend);
-            } catch (error) {
-                console.warn('Failed to push event to batch', error);
+
+    if (!window.lmnrStartedRecordingEvents) {
+        setInterval(sendBatchIfReady, BATCH_TIMEOUT);
+
+        window.lmnrRrweb.record({
+            async emit(event) {
+                try {
+                    const isLarge = isLargeEvent(event.type);
+                    const compressedResult = isLarge ?
+                        await compressLargeObject(event.data) :
+                        await compressSmallObject(event.data);
+
+                    const base64Data = await bufferToBase64(compressedResult);
+                    const eventToSend = {
+                        ...event,
+                        data: base64Data,
+                    };
+                    window.lmnrRrwebEventsBatch.push(eventToSend);
+                } catch (error) {
+                    console.warn('Failed to push event to batch', error);
+                }
+            },
+            recordCanvas: true,
+            collectFonts: true,
+            recordCrossOriginIframes: true,
+            maskInputOptions: {
+                password: true,
+                textarea: maskInputOptions.textarea || false,
+                text: maskInputOptions.text || false,
+                number: maskInputOptions.number || false,
+                select: maskInputOptions.select || false,
+                email: maskInputOptions.email || false,
+                tel: maskInputOptions.tel || false,
             }
-        },
-        recordCanvas: true,
-        collectFonts: true,
-        recordCrossOriginIframes: true,
-        maskInputOptions: {
-            password: true,
-            textarea: maskInputOptions.textarea || false,
-            text: maskInputOptions.text || false,
-            number: maskInputOptions.number || false,
-            select: maskInputOptions.select || false,
-            email: maskInputOptions.email || false,
-            tel: maskInputOptions.tel || false,
+        });
+
+        function heartbeat() {
+            // Add heartbeat events
+            setInterval(() => {
+                window.lmnrRrweb.record.addCustomEvent('heartbeat', {
+                    title: document.title,
+                        url: document.URL,
+                    })
+                }, HEARTBEAT_INTERVAL
+            );
         }
-    });
-
-    function heartbeat() {
-        // Add heartbeat events
-        setInterval(() => {
-            window.lmnrRrweb.record.addCustomEvent('heartbeat', {
-                title: document.title,
-                    url: document.URL,
-                })
-            }, HEARTBEAT_INTERVAL
-        );
-    }
 
-    heartbeat();
+        heartbeat();
+        window.lmnrStartedRecordingEvents = true;
+    }
 }
 """
 
 
+async def should_skip_page(cdp_session):
+    """Checks if the page url is an error page or an empty page.
+    This function returns True in case of any error in our code, because
+    it is safer to not record events than to try to inject the recorder
+    into something that is already broken.
+    """
+    cdp_client = cdp_session.cdp_client
+
+    try:
+        # Get the current page URL
+        result = await asyncio.wait_for(
+            cdp_client.send.Runtime.evaluate(
+                {
+                    "expression": "window.location.href",
+                    "returnByValue": True,
+                },
+                session_id=cdp_session.session_id,
+            ),
+            timeout=CDP_OPERATION_TIMEOUT_SECONDS,
+        )
+
+        url = result.get("result", {}).get("value", "")
+
+        # Comprehensive list of browser error URLs
+        error_url_patterns = [
+            "about:blank",
+            # Chrome error pages
+            "chrome-error://",
+            "chrome://network-error/",
+            "chrome://network-errors/",
+            # Chrome crash and debugging pages
+            "chrome://crash/",
+            "chrome://crashdump/",
+            "chrome://kill/",
+            "chrome://hang/",
+            "chrome://shorthang/",
+            "chrome://gpuclean/",
+            "chrome://gpucrash/",
+            "chrome://gpuhang/",
+            "chrome://memory-exhaust/",
+            "chrome://memory-pressure-critical/",
+            "chrome://memory-pressure-moderate/",
+            "chrome://inducebrowsercrashforrealz/",
+            "chrome://inducebrowserdcheckforrealz/",
+            "chrome://inducebrowserheapcorruption/",
+            "chrome://heapcorruptioncrash/",
+            "chrome://badcastcrash/",
+            "chrome://ppapiflashcrash/",
+            "chrome://ppapiflashhang/",
+            "chrome://quit/",
+            "chrome://restart/",
+            # Firefox error pages
+            "about:neterror",
+            "about:certerror",
+            "about:blocked",
+            # Firefox crash and debugging pages
+            "about:crashcontent",
+            "about:crashparent",
+            "about:crashes",
+            "about:tabcrashed",
+            # Edge error pages (similar to Chrome)
+            "edge-error://",
+            "edge://crash/",
+            "edge://kill/",
+            "edge://hang/",
+            # Safari/WebKit error indicators (data URLs with error content)
+            "webkit-error://",
+        ]
+
+        # Check if current URL matches any error pattern
+        if any(url.startswith(pattern) for pattern in error_url_patterns):
+            logger.debug(f"Detected browser error page from URL: {url}")
+            return True
+
+        # Additional check for data URLs that might contain error pages
+        if url.startswith("data:") and any(
+            error_term in url.lower()
+            for error_term in ["error", "crash", "failed", "unavailable", "not found"]
+        ):
+            logger.debug(f"Detected error page from data URL: {url[:100]}...")
+            return True
+
+        return False
+
+    except asyncio.TimeoutError:
+        logger.debug("Timeout error when checking if error page")
+        return True
+    except Exception as e:
+        logger.debug(f"Error during checking if error page: {e}")
+        return True
+
+
 def get_mask_input_setting() -> MaskInputOptions:
     """Get the mask_input setting from session recording configuration."""
     try:
@@ -534,12 +634,78 @@ def get_mask_input_setting() -> MaskInputOptions:
         )
 
 
-# browser_use.browser.session.CDPSession (browser-use >= 1.0.0)
-async def inject_session_recorder(cdp_session):
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
+async def get_isolated_context_id(cdp_session) -> int | None:
+    async with lock:
+        tree = {}
+        try:
+            tree = await asyncio.wait_for(
+                cdp_session.cdp_client.send.Page.getFrameTree(
+                    session_id=cdp_session.session_id
+                ),
+                timeout=CDP_OPERATION_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            logger.debug("Timeout error when getting frame tree")
+            return None
+        except Exception as e:
+            logger.debug(f"Failed to get frame tree: {e}")
+            return None
+        frame = tree.get("frameTree", {}).get("frame", {})
+        frame_id = frame.get("id")
+        loader_id = frame.get("loaderId")
+
+        if frame_id is None or loader_id is None:
+            logger.debug("Failed to get frame id or loader id")
+            return None
+        key = f"{frame_id}_{loader_id}"
+
+        if key in frame_to_isolated_context_id:
+            return frame_to_isolated_context_id[key]
+
+        try:
+            result = await asyncio.wait_for(
+                cdp_session.cdp_client.send.Page.createIsolatedWorld(
+                    {
+                        "frameId": frame_id,
+                        "worldName": "laminar-isolated-context",
+                    },
+                    session_id=cdp_session.session_id,
+                ),
+                timeout=CDP_OPERATION_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            logger.debug("Timeout error when getting isolated context id")
+            return None
+        except Exception as e:
+            logger.debug(f"Failed to get isolated context id: {e}")
+            return None
+        isolated_context_id = result["executionContextId"]
+        frame_to_isolated_context_id[key] = isolated_context_id
+        return isolated_context_id
+
+
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
+async def inject_session_recorder(cdp_session) -> int | None:
+    """Injects the session recorder base as well as the recorder itself.
+    Returns the isolated context id if successful.
+    """
+    isolated_context_id = None
     cdp_client = cdp_session.cdp_client
     try:
+        should_skip = True
         try:
-            is_loaded = await is_recorder_present(cdp_session)
+            should_skip = await should_skip_page(cdp_session)
+        except Exception as e:
+            logger.debug(f"Failed to check if error page: {e}")
+
+        if should_skip:
+            logger.debug("Empty page detected, skipping session recorder injection")
+            return
+
+        isolated_context_id = await get_isolated_context_id(cdp_session)
+        try:
+            is_loaded = await is_recorder_present(cdp_session, isolated_context_id)
         except Exception as e:
             logger.debug(f"Failed to check if session recorder is loaded: {e}")
             is_loaded = False
@@ -547,42 +713,60 @@ async def inject_session_recorder(cdp_session):
         if is_loaded:
             return
 
+        if isolated_context_id is None:
+            logger.debug("Failed to get isolated context id")
+            return
+
         async def load_session_recorder():
             try:
-                await cdp_client.send.Runtime.evaluate(
-                    {
-                        "expression": f"({RRWEB_CONTENT})()",
-                        "awaitPromise": True,
-                    },
-                    session_id=cdp_session.session_id,
+                await asyncio.wait_for(
+                    cdp_client.send.Runtime.evaluate(
+                        {
+                            "expression": f"({RRWEB_CONTENT})()",
+                            "contextId": isolated_context_id,
+                        },
+                        session_id=cdp_session.session_id,
+                    ),
+                    timeout=CDP_OPERATION_TIMEOUT_SECONDS,
                 )
                 return True
+            except asyncio.TimeoutError:
+                logger.debug("Timeout error when loading session recorder base")
+                return False
             except Exception as e:
-                logger.error(f"Failed to load session recorder: {e}")
+                logger.debug(f"Failed to load session recorder base: {e}")
                 return False
 
         if not await retry_async(
             load_session_recorder,
+            retries=3,
             delay=1,
             error_message="Failed to load session recorder",
         ):
             return
 
         try:
-            await cdp_client.send.Runtime.evaluate(
-                {
-                    "expression": f"({INJECT_PLACEHOLDER})({orjson.dumps(get_mask_input_setting()).decode("utf-8")})",
-                },
-                session_id=cdp_session.session_id,
+            await asyncio.wait_for(
+                cdp_client.send.Runtime.evaluate(
+                    {
+                        "expression": f"({INJECT_PLACEHOLDER})({orjson.dumps(get_mask_input_setting()).decode('utf-8')})",
+                        "contextId": isolated_context_id,
+                    },
+                    session_id=cdp_session.session_id,
+                ),
+                timeout=CDP_OPERATION_TIMEOUT_SECONDS,
             )
+            return isolated_context_id
+        except asyncio.TimeoutError:
+            logger.debug("Timeout error when injecting session recorder")
         except Exception as e:
-            logger.debug(f"Failed to inject session recorder placeholder: {e}")
+            logger.debug(f"Failed to inject recorder: {e}")
 
     except Exception as e:
-        logger.error(f"Error during session recorder injection: {e}")
+        logger.debug(f"Error during session recorder injection: {e}")
 
 
-# browser_use.browser.session.CDPSession (browser-use >= 1.0.0)
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
 @observe(name="cdp_use.session", ignore_input=True, ignore_output=True)
 async def start_recording_events(
     cdp_session,
@@ -596,7 +780,10 @@ async def start_recording_events(
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
 
-    await inject_session_recorder(cdp_session)
+    isolated_context_id = await inject_session_recorder(cdp_session)
+    if isolated_context_id is None:
+        logger.debug("Failed to inject session recorder, not registering bindings")
+        return
 
     # Buffer for reassembling chunks
     chunk_buffers = {}
@@ -654,11 +841,14 @@ async def start_recording_events(
     async def send_events_callback(event, cdp_session_id: str | None = None):
         if event["name"] != "lmnrSendEvents":
             return
+        if event["executionContextId"] != isolated_context_id:
+            return
         await send_events_from_browser(orjson.loads(event["payload"]))
 
     await cdp_client.send.Runtime.addBinding(
         {
             "name": "lmnrSendEvents",
+            "executionContextId": isolated_context_id,
         },
         session_id=cdp_session.session_id,
     )
@@ -668,7 +858,7 @@ async def start_recording_events(
     register_on_target_created(cdp_session, lmnr_session_id, client)
 
 
-# browser_use.browser.session.CDPSession (browser-use >= 1.0.0)
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
 async def enable_target_discovery(cdp_session):
     cdp_client = cdp_session.cdp_client
     await cdp_client.send.Target.setDiscoverTargets(
@@ -679,7 +869,7 @@ async def enable_target_discovery(cdp_session):
     )
 
 
-# browser_use.browser.session.CDPSession (browser-use >= 1.0.0)
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
 def register_on_target_created(
     cdp_session, lmnr_session_id: str, client: AsyncLaminarClient
 ):
@@ -689,31 +879,63 @@ def register_on_target_created(
         if target_info["type"] == "page":
             asyncio.create_task(inject_session_recorder(cdp_session=cdp_session))
 
-    cdp_session.cdp_client.register.Target.targetCreated(on_target_created)
+    try:
+        cdp_session.cdp_client.register.Target.targetCreated(on_target_created)
+    except Exception as e:
+        logger.debug(f"Failed to register on target created: {e}")
 
 
-# browser_use.browser.session.CDPSession (browser-use >= 1.0.0)
-async def is_recorder_present(cdp_session) -> bool:
+# browser_use.browser.session.CDPSession (browser-use >= 0.6.0)
+async def is_recorder_present(
+    cdp_session, isolated_context_id: int | None = None
+) -> bool:
+    # This function returns True on any error, because it is safer to not record
+    # events than to try to inject the recorder into a broken context.
     cdp_client = cdp_session.cdp_client
+    if isolated_context_id is None:
+        isolated_context_id = await get_isolated_context_id(cdp_session)
+    if isolated_context_id is None:
+        logger.debug("Failed to get isolated context id")
+        return True
 
-    result = await cdp_client.send.Runtime.evaluate(
-        {
-            "expression": """(()=>{
-                return typeof window.lmnrRrweb !== 'undefined';
-            })()""",
-        },
-        session_id=cdp_session.session_id,
-    )
-    if result and "result" in result and "value" in result["result"]:
-        return result["result"]["value"]
-    return False
+    try:
+        result = await asyncio.wait_for(
+            cdp_client.send.Runtime.evaluate(
+                {
+                    "expression": "typeof window.lmnrRrweb !== 'undefined'",
+                    "contextId": isolated_context_id,
+                },
+                session_id=cdp_session.session_id,
+            ),
+            timeout=CDP_OPERATION_TIMEOUT_SECONDS,
+        )
+        if result and "result" in result and "value" in result["result"]:
+            return result["result"]["value"]
+        return False
+    except asyncio.TimeoutError:
+        logger.debug("Timeout error when checking if session recorder is present")
+        return True
+    except Exception:
+        logger.debug("Exception when checking if session recorder is present")
+        return True
 
 
 async def take_full_snapshot(cdp_session):
     cdp_client = cdp_session.cdp_client
-    result = await cdp_client.send.Runtime.evaluate(
-        {
-            "expression": """(() => {
+    isolated_context_id = await get_isolated_context_id(cdp_session)
+    if isolated_context_id is None:
+        logger.debug("Failed to get isolated context id")
+        return False
+
+    if await should_skip_page(cdp_session):
+        logger.debug("Skipping full snapshot")
+        return False
+
+    try:
+        result = await asyncio.wait_for(
+            cdp_client.send.Runtime.evaluate(
+                {
+                    "expression": """(() => {
     if (window.lmnrRrweb) {
         try {
             window.lmnrRrweb.record.takeFullSnapshot();
@@ -725,9 +947,18 @@ async def take_full_snapshot(cdp_session):
     }
     return false;
 })()""",
-        },
-        session_id=cdp_session.session_id,
-    )
+                    "contextId": isolated_context_id,
+                },
+                session_id=cdp_session.session_id,
+            ),
+            timeout=CDP_OPERATION_TIMEOUT_SECONDS,
+        )
+    except asyncio.TimeoutError:
+        logger.debug("Timeout error when taking full snapshot")
+        return False
+    except Exception as e:
+        logger.debug(f"Error when taking full snapshot: {e}")
+        return False
     if result and "result" in result and "value" in result["result"]:
         return result["result"]["value"]
     return False

lmnr/sdk/evaluations.py

@@ -112,7 +112,12 @@ class Evaluation:
         base_http_url: str | None = None,
         http_port: int | None = None,
         grpc_port: int | None = None,
-        instruments: set[Instruments] | None = None,
+        instruments: (
+            set[Instruments] | list[Instruments] | tuple[Instruments] | None
+        ) = None,
+        disabled_instruments: (
+            set[Instruments] | list[Instruments] | tuple[Instruments] | None
+        ) = None,
         max_export_batch_size: int | None = MAX_EXPORT_BATCH_SIZE,
         trace_export_timeout_seconds: int | None = None,
     ):
@@ -172,6 +177,10 @@ class Evaluation:
                 used.
                 See https://docs.lmnr.ai/tracing/automatic-instrumentation
                 Defaults to None.
+            disabled_instruments (set[Instruments] | None, optional): Set of modules\
+                to disable auto-instrumentations. If None, only modules passed\
+                as `instruments` will be disabled.
+                Defaults to None.
         """
 
         if not evaluators:
@@ -234,6 +243,7 @@ class Evaluation:
             http_port=http_port,
             grpc_port=grpc_port,
             instruments=instruments,
+            disabled_instruments=disabled_instruments,
             max_export_batch_size=max_export_batch_size,
             export_timeout_seconds=trace_export_timeout_seconds,
         )
@@ -432,7 +442,12 @@ def evaluate(
     base_http_url: str | None = None,
     http_port: int | None = None,
     grpc_port: int | None = None,
-    instruments: set[Instruments] | None = None,
+    instruments: (
+        set[Instruments] | list[Instruments] | tuple[Instruments] | None
+    ) = None,
+    disabled_instruments: (
+        set[Instruments] | list[Instruments] | tuple[Instruments] | None
+    ) = None,
     max_export_batch_size: int | None = MAX_EXPORT_BATCH_SIZE,
     trace_export_timeout_seconds: int | None = None,
 ) -> Awaitable[None] | None:
@@ -493,6 +508,10 @@ def evaluate(
                         auto-instrument. If None, all available instruments\
                         will be used.
                         Defaults to None.
+        disabled_instruments (set[Instruments] | None, optional): Set of modules\
+                        to disable auto-instrumentations. If None, no\
+                        If None, only modules passed as `instruments` will be disabled.
+                        Defaults to None.
         trace_export_timeout_seconds (int | None, optional): The timeout for\
                         trace export on OpenTelemetry exporter. Defaults to None.
     """
@@ -510,6 +529,7 @@ def evaluate(
         http_port=http_port,
         grpc_port=grpc_port,
         instruments=instruments,
+        disabled_instruments=disabled_instruments,
         max_export_batch_size=max_export_batch_size,
         trace_export_timeout_seconds=trace_export_timeout_seconds,
     )

lmnr/sdk/laminar.py

@@ -421,14 +421,14 @@ class Laminar:
 
         Usage example:
         ```python
-        from src.lmnr import Laminar, use_span
+        from src.lmnr import Laminar
         def foo(span):
-            with use_span(span):
+            with Laminar.use_span(span):
                 with Laminar.start_as_current_span("foo_inner"):
                     some_function()
         
         def bar():
-            with use_span(span):
+            with Laminar.use_span(span):
                 openai_client.chat.completions.create()
         
         span = Laminar.start_span("outer")

lmnr/version.py

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

{lmnr-0.7.9.dist-info → lmnr-0.7.11.dist-info}/METADATA

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

{lmnr-0.7.9.dist-info → lmnr-0.7.11.dist-info}/RECORD

@@ -46,12 +46,12 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/openhands_ai/__init__.py,sh
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/opentelemetry/__init__.py,sha256=1f86cdf738e2f68586b0a4569bb1e40edddd85c529f511ef49945ddb7b61fab5,2648
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/skyvern/__init__.py,sha256=764e4fe979fb08d7821419a3cc5c3ae89a6664b626ef928259f8f175c939eaea,6334
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/threading/__init__.py,sha256=90aa8558467d7e469fe1a6c75372c113da403557715f03b522b2fab94b287c40,6320
-lmnr/opentelemetry_lib/tracing/__init__.py,sha256=b96aee7590af1853fffc4c3d8ce9127a67e1ce589f695a99aabe6b37d70b0e48,10203
-lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=f66dbe208fc1bd4075c0725561f6151a4c7622e6ecfa961b7ad6674d18dfb97f,15180
+lmnr/opentelemetry_lib/tracing/__init__.py,sha256=69dd8575908cedfebd29cd48c288cbf2cca1f689c469266bcdf79c7351bed99d,10979
+lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=cb2ce23406bdcbcad14489428d8a3438a948299bbb68a179cc3cbd44645154c0,16471
 lmnr/opentelemetry_lib/tracing/attributes.py,sha256=a879e337ff4e8569a4454544d303ccbc3b04bd42e1cdb765eb563aeaa08f731d,1653
 lmnr/opentelemetry_lib/tracing/context.py,sha256=83f842be0fc29a96647cbf005c39ea761b0fb5913c4102f965411f47906a6135,4103
 lmnr/opentelemetry_lib/tracing/exporter.py,sha256=6af8e61fd873e8f5db315d9b9f1edbf46b860ba7e50140f0bdcc6864c6d35a03,2082
-lmnr/opentelemetry_lib/tracing/instruments.py,sha256=950c351bbc05a7665e6c0eb0ed1bafc1b4b2a037ed1086786ec8496802ecef2e,5618
+lmnr/opentelemetry_lib/tracing/instruments.py,sha256=8482c9df1310a47117667469eeeddb60707da484ee7e80b69f506ef1594e380a,5848
 lmnr/opentelemetry_lib/tracing/processor.py,sha256=cbc70f138e70c878ef57b02a2c46ef48dd7f694a522623a82dff1623b73d1e1c,3353
 lmnr/opentelemetry_lib/tracing/tracer.py,sha256=33769a9a97385f5697eb0e0a6b1813a57ed956c7a8379d7ac2523e700e7dd528,1362
 lmnr/opentelemetry_lib/utils/__init__.py,sha256=a4d85fd06def4dde5c728734de2d4c5c36eb89c49a8aa09b8b50cb5a149e90af,604
@@ -61,9 +61,10 @@ lmnr/opentelemetry_lib/utils/wrappers.py,sha256=f7b1134809f2c408976a71e661fee5cb
 lmnr/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 lmnr/sdk/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
 lmnr/sdk/browser/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-lmnr/sdk/browser/browser_use_cdp_otel.py,sha256=aa14e3ea7bd0980a4b1fc2d9a5d40d3815479fe37f2aff989f896f0ad5a63a7d,3210
+lmnr/sdk/browser/browser_use_cdp_otel.py,sha256=4ee0ce6b60b8b20c8a862d5ebce9f2a99dbf0867d549cc44455294ab1281137d,3379
 lmnr/sdk/browser/browser_use_otel.py,sha256=e5549878c07bad451efef9f460ce52202284cff50075bce700ca61749102c5eb,5065
-lmnr/sdk/browser/cdp_utils.py,sha256=3f43e4b9958e752b1b9aa0a3ae6321ef9e1cb66b3f4ca07990584b2c60c17a97,26103
+lmnr/sdk/browser/bubus_otel.py,sha256=92991ba5f6b5e2a6e131ab57df7c383345b57982acfdb1437540a1609ad1f876,2465
+lmnr/sdk/browser/cdp_utils.py,sha256=e49b2a526f4c6dfc0646e26d33c0f4beebbc9dad5d5d2b0389737b339c6cc0b4,35067
 lmnr/sdk/browser/patchright_otel.py,sha256=9d22ab1f28f1eddbcfd0032a14fe306bfe00bfc7f11128cb99836c4dd15fb7c8,4800
 lmnr/sdk/browser/playwright_otel.py,sha256=859d220d856c8fe7104863efca0c6a3ed5464d778675e07d7f79c48f73d5e838,10416
 lmnr/sdk/browser/pw_utils.py,sha256=a75769eb977d8e56c38a0eefad09b87550b872f8d4df186b36a8c4d4af2bffaf,29021
@@ -88,13 +89,13 @@ lmnr/sdk/client/synchronous/sync_client.py,sha256=0bebe88e3aed689505e9ed3d32036f
 lmnr/sdk/datasets.py,sha256=3fd851c5f97bf88eaa84b1451a053eaff23b4497cbb45eac2f9ea0e5f2886c00,1708
 lmnr/sdk/decorators.py,sha256=c709b76a814e019c919fd811591850787a2f266b7b6f46123f66ddd92e1092d5,6920
 lmnr/sdk/eval_control.py,sha256=291394ac385c653ae9b5167e871bebeb4fe8fc6b7ff2ed38e636f87015dcba86,184
-lmnr/sdk/evaluations.py,sha256=895d0b1af77395bddfbf69388679eb03f8f4d2ef03facab270965de1b382b2c8,22881
-lmnr/sdk/laminar.py,sha256=24d680407ce694f1a7ec0e9c0524eae3deb7d638ad5caff3a591ddf7963ad480,37533
+lmnr/sdk/evaluations.py,sha256=7e55cbca77fa32cb64cb77aed8076a1994258a5b652c7f1d45231928e4aefe26,23885
+lmnr/sdk/laminar.py,sha256=199bab54d49f918f110d7b98569551d8ab7ea4e93828af7381ba56b1181e855b,37539
 lmnr/sdk/log.py,sha256=9edfd83263f0d4845b1b2d1beeae2b4ed3f8628de941f371a893d72b79c348d4,2213
 lmnr/sdk/types.py,sha256=f8a8368e225c4d2f82df54d92f029065afb60c3eff494c77c6e574963ed524ff,13454
 lmnr/sdk/utils.py,sha256=0c5a81c305dcd3922f4b31c4f42cf83719c03888725838395adae167de92db76,5019
-lmnr/version.py,sha256=e9882c4c3fde6de255d516c74b58299c7fe25676f330f27a192a16c01106c4a5,1321
-lmnr-0.7.9.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-lmnr-0.7.9.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
-lmnr-0.7.9.dist-info/METADATA,sha256=c80f3d2e429443e6bfa13bf62b50521954560a51c88164ab4b83894e3b0ab27b,14196
-lmnr-0.7.9.dist-info/RECORD,,
+lmnr/version.py,sha256=52bb47a5d5e8f391c347d7742269dd0b231aa0de29e1ddbac7958d9b94cb47db,1322
+lmnr-0.7.11.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+lmnr-0.7.11.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
+lmnr-0.7.11.dist-info/METADATA,sha256=1beeb3d2258e4416445fea5d6e5d4c788fd5ccabfedb7e814352f78863001cad,14197
+lmnr-0.7.11.dist-info/RECORD,,