lmnr 0.4.66__py3-none-any.whl → 0.5.1__py3-none-any.whl

lmnr/sdk/browser/pw_utils.py

@@ -0,0 +1,289 @@
+import asyncio
+import logging
+import os
+import time
+import threading
+
+from opentelemetry import trace
+
+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
+
+try:
+    from playwright.async_api import Page
+    from playwright.sync_api import Page as SyncPage
+except ImportError as e:
+    raise ImportError(
+        f"Attempted to import {__file__}, but it is designed "
+        "to patch Playwright, which is not installed. Use `pip install playwright` "
+        "to install Playwright or remove this import."
+    ) from 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:
+    RRWEB_CONTENT = f"() => {{ {f.read()} }}"
+
+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 () => {
+        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));
+        }
+    }, 1000);
+
+    window.lmnrRrweb.record({
+        async emit(event) {
+            // Ignore events from all tabs except the current one
+            if (document.visibilityState === 'hidden' || document.hidden) {
+                return;
+            }
+            // Compress the data field
+            const compressedEvent = {
+                ...event,
+                data: await compressEventData(event.data)
+            };
+            window.lmnrRrwebEventsBatch.add(compressedEvent);
+        }
+    });
+}
+"""
+
+
+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
+        has_function = await page.evaluate(
+            """
+            () => typeof window.lmnrGetAndClearEvents === 'function'
+        """
+        )
+        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}")
+
+
+def send_events_sync(
+    page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
+):
+    """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()")
+        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}")
+
+
+def inject_rrweb_sync(page: SyncPage):
+    try:
+        page.wait_for_load_state("domcontentloaded")
+
+        # Wrap the evaluate call in a try-catch
+        try:
+            is_loaded = page.evaluate(
+                """() => typeof window.lmnrRrweb !== 'undefined'"""
+            )
+        except Exception as e:
+            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            is_loaded = False
+
+        if not is_loaded:
+
+            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}")
+                    return False
+
+            if not retry_sync(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        try:
+            page.evaluate(INJECT_PLACEHOLDER)
+        except Exception as e:
+            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+    except Exception as e:
+        logger.error(f"Error during rrweb injection: {e}")
+
+
+async def inject_rrweb_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}")
+            is_loaded = False
+
+        if not is_loaded:
+
+            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}")
+                    return False
+
+            if not await retry_async(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        try:
+            await page.evaluate(INJECT_PLACEHOLDER)
+        except Exception as e:
+            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+    except Exception as e:
+        logger.error(f"Error during rrweb 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
+):
+    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)
+
+    def on_load():
+        try:
+            inject_rrweb_sync(page)
+        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()
+
+
+@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}")
+
+    # Create and store task
+    task = asyncio.create_task(collection_loop())
+
+    # Clean up task when page closes
+    page.on("close", lambda: task.cancel())

lmnr/sdk/browser/utils.py

@@ -1,62 +1,15 @@
 import asyncio
 import logging
 import time
+from typing import Union
+
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 
 logger = logging.getLogger(__name__)
 
-INJECT_PLACEHOLDER = """
-() => {
-    const BATCH_SIZE = 1000;  // Maximum events to store in memory
-    
-    window.lmnrRrwebEventsBatch = [];
-    
-    // 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 = [];
-        return events;
-    };
-
-    // Add heartbeat events
-    setInterval(async () => {
-        const heartbeat = {
-            type: 6,
-            data: await compressEventData({ source: 'heartbeat' }),
-            timestamp: Date.now()
-        };
-        
-        window.lmnrRrwebEventsBatch.push(heartbeat);
-        
-        // Prevent memory issues by limiting batch size
-        if (window.lmnrRrwebEventsBatch.length > BATCH_SIZE) {
-            window.lmnrRrwebEventsBatch = window.lmnrRrwebEventsBatch.slice(-BATCH_SIZE);
-        }
-    }, 1000);
-
-    window.lmnrRrweb.record({
-        async emit(event) {
-            // Compress the data field
-            const compressedEvent = {
-                ...event,
-                data: await compressEventData(event.data)
-            };
-            window.lmnrRrwebEventsBatch.push(compressedEvent);
-        }
-    });
-}
-"""
-
-
-def _with_tracer_wrapper(func):
+
+def with_tracer_wrapper(func):
     """Helper for providing tracer for wrapper functions."""
 
     def _with_tracer(tracer, to_wrap):
@@ -68,6 +21,18 @@ def _with_tracer_wrapper(func):
     return _with_tracer
 
 
