lmnr 0.6.16__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/sdk/browser/pw_utils.py

@@ -1,17 +1,23 @@
 import asyncio
-import logging
 import os
 import time
-import threading
+
+import orjson
 
 from opentelemetry import trace
 
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
 from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 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.browser.background_send_events import (
+    get_background_loop,
+    track_async_send,
+)
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
-
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.types import MaskInputOptions
 
 try:
     if is_package_installed("playwright"):
@@ -33,292 +39,325 @@ except ImportError as e:
         "or `pip install patchright` to install one of the supported browsers."
     ) from e
 
-logger = logging.getLogger(__name__)
+logger = get_default_logger(__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:
-    RRWEB_CONTENT = f"() => {{ {f.read()} }}"
+OLD_BUFFER_TIMEOUT = 60
 
-INJECT_PLACEHOLDER = """
-() => {
-    const BATCH_SIZE = 1000;  // Maximum events to store in memory
-
-    window.lmnrRrwebEventsBatch = new Set();
-    
-    // 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 = new Set();
-        return Array.from(events);
-    };
-
-    // Add heartbeat events
-    setInterval(async () => {
-        window.lmnrRrweb.record.addCustomEvent('heartbeat', {
-            title: document.title,
-            url: document.URL,
-        })
-
-    }, 1000);
-
-    window.lmnrRrweb.record({
-        async emit(event) {    
-            // Compress the data field
-            const compressedEvent = {
-                ...event,
-                data: await compressEventData(event.data)
-            };
-            window.lmnrRrwebEventsBatch.add(compressedEvent);
-        },
-        recordCanvas: true,
-        collectFonts: true,
-        recordCrossOriginIframes: true
-    });
-}
-"""
-
-
-async def send_events_async(
-    page: Page, session_id: str, trace_id: str, client: AsyncLaminarClient
+
+def create_send_events_handler(
+    chunk_buffers: dict,
+    session_id: str,
+    trace_id: str,
+    client: AsyncLaminarClient,
+    background_loop: asyncio.AbstractEventLoop,
 ):
-    """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();
-        }
-        """
-        )
+    """
+    Create an async event handler for sending browser events.
 
-        if not events or len(events) == 0:
-            return
+    This handler reassembles chunked event data and submits it to the background
+    loop for async HTTP sending. The handler itself processes chunks synchronously
+    but delegates the actual HTTP send to the background loop.
 
-        await client._browser_events.send(session_id, trace_id, events)
-    except Exception as e:
-        if str(e).startswith("Page.evaluate: Execution context was destroyed"):
-            logger.info("Execution context was destroyed, injecting rrweb again")
-            await inject_rrweb_async(page)
-            await send_events_async(page, session_id, trace_id, client)
-        else:
-            logger.debug(f"Could not send events: {e}")
+    Args:
+        chunk_buffers: Dictionary to store incomplete chunk batches
+        session_id: Browser session ID
+        trace_id: OpenTelemetry trace ID
+        client: Async Laminar client for HTTP requests
+        background_loop: Background event loop for async sends
 
+    Returns:
+        An async function that handles incoming event chunks from the browser
+    """
 
-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
+    async def send_events_from_browser(chunk):
+        try:
+            # Handle chunked data
+            batch_id = chunk["batchId"]
+            chunk_index = chunk["chunkIndex"]
+            total_chunks = chunk["totalChunks"]
+            data = chunk["data"]
+
+            # Initialize buffer for this batch if needed
+            if batch_id not in chunk_buffers:
+                chunk_buffers[batch_id] = {
+                    "chunks": {},
+                    "total": total_chunks,
+                    "timestamp": time.time(),
+                }
 
-        client._browser_events.send(session_id, trace_id, events)
+            # Store chunk
+            chunk_buffers[batch_id]["chunks"][chunk_index] = data
+
+            # Check if we have all chunks
+            if len(chunk_buffers[batch_id]["chunks"]) == total_chunks:
+                # Reassemble the full message
+                full_data = ""
+                for i in range(total_chunks):
+                    full_data += chunk_buffers[batch_id]["chunks"][i]
+
+                # Parse the JSON
+                events = orjson.loads(full_data)
+
+                # Send to server in background loop (independent of Playwright's loop)
+                if events and len(events) > 0:
+                    future = asyncio.run_coroutine_threadsafe(
+                        client._browser_events.send(session_id, trace_id, events),
+                        background_loop,
+                    )
+                    track_async_send(future)
+
+                # Clean up buffer
+                del chunk_buffers[batch_id]
+
+            # Clean up old incomplete buffers
+            current_time = time.time()
+            to_delete = []
+            for bid, buffer in chunk_buffers.items():
+                if current_time - buffer["timestamp"] > OLD_BUFFER_TIMEOUT:
+                    to_delete.append(bid)
+            for bid in to_delete:
+                logger.debug(f"Cleaning up incomplete chunk buffer: {bid}")
+                del chunk_buffers[bid]
 
-    except Exception as e:
-        if str(e).startswith("Page.evaluate: Execution context was destroyed"):
-            logger.info("Execution context was destroyed, injecting rrweb again")
-            inject_rrweb_sync(page)
-            send_events_sync(page, session_id, trace_id, client)
-        else:
+        except Exception as e:
             logger.debug(f"Could not send events: {e}")
 
+    return send_events_from_browser
+
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(current_dir, "recorder", "record.umd.min.cjs"), "r") as f:
+    RRWEB_CONTENT = f"() => {{ {f.read()} }}"
 
