lmnr 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

lmnr/sdk/browser/pw_utils.py

@@ -23,21 +23,29 @@ except ImportError as e:
 
 logger = logging.getLogger(__name__)
 
-# Track pages we've already instrumented to avoid double-instrumentation
-instrumented_pages = set()
-async_instrumented_pages = set()
-
-
 current_dir = os.path.dirname(os.path.abspath(__file__))
-with open(os.path.join(current_dir, "rrweb", "rrweb.min.js"), "r") as f:
+with open(os.path.join(current_dir, "rrweb", "rrweb.umd.min.cjs"), "r") as f:
     RRWEB_CONTENT = f"() => {{ {f.read()} }}"
 
 INJECT_PLACEHOLDER = """
 () => {
     const BATCH_SIZE = 1000;  // Maximum events to store in memory
-    
+
     window.lmnrRrwebEventsBatch = new Set();
     
+    // Track page focus state
+    window.lmnrPageIsFocused = true;
+    
+    window.addEventListener('blur', () => {
+        window.lmnrPageIsFocused = false;
+        console.log('Page lost focus');
+    });
+    
+    window.addEventListener('focus', () => {
+        window.lmnrPageIsFocused = true;
+        console.log('Page gained focus');
+    });
+
     // Utility function to compress individual event data
     async function compressEventData(data) {
         const jsonString = JSON.stringify(data);
@@ -47,7 +55,7 @@ INJECT_PLACEHOLDER = """
         const compressedData = await compressedResponse.arrayBuffer();
         return Array.from(new Uint8Array(compressedData));
     }
-    
+
     window.lmnrGetAndClearEvents = () => {
         const events = window.lmnrRrwebEventsBatch;
         window.lmnrRrwebEventsBatch = new Set();
@@ -56,26 +64,24 @@ INJECT_PLACEHOLDER = """
 
     // Add heartbeat events
     setInterval(async () => {
-        const heartbeat = {
-            type: 6,
-            data: await compressEventData({ source: 'heartbeat' }),
-            timestamp: Date.now()
-        };
-        
-        window.lmnrRrwebEventsBatch.add(heartbeat);
-        
-        // Prevent memory issues by limiting batch size
-        if (window.lmnrRrwebEventsBatch.size > BATCH_SIZE) {
-            window.lmnrRrwebEventsBatch = new Set(Array.from(window.lmnrRrwebEventsBatch).slice(-BATCH_SIZE));
+        if (!window.lmnrPageIsFocused) {
+            return;
         }
+
+        window.lmnrRrweb.record.addCustomEvent('heartbeat', {
+            title: document.title,
+            url: document.URL,
+        })
+
     }, 1000);
 
     window.lmnrRrweb.record({
         async emit(event) {
-            // Ignore events from all tabs except the current one
-            if (document.visibilityState === 'hidden' || document.hidden) {
+            // Ignore events when page is not focused
+            if (!window.lmnrPageIsFocused) {
                 return;
             }
+            
             // Compress the data field
             const compressedEvent = {
                 ...event,
@@ -94,22 +100,28 @@ async def send_events_async(
     """Fetch events from the page and send them to the server"""
     try:
         # Check if function exists first
-        has_function = await page.evaluate(
+        events = await page.evaluate(
             """
-            () => typeof window.lmnrGetAndClearEvents === 'function'
+        () => {
+            if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
+                return [];
+            }
+            return window.lmnrGetAndClearEvents();
+        }
         """
         )
-        if not has_function:
-            return
 
-        events = await page.evaluate("window.lmnrGetAndClearEvents()")
         if not events or len(events) == 0:
             return
 
         await client._browser_events.send(session_id, trace_id, events)
-
     except Exception as e:
-        logger.error(f"Error sending events: {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}")
 
 
 def send_events_sync(
@@ -117,23 +129,28 @@ def send_events_sync(
 ):
     """Synchronous version of send_events"""
     try:
-        # Check if function exists first
-        has_function = page.evaluate(
+        events = page.evaluate(
             """
-            () => typeof window.lmnrGetAndClearEvents === 'function'
+        () => {
+            if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
+                return [];
+            }
+            return window.lmnrGetAndClearEvents();
+        }
         """
         )
-        if not has_function:
-            return
-
-        events = page.evaluate("window.lmnrGetAndClearEvents()")
         if not events or len(events) == 0:
             return
 
         client._browser_events.send(session_id, trace_id, events)
 
     except Exception as e:
-        logger.error(f"Error sending events: {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:
+            logger.debug(f"Could not send events: {e}")
 
 
 def inject_rrweb_sync(page: SyncPage):
@@ -154,10 +171,6 @@ def inject_rrweb_sync(page: SyncPage):
             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}")
@@ -195,10 +208,6 @@ async def inject_rrweb_async(page: Page):
             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}")
@@ -223,11 +232,23 @@ def handle_navigation_sync(
     page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
 ):
     trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
-    # Check if we've already instrumented this page
-    page_id = id(page)
-    if page_id in instrumented_pages:
-        return
-    instrumented_pages.add(page_id)
+    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
 
     def on_load():
         try:
@@ -235,49 +256,37 @@ def handle_navigation_sync(
         except Exception as e:
             logger.error(f"Error in on_load handler: {e}")
 
-    page.on("load", on_load)
-    inject_rrweb_sync(page)
-
     def collection_loop():
         while not page.is_closed():  # Stop when page closes
             send_events_sync(page, session_id, trace_id, client)
             time.sleep(2)
 
-        # Clean up when page closes
-        if page_id in instrumented_pages:
-            instrumented_pages.remove(page_id)
-
     thread = threading.Thread(target=collection_loop, daemon=True)
     thread.start()
 
+    def on_close():
+        try:
+            send_events_sync(page, session_id, trace_id, client)
+            thread.join()
+        except Exception:
+            pass
+
+    page.on("load", on_load)
+    page.on("close", on_close)
+    inject_rrweb_sync(page)
+
 
 @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
 ):
     trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
-    # Check if we've already instrumented this page
-    page_id = id(page)
-    if page_id in async_instrumented_pages:
-        return
-    async_instrumented_pages.add(page_id)
-
-    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, client)
                 await asyncio.sleep(2)
-            # Clean up when page closes
-            async_instrumented_pages.remove(page_id)
             logger.info("Event collection stopped")
         except Exception as e:
             logger.error(f"Event collection stopped: {e}")
@@ -285,5 +294,38 @@ async def handle_navigation_async(
     # Create and store task
     task = asyncio.create_task(collection_loop())
 
-    # Clean up task when page closes
-    page.on("close", lambda: task.cancel())
+    async def on_load():
+        try:
+            await inject_rrweb_async(page)
+        except Exception as e:
+            logger.error(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.bring_to_front = bring_to_front
+    await inject_rrweb_async(page)