+def with_tracer_and_client_wrapper(func):
+    """Helper for providing tracer and client for wrapper functions."""
+
+    def _with_tracer(tracer, client: Union[LaminarClient, AsyncLaminarClient], to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, client, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer
+
+
 def retry_sync(func, retries=5, delay=0.5, error_message="Operation failed"):
     """Utility function for retry logic in synchronous operations"""
     for attempt in range(retries):

lmnr/sdk/client/asynchronous/async_client.py

@@ -0,0 +1,157 @@
+"""
+Laminar HTTP client. Used to send data to/from the Laminar API.
+"""
+
+import httpx
+import re
+from typing import Optional, TypeVar
+from types import TracebackType
+
+from lmnr.sdk.client.asynchronous.resources import (
+    AsyncAgent,
+    AsyncBrowserEvents,
+    AsyncEvals,
+    AsyncPipeline,
+    AsyncSemanticSearch,
+)
+from lmnr.sdk.utils import from_env
+
+_T = TypeVar("_T", bound="AsyncLaminarClient")
+
+
+class AsyncLaminarClient:
+    __base_url: str
+    __project_api_key: str
+    __client: httpx.AsyncClient = None
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        project_api_key: Optional[str] = None,
+        port: Optional[int] = None,
+        timeout: int = 3600,
+    ):
+        """Initializer for the Laminar HTTP client.
+
+        Args:
+            base_url (str): base URL of the Laminar API.
+            project_api_key (str): Laminar project API key
+            port (Optional[int], optional): port of the Laminar API HTTP server.\
+                Overrides any port in the base URL.
+                Defaults to None. If none is provided, the default port (443) will
+                be used.
+            timeout (int, optional): global timeout seconds for the HTTP client.\
+                Applied to all httpx operations, i.e. connect, read, get_from_pool, etc.
+                Defaults to 3600.
+        """
+        # If port is already in the base URL, use it as is
+        base_url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
+        if match := re.search(r":(\d{1,5})$", base_url):
+            base_url = base_url[: -len(match.group(0))]
+            if port is None:
+                port = int(match.group(1))
+
+        base_url = base_url.rstrip("/")
+        self.__base_url = f"{base_url}:{port or 443}"
+        self.__project_api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
+        if not self.__project_api_key:
+            raise ValueError(
+                "Project API key is not set. Please set the LMNR_PROJECT_API_KEY environment "
+                "variable or pass project_api_key to the initializer."
+            )
+
+        self.__client = httpx.AsyncClient(
+            headers=self._headers(),
+            timeout=timeout,
+        )
+
+        # Initialize resource objects
+        self.__pipeline = AsyncPipeline(
+            self.__client, self.__base_url, self.__project_api_key
+        )
+        self.__semantic_search = AsyncSemanticSearch(
+            self.__client, self.__base_url, self.__project_api_key
+        )
+        self.__agent = AsyncAgent(
+            self.__client, self.__base_url, self.__project_api_key
+        )
+        self.__evals = AsyncEvals(
+            self.__client, self.__base_url, self.__project_api_key
+        )
+        self.__browser_events = AsyncBrowserEvents(
+            self.__client, self.__base_url, self.__project_api_key
+        )
+
+    @property
+    def pipeline(self) -> AsyncPipeline:
+        """Get the Pipeline resource.
+
+        Returns:
+            Pipeline: The Pipeline resource instance.
+        """
+        return self.__pipeline
+
+    @property
+    def semantic_search(self) -> AsyncSemanticSearch:
+        """Get the SemanticSearch resource.
+
+        Returns:
+            SemanticSearch: The SemanticSearch resource instance.
+        """
+        return self.__semantic_search
+
+    @property
+    def agent(self) -> AsyncAgent:
+        """Get the Agent resource.
+
+        Returns:
+            Agent: The Agent resource instance.
+        """
+        return self.__agent
+
+    @property
+    def _evals(self) -> AsyncEvals:
+        """Get the Evals resource.
+
+        Returns:
+            Evals: The Evals resource instance.
+        """
+        return self.__evals
+
+    @property
+    def _browser_events(self) -> AsyncBrowserEvents:
+        """Get the BrowserEvents resource.
+
+        Returns:
+            BrowserEvents: The BrowserEvents resource instance.
+        """
+        return self.__browser_events
+
+    def is_closed(self) -> bool:
+        return self.__client.is_closed
+
+    async def close(self) -> None:
+        """Close the underlying HTTPX client.
+
+        The client will *not* be usable after this.
+        """
+        await self.__client.aclose()
+
+    async def __aenter__(self: _T) -> _T:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+    def _headers(self) -> dict[str, str]:
+        assert self.__project_api_key is not None, "Project API key is not set"
+        return {
+            "Authorization": "Bearer " + self.__project_api_key,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }

lmnr/sdk/client/asynchronous/resources/__init__.py

@@ -0,0 +1,13 @@
+from lmnr.sdk.client.asynchronous.resources.agent import AsyncAgent
+from lmnr.sdk.client.asynchronous.resources.browser_events import AsyncBrowserEvents
+from lmnr.sdk.client.asynchronous.resources.evals import AsyncEvals
+from lmnr.sdk.client.asynchronous.resources.pipeline import AsyncPipeline
+from lmnr.sdk.client.asynchronous.resources.semantic_search import AsyncSemanticSearch
+
+__all__ = [
+    "AsyncPipeline",
+    "AsyncSemanticSearch",
+    "AsyncAgent",
+    "AsyncEvals",
+    "AsyncBrowserEvents",
+]