lmnr 0.6.21__py3-none-any.whl → 0.7.1__py3-none-any.whl

lmnr/opentelemetry_lib/tracing/tracer.py

@@ -1,6 +1,8 @@
 from contextlib import contextmanager
+from typing import Generator, Tuple
 
 from opentelemetry import trace
+from opentelemetry.context import Context
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
 
@@ -16,3 +18,30 @@ def get_tracer(flush_on_exit: bool = False):
     finally:
         if flush_on_exit:
             wrapper.flush()
+
+
+@contextmanager
+def get_tracer_with_context(
+    flush_on_exit: bool = False,
+) -> Generator[Tuple[trace.Tracer, Context], None, None]:
+    """Get tracer with isolated context. Returns (tracer, context) tuple."""
+    wrapper = TracerWrapper()
+    try:
+        tracer = wrapper.get_tracer()
+        context = wrapper.get_isolated_context()
+        yield tracer, context
+    finally:
+        if flush_on_exit:
+            wrapper.flush()
+
+
+def copy_current_context() -> Context:
+    """Copy the current isolated context for use in threads/tasks."""
+    wrapper = TracerWrapper()
+    return wrapper.get_isolated_context()
+
+
+def set_context_for_thread(context: Context) -> None:
+    """Set the isolated context for the current thread."""
+    wrapper = TracerWrapper()
+    wrapper.set_isolated_context(context)

lmnr/sdk/browser/browser_use_otel.py

@@ -28,8 +28,8 @@ WRAPPED_METHODS = [
         "object": "Agent",
         "method": "run",
         "span_name": "agent.run",
-        "ignore_input": False,
-        "ignore_output": False,
+        "ignore_input": True,
+        "ignore_output": True,
         "span_type": "DEFAULT",
     },
     {
@@ -47,15 +47,15 @@ WRAPPED_METHODS = [
         "method": "act",
         "span_name": "controller.act",
         "ignore_input": True,
-        "ignore_output": False,
+        "ignore_output": True,
         "span_type": "DEFAULT",
     },
     {
         "package": "browser_use.controller.registry.service",
         "object": "Registry",
         "method": "execute_action",
-        "ignore_input": False,
-        "ignore_output": False,
+        "ignore_input": True,
+        "ignore_output": True,
         "span_type": "TOOL",
     },
 ]

lmnr/sdk/browser/patchright_otel.py

@@ -1,4 +1,6 @@
 from lmnr.sdk.browser.playwright_otel import (
+    _wrap_bring_to_front_async,
+    _wrap_bring_to_front_sync,
     _wrap_new_browser_sync,
     _wrap_new_browser_async,
     _wrap_new_context_sync,
@@ -46,6 +48,12 @@ WRAPPED_METHODS = [
         "method": "launch_persistent_context",
         "wrapper": _wrap_new_context_sync,
     },
+    {
+        "package": "patchright.sync_api",
+        "object": "Page",
+        "method": "bring_to_front",
+        "wrapper": _wrap_bring_to_front_sync,
+    },
 ]
 
 WRAPPED_METHODS_ASYNC = [
@@ -79,6 +87,12 @@ WRAPPED_METHODS_ASYNC = [
         "method": "launch_persistent_context",
         "wrapper": _wrap_new_context_async,
     },
+    {
+        "package": "patchright.async_api",
+        "object": "Page",
+        "method": "bring_to_front",
+        "wrapper": _wrap_bring_to_front_async,
+    },
 ]
 
 

lmnr/sdk/browser/playwright_otel.py