-def inject_rrweb_sync(page: SyncPage):
+with open(os.path.join(current_dir, "inject_script.js"), "r") as f:
+    INJECT_SCRIPT_CONTENT = f.read()
+
+
+def get_mask_input_setting() -> MaskInputOptions:
+    """Get the mask_input setting from session recording configuration."""
     try:
-        page.wait_for_load_state("domcontentloaded")
+        config = TracerWrapper.get_session_recording_options()
+        return config.get(
+            "mask_input_options",
+            MaskInputOptions(
+                textarea=False,
+                text=False,
+                number=False,
+                select=False,
+                email=False,
+                tel=False,
+            ),
+        )
+    except (AttributeError, Exception):
+        # Fallback to default configuration if TracerWrapper is not initialized
+        return MaskInputOptions(
+            textarea=False,
+            text=False,
+            number=False,
+            select=False,
+            email=False,
+            tel=False,
+        )
 
-        # Wrap the evaluate call in a try-catch
+
+def inject_session_recorder_sync(page: SyncPage):
+    try:
         try:
             is_loaded = page.evaluate(
                 """() => typeof window.lmnrRrweb !== 'undefined'"""
             )
         except Exception as e:
-            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            logger.debug(f"Failed to check if session recorder is loaded: {e}")
             is_loaded = False
 
         if not is_loaded:
 
-            def load_rrweb():
+            def load_session_recorder():
                 try:
+                    if page.is_closed():
+                        return False
                     page.evaluate(RRWEB_CONTENT)
                     return True
                 except Exception as e:
-                    logger.debug(f"Failed to load rrweb: {e}")
+                    logger.debug(f"Failed to load session recorder: {e}")
                     return False
 
             if not retry_sync(
-                load_rrweb, delay=1, error_message="Failed to load rrweb"
+                load_session_recorder,
+                delay=1,
+                error_message="Failed to load session recorder",
             ):
                 return
 
-        try:
-            page.evaluate(INJECT_PLACEHOLDER)
-        except Exception as e:
-            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+            try:
+                if not page.is_closed():
+                    page.evaluate(
+                        f"({INJECT_SCRIPT_CONTENT})({orjson.dumps(get_mask_input_setting()).decode('utf-8')}, false)"
+                    )
+            except Exception as e:
+                logger.debug(f"Failed to inject session recorder: {e}")
 
     except Exception as e:
-        logger.error(f"Error during rrweb injection: {e}")
+        logger.error(f"Error during session recorder injection: {e}")
 
 
-async def inject_rrweb_async(page: Page):
+async def inject_session_recorder_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}")
+            logger.debug(f"Failed to check if session recorder is loaded: {e}")
             is_loaded = False
 
         if not is_loaded:
 
-            async def load_rrweb():
+            async def load_session_recorder():
                 try:
+                    if page.is_closed():
+                        return False
                     await page.evaluate(RRWEB_CONTENT)
                     return True
                 except Exception as e:
-                    logger.debug(f"Failed to load rrweb: {e}")
+                    logger.debug(f"Failed to load session recorder: {e}")
                     return False
 
             if not await retry_async(
-                load_rrweb, delay=1, error_message="Failed to load rrweb"
+                load_session_recorder,
+                delay=1,
+                error_message="Failed to load session recorder",
             ):
                 return
 
-        try:
-            await page.evaluate(INJECT_PLACEHOLDER)
-        except Exception as e:
-            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+            try:
+                if not page.is_closed():
+                    await page.evaluate(
+                        f"({INJECT_SCRIPT_CONTENT})({orjson.dumps(get_mask_input_setting()).decode('utf-8')}, false)"
+                    )
+            except Exception as e:
+                logger.debug(f"Failed to inject session recorder placeholder: {e}")
 
     except Exception as e:
-        logger.error(f"Error during rrweb injection: {e}")
+        logger.error(f"Error during session recorder injection: {e}")
 
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
-def handle_navigation_sync(
-    page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
+def start_recording_events_sync(
+    page: SyncPage, session_id: str, client: AsyncLaminarClient
 ):
-    trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
-    original_bring_to_front = page.bring_to_front
-
-    def bring_to_front():
-        original_bring_to_front()
-        page.evaluate(
-            """() => {
-            if (window.lmnrRrweb) {
-                try {
-                    window.lmnrRrweb.record.takeFullSnapshot();
-                } catch (e) {
-                    console.error("Error taking full snapshot:", e);
-                }
-            }
-        }"""
-        )
 
-    page.bring_to_front = bring_to_front
+    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)
+
+    # Get the background loop for async sends
+    background_loop = get_background_loop()
 
