lmnr 0.5.1a0__py3-none-any.whl → 0.5.3__py3-none-any.whl

lmnr/sdk/browser/pw_utils.py

@@ -3,7 +3,6 @@ import logging
 import os
 import time
 import threading
-from typing import Optional
 
 from opentelemetry import trace
 
@@ -24,23 +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()
-client: Optional[LaminarClient] = None
-async_client: Optional[AsyncLaminarClient] = None
-
-
 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);
@@ -50,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();
@@ -59,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,
@@ -97,22 +100,26 @@ 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(
-            """
-            () => typeof window.lmnrGetAndClearEvents === 'function'
-        """
-        )
-        if not has_function:
-            return
+        events = await page.evaluate("""
+        () => {
+            if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
+                return [];
+            }
+            return window.lmnrGetAndClearEvents();
+        }
+        """)
 
-        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(
@@ -120,23 +127,26 @@ def send_events_sync(
 ):
     """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()")
+        events = page.evaluate("""
+        () => {
+            if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
+                return [];
+            }
+            return 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):
@@ -157,10 +167,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}")
@@ -198,10 +204,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,27 +225,26 @@ async def inject_rrweb_async(page: Page):
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
 def handle_navigation_sync(
-    page: SyncPage,
-    session_id: str,
-    trace_id: str,
-    project_api_key: Optional[str] = None,
-    base_http_url: Optional[str] = None,
+    page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
 ):
-    global client
-    if client is None:
-        client = LaminarClient(base_url=base_http_url, project_api_key=project_api_key)
-    if (base_http_url is not None and base_http_url != client.base_url) or (
-        project_api_key is not None and project_api_key != client.project_api_key
-    ):
-        if client is not None:
-            client.close()
-        client = LaminarClient(base_url=base_http_url, project_api_key=project_api_key)
     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:
@@ -251,48 +252,43 @@ 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():
+        while not page.is_closed():  # Stop when page closes
             send_events_sync(page, session_id, trace_id, client)
             time.sleep(2)
 
-        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,
-    project_api_key: Optional[str] = None,
-    base_http_url: Optional[str] = None,
+    page: Page, session_id: str, trace_id: str, client: AsyncLaminarClient
 ):
-    global async_client
-    if async_client is None:
-        async_client = AsyncLaminarClient(
-            base_url=base_http_url, project_api_key=project_api_key
-        )
-    if (base_http_url is not None and base_http_url != async_client.base_url) or (
-        project_api_key is not None and project_api_key != async_client.project_api_key
-    ):
-        if async_client is not None:
-            await async_client.close()
-        async_client = AsyncLaminarClient(
-            base_url=base_http_url, project_api_key=project_api_key
-        )
     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 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}")
+
+    # Create and store task
+    task = asyncio.create_task(collection_loop())
 
     async def on_load():
         try:
@@ -300,22 +296,32 @@ async def handle_navigation_async(
         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()))
-    await inject_rrweb_async(page)
+    page.on("close", lambda: asyncio.create_task(on_close()))
 
-    async def collection_loop(client: AsyncLaminarClient):
-        try:
-            while not page.is_closed():
-                await send_events_async(page, session_id, trace_id, client)
-                await asyncio.sleep(2)
+    original_bring_to_front = page.bring_to_front
 
-            async_instrumented_pages.remove(page_id)
-            logger.info("Event collection stopped")
-        except Exception as e:
-            logger.error(f"Event collection stopped: {e}")
+    async def bring_to_front():
+        await original_bring_to_front()
 
-    # Create and store task
-    task = asyncio.create_task(collection_loop(async_client))
+        await page.evaluate(
+            """() => {
+            if (window.lmnrRrweb) {
+                try {
+                    window.lmnrRrweb.record.takeFullSnapshot();
+                } catch (e) {
+                    console.error("Error taking full snapshot:", e);
+                }
+            }
+        }"""
+        )
 
-    # Clean up task when page closes
-    page.on("close", lambda: task.cancel())
+    page.bring_to_front = bring_to_front
+    await inject_rrweb_async(page)