@@ -60,8 +60,15 @@ def _wrap_new_browser_sync(
     browser: SyncBrowser = wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
 
+    def create_page_handler(session_id, client):
+        def page_handler(page):
+            start_recording_events_sync(page, session_id, client)
+
+        return page_handler
+
     for context in browser.contexts:
-        context.on("page", lambda p: start_recording_events_sync(p, session_id, client))
+        page_handler = create_page_handler(session_id, client)
+        context.on("page", page_handler)
         for page in context.pages:
             start_recording_events_sync(page, session_id, client)
 
@@ -75,10 +82,15 @@ async def _wrap_new_browser_async(
     browser: Browser = await wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
 
+    def create_page_handler(session_id, client):
+        async def page_handler(page):
+            await start_recording_events_async(page, session_id, client)
+
+        return page_handler
+
     for context in browser.contexts:
-        context.on(
-            "page", lambda p: start_recording_events_async(p, session_id, client)
-        )
+        page_handler = create_page_handler(session_id, client)
+        context.on("page", page_handler)
         for page in context.pages:
             await start_recording_events_async(page, session_id, client)
     return browser
@@ -91,7 +103,14 @@ def _wrap_new_context_sync(
     context: SyncBrowserContext = wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
 
-    context.on("page", lambda p: start_recording_events_sync(p, session_id, client))
+    def create_page_handler(session_id, client):
+        def page_handler(page):
+            start_recording_events_sync(page, session_id, client)
+
+        return page_handler
+
+    page_handler = create_page_handler(session_id, client)
+    context.on("page", page_handler)
     for page in context.pages:
         start_recording_events_sync(page, session_id, client)
 
@@ -105,7 +124,14 @@ async def _wrap_new_context_async(
     context: BrowserContext = await wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
 
-    context.on("page", lambda p: start_recording_events_async(p, session_id, client))
+    def create_page_handler(session_id, client):
+        async def page_handler(page):
+            await start_recording_events_async(page, session_id, client)
+
+        return page_handler
+
+    page_handler = create_page_handler(session_id, client)
+    context.on("page", page_handler)
     for page in context.pages:
         await start_recording_events_async(page, session_id, client)
 

lmnr/sdk/browser/pw_utils.py

@@ -8,6 +8,7 @@ from lmnr.sdk.decorators import observe
 from lmnr.sdk.browser.utils import retry_sync, retry_async
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 
 try:
     if is_package_installed("playwright"):
@@ -32,13 +33,15 @@ except ImportError as e:
 logger = logging.getLogger(__name__)
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
-with open(os.path.join(current_dir, "rrweb", "rrweb.umd.min.cjs"), "r") as f:
+with open(os.path.join(current_dir, "recorder", "record.umd.min.cjs"), "r") as f:
     RRWEB_CONTENT = f"() => {{ {f.read()} }}"
 
 INJECT_PLACEHOLDER = """
 () => {
     const BATCH_TIMEOUT = 2000; // Send events after 2 seconds
-
+    const MAX_WORKER_PROMISES = 50; // Max concurrent worker promises
+    const HEARTBEAT_INTERVAL = 1000;
+    
     window.lmnrRrwebEventsBatch = [];
 
     // Create a Web Worker for heavy JSON processing with chunked processing
@@ -97,6 +100,29 @@ INJECT_PLACEHOLDER = """
     let workerPromises = new Map();
     let workerId = 0;
 
+    // Cleanup function for worker
+    const cleanupWorker = () => {
+        if (compressionWorker) {
+            compressionWorker.terminate();
+            compressionWorker = null;
+        }
+        workerPromises.clear();
+        workerId = 0;
+    };
+
+    // Clean up stale promises to prevent memory leaks
+    const cleanupStalePromises = () => {
+        if (workerPromises.size > MAX_WORKER_PROMISES) {
+            const toDelete = [];
+            for (const [id, promise] of workerPromises) {
+                if (toDelete.length >= workerPromises.size - MAX_WORKER_PROMISES) break;
+                toDelete.push(id);
+                promise.reject(new Error('Promise cleaned up due to memory pressure'));
+            }
+            toDelete.forEach(id => workerPromises.delete(id));
+        }
+    };
+
     // Non-blocking JSON.stringify using chunked processing
     function stringifyNonBlocking(obj, chunkSize = 10000) {
         return new Promise((resolve, reject) => {
@@ -196,6 +222,9 @@ INJECT_PLACEHOLDER = """
     // Alternative: Use transferable objects for maximum efficiency
     async function compressLargeObjectTransferable(data) {
         try {
+            // Clean up stale promises first
+            cleanupStalePromises();
+            
             // Stringify on main thread but non-blocking
             const jsonString = await stringifyNonBlocking(data);
 
@@ -219,11 +248,24 @@ INJECT_PLACEHOLDER = """
                             }
                         }
                     };
+                    
+                    compressionWorker.onerror = (error) => {
+                        console.error('Compression worker error:', error);
+                        cleanupWorker();
+                    };
                 }
 
                 const id = ++workerId;
                 workerPromises.set(id, { resolve, reject });
 
+                // Set timeout to prevent hanging promises
+                setTimeout(() => {
+                    if (workerPromises.has(id)) {
+                        workerPromises.delete(id);
+                        reject(new Error('Compression timeout'));
+                    }
+                }, 10000);
+
                 // Transfer the ArrayBuffer (no copying!)
                 compressionWorker.postMessage({
                     buffer,
@@ -262,15 +304,32 @@ INJECT_PLACEHOLDER = """
                             }
                         }
                     };
+                    
+                    compressionWorker.onerror = (error) => {
+                        console.error('Compression worker error:', error);
+                        cleanupWorker();
+                    };
                 }
 
                 const id = ++workerId;
                 workerPromises.set(id, { resolve, reject });
+                
+                // Set timeout to prevent hanging promises
+                setTimeout(() => {
+                    if (workerPromises.has(id)) {
+                        workerPromises.delete(id);
+                        reject(new Error('Compression timeout'));
+                    }
+                }, 10000);
+                
                 compressionWorker.postMessage({ jsonString, id });
             });
         }
     }
 
+    
+    setInterval(cleanupWorker, 5000);
+    
     function isLargeEvent(type) {
         const LARGE_EVENT_TYPES = [
             2, // FullSnapshot
@@ -299,14 +358,15 @@ INJECT_PLACEHOLDER = """
 
     setInterval(sendBatchIfReady, BATCH_TIMEOUT);
 
-    // Add heartbeat events
-    setInterval(async () => {
-        window.lmnrRrweb.record.addCustomEvent('heartbeat', {
-            title: document.title,
-            url: document.URL,
-        })
-    }, 1000);
-
+    async function bufferToBase64(buffer) {
+        const base64url = await new Promise(r => {
+            const reader = new FileReader()
+            reader.onload = () => r(reader.result)
+            reader.readAsDataURL(new Blob([buffer]))
+        });
+        return base64url.slice(base64url.indexOf(',') + 1);
+    }
+ 
     window.lmnrRrweb.record({
         async emit(event) {
             try {
@@ -315,9 +375,10 @@ INJECT_PLACEHOLDER = """
                     await compressLargeObject(event.data, true) :
                     await compressSmallObject(event.data);
 
+                const base64Data = await bufferToBase64(compressedResult);
                 const eventToSend = {
                     ...event,
-                    data: compressedResult,
+                    data: base64Data,
                 };
                 window.lmnrRrwebEventsBatch.push(eventToSend);
             } catch (error) {
@@ -328,63 +389,22 @@ INJECT_PLACEHOLDER = """
         collectFonts: true,
         recordCrossOriginIframes: true
     });
-}
-"""
-
 
-async def send_events_async(
-    page: Page, session_id: str, trace_id: str, client: AsyncLaminarClient
-):
-    """Fetch events from the page and send them to the server"""
-    try:
-        # Check if function exists first
-        events = await page.evaluate(
-            """
-        () => {
-            if (typeof window.lmnrGetAndClearEvents !== 'function') {
-                return [];
-            }
-            return window.lmnrGetAndClearEvents();
-        }
-        """
-        )
-
-        if not events or len(events) == 0:
-            return
-
-        await client._browser_events.send(session_id, trace_id, events)
-    except Exception as e:
-        if "Page.evaluate: Target page, context or browser has been closed" not in str(
-            e
-        ):
-            logger.debug(f"Could not send events: {e}")
-
-
-def send_events_sync(
-    page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
-):
-    """Synchronous version of send_events"""
-    try:
-        events = page.evaluate(
-            """
-        () => {
-            if (typeof window.lmnrGetAndClearEvents !== 'function') {
-                return [];
-            }
-            return window.lmnrGetAndClearEvents();
-        }
-        """
-        )
-        if not events or len(events) == 0:
-            return
+    function heartbeat() {
+        // Add heartbeat events
+        setInterval(() => {
+            window.lmnrRrweb.record.addCustomEvent('heartbeat', {
+                title: document.title,
+                    url: document.URL,
+                })
+            }, HEARTBEAT_INTERVAL
+        );
+    }
 
-        client._browser_events.send(session_id, trace_id, events)
+    heartbeat();
 
-    except Exception as e:
-        if "Page.evaluate: Target page, context or browser has been closed" not in str(
-            e
-        ):
-            logger.debug(f"Could not send events: {e}")
+}
+"""
 
 
 def inject_session_recorder_sync(page: SyncPage):
@@ -414,10 +434,10 @@ def inject_session_recorder_sync(page: SyncPage):
             ):
                 return
 
-        try:
-            page.evaluate(INJECT_PLACEHOLDER)
-        except Exception as e:
-            logger.debug(f"Failed to inject session recorder: {e}")
+            try:
+                page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject session recorder: {e}")
 
     except Exception as e:
         logger.error(f"Error during session recorder injection: {e}")
@@ -450,10 +470,10 @@ async def inject_session_recorder_async(page: Page):
             ):
                 return
 
-        try:
-            await page.evaluate(INJECT_PLACEHOLDER)
-        except Exception as e:
-            logger.debug(f"Failed to inject session recorder placeholder: {e}")
+            try:
+                await page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject session recorder placeholder: {e}")
 
     except Exception as e:
         logger.error(f"Error during session recorder injection: {e}")
@@ -461,7 +481,9 @@ async def inject_session_recorder_async(page: Page):
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
 def start_recording_events_sync(page: SyncPage, session_id: str, client: LaminarClient):
-    span = trace.get_current_span()
+
+    ctx = get_current_context()
+    span = trace.get_current_span(ctx)
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
 
@@ -471,24 +493,6 @@ def start_recording_events_sync(page: SyncPage, session_id: str, client: Laminar
     except Exception:
         pass
 
-    def on_load():
-        try:
-            inject_session_recorder_sync(page)
-        except Exception as e:
-            logger.error(f"Error in on_load handler: {e}")
-
-    def on_close():
-        try:
-            send_events_sync(page, session_id, trace_id, client)
-        except Exception:
-            pass
-
-    page.on("load", on_load)
-    page.on("close", on_close)
-
-    inject_session_recorder_sync(page)
-
-    # Expose function to browser so it can call us when events are ready
     def send_events_from_browser(events):
         try:
             if events and len(events) > 0:
@@ -501,12 +505,23 @@ def start_recording_events_sync(page: SyncPage, session_id: str, client: Laminar
     except Exception as e:
         logger.debug(f"Could not expose function: {e}")
 
+    inject_session_recorder_sync(page)
+
+    def on_load(p):
+        try:
+            inject_session_recorder_sync(p)
+        except Exception as e:
+            logger.error(f"Error in on_load handler: {e}")
+
+    page.on("domcontentloaded", on_load)
+
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
 async def start_recording_events_async(
     page: Page, session_id: str, client: AsyncLaminarClient
 ):
-    span = trace.get_current_span()
+    ctx = get_current_context()
+    span = trace.get_current_span(ctx)
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
 
@@ -517,25 +532,7 @@ async def start_recording_events_async(
             return
     except Exception:
         pass
-
-    async def on_load(p):
-        try:
-            await inject_session_recorder_async(p)
-        except Exception as e:
-            logger.error(f"Error in on_load handler: {e}")
-
-    async def on_close(p):
-        try:
-            # Send any remaining events before closing
-            await send_events_async(p, session_id, trace_id, client)
-        except Exception:
-            pass
-
-    page.on("load", on_load)
-    page.on("close", on_close)
-
-    await inject_session_recorder_async(page)
-
+    
     async def send_events_from_browser(events):
         try:
             if events and len(events) > 0:
@@ -548,6 +545,16 @@ async def start_recording_events_async(
     except Exception as e:
         logger.debug(f"Could not expose function: {e}")
 
+    await inject_session_recorder_async(page)
+    
+    async def on_load(p):
+        try:
+            await inject_session_recorder_async(p)
+        except Exception as e:
+            logger.error(f"Error in on_load handler: {e}")
+
+    page.on("domcontentloaded", on_load)
+
 
 def take_full_snapshot(page: Page):
     return page.evaluate(