-    def on_load():
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+
+    # Create the async event handler (shared implementation)
+    send_events_from_browser = create_send_events_handler(
+        chunk_buffers, session_id, trace_id, client, background_loop
+    )
+
+    def submit_event(chunk):
+        """Sync wrapper that submits async handler to background loop."""
         try:
-            inject_rrweb_sync(page)
+            # Submit async handler to background loop
+            asyncio.run_coroutine_threadsafe(
+                send_events_from_browser(chunk),
+                background_loop,
+            )
         except Exception as e:
-            logger.error(f"Error in on_load handler: {e}")
+            logger.debug(f"Error submitting event: {e}")
 
-    def collection_loop():
-        while not page.is_closed():  # Stop when page closes
-            send_events_sync(page, session_id, trace_id, client)
-            time.sleep(2)
+    try:
+        page.expose_function("lmnrSendEvents", submit_event)
+    except Exception as e:
+        logger.debug(f"Could not expose function: {e}")
 
-    thread = threading.Thread(target=collection_loop, daemon=True)
-    thread.start()
+    inject_session_recorder_sync(page)
 
-    def on_close():
+    def on_load(p):
         try:
-            send_events_sync(page, session_id, trace_id, client)
-            thread.join()
-        except Exception:
-            pass
+            if not p.is_closed():
+                inject_session_recorder_sync(p)
+        except Exception as e:
+            logger.debug(f"Error in on_load handler: {e}")
 
-    page.on("load", on_load)
-    page.on("close", on_close)
-    inject_rrweb_sync(page)
+    page.on("domcontentloaded", on_load)
 
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
-async def handle_navigation_async(
-    page: Page, session_id: str, trace_id: str, client: AsyncLaminarClient
+async def start_recording_events_async(
+    page: Page, session_id: str, client: AsyncLaminarClient
 ):
-    trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
+    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)
 
-    async def collection_loop():
-        try:
-            while not page.is_closed():  # Stop when page closes
-                await send_events_async(page, session_id, trace_id, client)
-                await asyncio.sleep(2)
-            logger.info("Event collection stopped")
-        except Exception as e:
-            logger.error(f"Event collection stopped: {e}")
+    # Get the background loop for async sends (independent of Playwright's loop)
+    background_loop = get_background_loop()
+
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+
+    # Create the async event handler (shared implementation)
+    send_events_from_browser = create_send_events_handler(
+        chunk_buffers, session_id, trace_id, client, background_loop
+    )
+
+    try:
+        await page.expose_function("lmnrSendEvents", send_events_from_browser)
+    except Exception as e:
+        logger.debug(f"Could not expose function: {e}")
 
-    # Create and store task
-    task = asyncio.create_task(collection_loop())
+    await inject_session_recorder_async(page)
 
-    async def on_load():
+    async def on_load(p):
         try:
-            await inject_rrweb_async(page)
+            # Check if page is closed before attempting to inject
+            if not p.is_closed():
+                await inject_session_recorder_async(p)
         except Exception as e:
-            logger.error(f"Error in on_load handler: {e}")
+            logger.debug(f"Error in on_load handler: {e}")
 
-    async def on_close():
-        try:
-            task.cancel()
-            await send_events_async(page, session_id, trace_id, client)
-        except Exception:
-            pass
-
-    page.on("load", lambda: asyncio.create_task(on_load()))
-    page.on("close", lambda: asyncio.create_task(on_close()))
-
-    original_bring_to_front = page.bring_to_front
-
-    async def bring_to_front():
-        await original_bring_to_front()
-
-        await page.evaluate(
-            """() => {
-            if (window.lmnrRrweb) {
-                try {
-                    window.lmnrRrweb.record.takeFullSnapshot();
-                } catch (e) {
-                    console.error("Error taking full snapshot:", e);
-                }
-            }
-        }"""
-        )
+    page.on("domcontentloaded", on_load)
 
-    page.bring_to_front = bring_to_front
-    await inject_rrweb_async(page)
+
+def take_full_snapshot(page: Page):
+    return page.evaluate(
+        """() => {
+        if (window.lmnrRrweb) {
+            try {
+                window.lmnrRrweb.record.takeFullSnapshot();
+                return true;
+            } catch (e) {
+                console.error("Error taking full snapshot:", e);
+                return false;
+            }
+        }
+        return false;
+    }"""
+    )
+
+
+async def take_full_snapshot_async(page: Page):
+    return await page.evaluate(
+        """() => {
+        if (window.lmnrRrweb) {
+            try {
+                window.lmnrRrweb.record.takeFullSnapshot();
+                return true;
+            } catch (e) {
+                console.error("Error taking full snapshot:", e);
+                return false;
+            }
+        }
+        return false;
+    }"""
+    )