lmnr 0.4.58__tar.gz → 0.4.60__tar.gz

{lmnr-0.4.58 → lmnr-0.4.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lmnr
-Version: 0.4.58
+Version: 0.4.60
 Summary: Python SDK for Laminar
 License: Apache-2.0
 Author: lmnr.ai

{lmnr-0.4.58 → lmnr-0.4.60}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.4.58"
+version = "0.4.60"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }

{lmnr-0.4.58 → lmnr-0.4.60}/src/lmnr/openllmetry_sdk/config/__init__.py

@@ -7,3 +7,6 @@ def is_tracing_enabled() -> bool:
 
 def is_content_tracing_enabled() -> bool:
     return (os.getenv("TRACELOOP_TRACE_CONTENT") or "true").lower() == "true"
+
+
+MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024  # 1MB

{lmnr-0.4.58 → lmnr-0.4.60}/src/lmnr/openllmetry_sdk/decorators/base.py

@@ -4,7 +4,7 @@ import logging
 import os
 import pydantic
 import types
-from typing import Any, Optional
+from typing import Any, Literal, Optional, Union
 
 from opentelemetry import trace
 from opentelemetry import context as context_api
@@ -12,9 +12,10 @@ from opentelemetry.trace import Span
 
 from lmnr.sdk.utils import get_input_from_func_args, is_method
 from lmnr.openllmetry_sdk.tracing import get_tracer
-from lmnr.openllmetry_sdk.tracing.attributes import SPAN_INPUT, SPAN_OUTPUT
+from lmnr.openllmetry_sdk.tracing.attributes import SPAN_INPUT, SPAN_OUTPUT, SPAN_TYPE
 from lmnr.openllmetry_sdk.tracing.tracing import TracerWrapper
 from lmnr.openllmetry_sdk.utils.json_encoder import JSONEncoder
+from lmnr.openllmetry_sdk.config import MAX_MANUAL_SPAN_PAYLOAD_SIZE
 
 
 class CustomJSONEncoder(JSONEncoder):
@@ -38,6 +39,9 @@ def json_dumps(data: dict) -> str:
 
 def entity_method(
     name: Optional[str] = None,
+    ignore_input: bool = False,
+    ignore_output: bool = False,
+    span_type: Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]] = "DEFAULT",
 ):
     def decorate(fn):
         @wraps(fn)
@@ -48,21 +52,22 @@ def entity_method(
             span_name = name or fn.__name__
 
             with get_tracer() as tracer:
-                span = tracer.start_span(span_name)
+                span = tracer.start_span(span_name, attributes={SPAN_TYPE: span_type})
 
                 ctx = trace.set_span_in_context(span, context_api.get_current())
                 ctx_token = context_api.attach(ctx)
 
                 try:
-                    if _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_INPUT,
-                            json_dumps(
-                                get_input_from_func_args(
-                                    fn, is_method(fn), args, kwargs
-                                )
-                            ),
+                    if _should_send_prompts() and not ignore_input:
+                        inp = json_dumps(
+                            get_input_from_func_args(fn, is_method(fn), args, kwargs)
                         )
+                        if len(inp) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
+                            span.set_attribute(
+                                SPAN_INPUT, "Laminar: input too large to record"
+                            )
+                        else:
+                            span.set_attribute(SPAN_INPUT, inp)
                 except TypeError:
                     pass
 
@@ -78,11 +83,14 @@ def entity_method(
                     return _handle_generator(span, res)
 
                 try:
-                    if _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_OUTPUT,
-                            json_dumps(res),
-                        )
+                    if _should_send_prompts() and not ignore_output:
+                        output = json_dumps(res)
+                        if len(output) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
+                            span.set_attribute(
+                                SPAN_OUTPUT, "Laminar: output too large to record"
+                            )
+                        else:
+                            span.set_attribute(SPAN_OUTPUT, output)
                 except TypeError:
                     pass
 
@@ -99,6 +107,9 @@ def entity_method(
 # Async Decorators
 def aentity_method(
     name: Optional[str] = None,
+    ignore_input: bool = False,
+    ignore_output: bool = False,
+    span_type: Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]] = "DEFAULT",
 ):
     def decorate(fn):
         @wraps(fn)
@@ -109,21 +120,22 @@ def aentity_method(
             span_name = name or fn.__name__
 
             with get_tracer() as tracer:
-                span = tracer.start_span(span_name)
+                span = tracer.start_span(span_name, attributes={SPAN_TYPE: span_type})
 
                 ctx = trace.set_span_in_context(span, context_api.get_current())
                 ctx_token = context_api.attach(ctx)
 
                 try:
-                    if _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_INPUT,
-                            json_dumps(
-                                get_input_from_func_args(
-                                    fn, is_method(fn), args, kwargs
-                                )
-                            ),
+                    if _should_send_prompts() and not ignore_input:
+                        inp = json_dumps(
+                            get_input_from_func_args(fn, is_method(fn), args, kwargs)
                         )
+                        if len(inp) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
+                            span.set_attribute(
+                                SPAN_INPUT, "Laminar: input too large to record"
+                            )
+                        else:
+                            span.set_attribute(SPAN_INPUT, inp)
                 except TypeError:
                     pass
 
@@ -139,8 +151,14 @@ def aentity_method(
                     return await _ahandle_generator(span, ctx_token, res)
 
                 try:
-                    if _should_send_prompts():
-                        span.set_attribute(SPAN_OUTPUT, json_dumps(res))
+                    if _should_send_prompts() and not ignore_output:
+                        output = json_dumps(res)
+                        if len(output) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
+                            span.set_attribute(
+                                SPAN_OUTPUT, "Laminar: output too large to record"
+                            )
+                        else:
+                            span.set_attribute(SPAN_OUTPUT, output)
                 except TypeError:
                     pass
 

{lmnr-0.4.58 → lmnr-0.4.60}/src/lmnr/openllmetry_sdk/tracing/attributes.py

@@ -5,7 +5,10 @@ SPAN_INPUT = "lmnr.span.input"
 SPAN_OUTPUT = "lmnr.span.output"
 SPAN_TYPE = "lmnr.span.type"
 SPAN_PATH = "lmnr.span.path"
+SPAN_IDS_PATH = "lmnr.span.ids_path"
 SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source"
+SPAN_SDK_VERSION = "lmnr.span.sdk_version"
+SPAN_LANGUAGE_VERSION = "lmnr.span.language_version"
 OVERRIDE_PARENT_SPAN = "lmnr.internal.override_parent_span"
 
 ASSOCIATION_PROPERTIES = "lmnr.association.properties"

{lmnr-0.4.58 → lmnr-0.4.60}/src/lmnr/openllmetry_sdk/tracing/tracing.py

@@ -1,7 +1,7 @@
 import atexit
 import copy
 import logging
-
+import uuid
 
 from contextvars import Context
 from lmnr.sdk.log import VerboseColorfulFormatter
@@ -9,7 +9,10 @@ from lmnr.openllmetry_sdk.instruments import Instruments
 from lmnr.sdk.browser import init_browser_tracing
 from lmnr.openllmetry_sdk.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
+    SPAN_IDS_PATH,
     SPAN_INSTRUMENTATION_SOURCE,
+    SPAN_SDK_VERSION,
+    SPAN_LANGUAGE_VERSION,
     SPAN_PATH,
     TRACING_LEVEL,
 )
@@ -23,6 +26,7 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter as GRPCExporter,
 )
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import Compression
 from opentelemetry.instrumentation.threading import ThreadingInstrumentor
 from opentelemetry.context import get_value, attach, get_current, set_value, Context
 from opentelemetry.propagate import set_global_textmap
@@ -38,6 +42,8 @@ from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 
 from typing import Dict, Optional, Set
 
+from lmnr.version import SDK_VERSION, PYTHON_VERSION
+
 module_logger = logging.getLogger(__name__)
 console_log_handler = logging.StreamHandler()
 console_log_handler.setFormatter(VerboseColorfulFormatter())
@@ -72,6 +78,7 @@ class TracerWrapper(object):
     __tracer_provider: TracerProvider = None
     __logger: logging.Logger = None
     __span_id_to_path: dict[int, list[str]] = {}
+    __span_id_lists: dict[int, list[str]] = {}
 
     def __new__(
         cls,
@@ -132,9 +139,9 @@ class TracerWrapper(object):
             )
 
             if not instrument_set:
-                cls.__logger.warning(
-                    "No valid instruments set. Remove 'instrument' "
-                    "argument to use all instruments, or set a valid instrument."
+                cls.__logger.info(
+                    "No instruments set through Laminar. "
+                    "Only enabling basic OpenTelemetry tracing."
                 )
 
             obj.__content_allow_list = ContentAllowList()
@@ -162,12 +169,22 @@ class TracerWrapper(object):
         parent_span_path = span_path_in_context or (
             self.__span_id_to_path.get(span.parent.span_id) if span.parent else None
         )
+        parent_span_ids_path = (
+            self.__span_id_lists.get(span.parent.span_id, []) if span.parent else []
+        )
         span_path = parent_span_path + [span.name] if parent_span_path else [span.name]
+        span_ids_path = parent_span_ids_path + [
+            str(uuid.UUID(int=span.get_span_context().span_id))
+        ]
         span.set_attribute(SPAN_PATH, span_path)
+        span.set_attribute(SPAN_IDS_PATH, span_ids_path)
         set_value("span_path", span_path, get_current())
         self.__span_id_to_path[span.get_span_context().span_id] = span_path
+        self.__span_id_lists[span.get_span_context().span_id] = span_ids_path
 
         span.set_attribute(SPAN_INSTRUMENTATION_SOURCE, "python")
+        span.set_attribute(SPAN_SDK_VERSION, SDK_VERSION)
+        span.set_attribute(SPAN_LANGUAGE_VERSION, f"python@{PYTHON_VERSION}")
 
         association_properties = get_value("association_properties")
         if association_properties is not None:
@@ -203,6 +220,7 @@ class TracerWrapper(object):
     def clear(cls):
         # Any state cleanup. Now used in between tests
         cls.__span_id_to_path = {}
+        cls.__span_id_lists = {}
 
     def flush(self):
         self.__spans_processor.force_flush()
@@ -268,7 +286,9 @@ def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExpor
     if "http" in api_endpoint.lower() or "https" in api_endpoint.lower():
         return HTTPExporter(endpoint=f"{api_endpoint}/v1/traces", headers=headers)
     else:
-        return GRPCExporter(endpoint=f"{api_endpoint}", headers=headers)
+        return GRPCExporter(
+            endpoint=f"{api_endpoint}", headers=headers, compression=Compression.Gzip
+        )
 
 
 def init_tracer_provider(resource: Resource) -> TracerProvider:

lmnr-0.4.60/src/lmnr/sdk/browser/playwright_patch.py

@@ -0,0 +1,349 @@
+import opentelemetry
+import uuid
+import asyncio
+import logging
+import time
+import os
+
+logger = logging.getLogger(__name__)
+
+try:
+    from playwright.async_api import BrowserContext, Page
+    from playwright.sync_api import (
+        BrowserContext as SyncBrowserContext,
+        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
+
+_original_new_page = None
+_original_new_page_async = None
+
+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 = """
+([baseUrl, projectApiKey]) => {
+    const serverUrl = `${baseUrl}/v1/browser-sessions/events`;
+    const FLUSH_INTERVAL = 1000;
+    const HEARTBEAT_INTERVAL = 1000;
+
+    window.lmnrRrwebEventsBatch = [];
+    
+    window.lmnrSendRrwebEventsBatch = async () => {
+        if (window.lmnrRrwebEventsBatch.length === 0) return;
+        
+        const eventsPayload = {
+            sessionId: window.lmnrRrwebSessionId,
+            traceId: window.lmnrTraceId,
+            events: window.lmnrRrwebEventsBatch
+        };
+        
+        try {
+            const jsonString = JSON.stringify(eventsPayload);
+            const uint8Array = new TextEncoder().encode(jsonString);
+            
+            const cs = new CompressionStream('gzip');
+            const compressedStream = await new Response(
+                new Response(uint8Array).body.pipeThrough(cs)
+            ).arrayBuffer();
+            
+            const compressedArray = new Uint8Array(compressedStream);
+            
+            const blob = new Blob([compressedArray], { type: 'application/octet-stream' });
+            
+            const response = await fetch(serverUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Encoding': 'gzip',
+                    'Authorization': `Bearer ${projectApiKey}`,
+                    'Accept': 'application/json'
+                },
+                body: blob,
+                mode: 'cors',
+                credentials: 'omit'
+            });
+            
+            if (!response.ok) {
+                console.error(`HTTP error! status: ${response.status}`);
+                if (response.status === 0) {
+                    console.error('Possible CORS issue - check network tab for details');
+                }
+            }
+
+            window.lmnrRrwebEventsBatch = [];
+        } catch (error) {
+            console.error('Failed to send events:', error);
+        }
+    };
+
+    setInterval(() => window.lmnrSendRrwebEventsBatch(), FLUSH_INTERVAL);
+
+    setInterval(() => {
+        window.lmnrRrwebEventsBatch.push({
+            type: 6,
+            data: { source: 'heartbeat' },
+            timestamp: Date.now()
+        });
+    }, HEARTBEAT_INTERVAL);
+
+    window.lmnrRrweb.record({
+        emit(event) {
+            window.lmnrRrwebEventsBatch.push(event);
+        }
+    });
+
+    window.addEventListener('beforeunload', () => {
+        window.lmnrSendRrwebEventsBatch();
+    });
+}
+"""
+
+
+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):
+        try:
+            result = func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        time.sleep(delay)
+    return None
+
+
+async def retry_async(func, retries=5, delay=0.5, error_message="Operation failed"):
+    """Utility function for retry logic in asynchronous operations"""
+    for attempt in range(retries):
+        try:
+            result = await func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        await asyncio.sleep(delay)
+    return None
+
+
+def init_playwright_tracing(http_url: str, project_api_key: str):
+
+    def inject_rrweb(page: SyncPage):
+        # Wait for the page to be in a ready state first
+        page.wait_for_load_state("domcontentloaded")
+
+        # First check if rrweb is already loaded
+        is_loaded = page.evaluate(
+            """
+            () => typeof window.lmnrRrweb !== 'undefined'
+        """
+        )
+
+        if not is_loaded:
+
+            def load_rrweb():
+                page.evaluate(RRWEB_CONTENT)
+                # Verify script loaded successfully
+                page.wait_for_function(
+                    """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                    timeout=5000,
+                )
+                return True
+
+            if not retry_sync(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        # Get current trace ID from active span
+        current_span = opentelemetry.trace.get_current_span()
+        if current_span.is_recording():
+            current_span.set_attribute("lmnr.internal.has_browser_session", True)
+
+        trace_id = format(current_span.get_span_context().trace_id, "032x")
+        session_id = str(uuid.uuid4().hex)
+
+        def set_window_vars():
+            page.evaluate(
+                """([traceId, sessionId]) => {
+                window.lmnrRrwebSessionId = sessionId;
+                window.lmnrTraceId = traceId;
+            }""",
+                [trace_id, session_id],
+            )
+            return page.evaluate(
+                """
+                () => window.lmnrRrwebSessionId && window.lmnrTraceId
+            """
+            )
+
+        if not retry_sync(
+            set_window_vars, error_message="Failed to set window variables"
+        ):
+            return
+
+        # Update the recording setup to include trace ID
+        page.evaluate(
+            INJECT_PLACEHOLDER,
+            [http_url, project_api_key],
+        )
+
+    async def inject_rrweb_async(page: Page):
+        # Wait for the page to be in a ready state first
+        await page.wait_for_load_state("domcontentloaded")
+
+        # First check if rrweb is already loaded
+        is_loaded = await page.evaluate(
+            """
+            () => typeof window.lmnrRrweb !== 'undefined'
+        """
+        )
+
+        if not is_loaded:
+
+            async def load_rrweb():
+                await page.evaluate(RRWEB_CONTENT)
+                # Verify script loaded successfully
+                await page.wait_for_function(
+                    """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                    timeout=5000,
+                )
+                return True
+
+            if not await retry_async(
+                load_rrweb, delay=1, error_message="Failed to load rrweb"
+            ):
+                return
+
+        # Get current trace ID from active span
+        current_span = opentelemetry.trace.get_current_span()
+        if current_span.is_recording():
+            current_span.set_attribute("lmnr.internal.has_browser_session", True)
+
+        trace_id = format(current_span.get_span_context().trace_id, "032x")
+        session_id = str(uuid.uuid4().hex)
+
+        async def set_window_vars():
+            await page.evaluate(
+                """([traceId, sessionId]) => {
+                window.lmnrRrwebSessionId = sessionId;
+                window.lmnrTraceId = traceId;
+            }""",
+                [trace_id, session_id],
+            )
+            return await page.evaluate(
+                """
+                () => window.lmnrRrwebSessionId && window.lmnrTraceId
+            """
+            )
+
+        if not await retry_async(
+            set_window_vars, error_message="Failed to set window variables"
+        ):
+            return
+
+        # Update the recording setup to include trace ID
+        await page.evaluate(
+            INJECT_PLACEHOLDER,
+            [http_url, project_api_key],
+        )
+
+    def handle_navigation(page: SyncPage):
+        def on_load():
+            inject_rrweb(page)
+
+        page.on("load", on_load)
+        inject_rrweb(page)
+
+    async def handle_navigation_async(page: Page):
+        async def on_load():
+            await inject_rrweb_async(page)
+
+        page.on("load", lambda: asyncio.create_task(on_load()))
+        await inject_rrweb_async(page)
+
+    async def patched_new_page_async(self: BrowserContext, *args, **kwargs):
+        # Modify CSP to allow required domains
+        async def handle_route(route):
+            try:
+                response = await route.fetch()
+                headers = dict(response.headers)
+
+                # Find and modify CSP header
+                for header_name in headers:
+                    if header_name.lower() == "content-security-policy":
+                        csp = headers[header_name]
+                        parts = csp.split(";")
+                        for i, part in enumerate(parts):
+                            if "connect-src" in part:
+                                parts[i] = f"{part.strip()} {http_url}"
+                        headers[header_name] = ";".join(parts)
+
+                await route.fulfill(response=response, headers=headers)
+            except Exception as e:
+                logger.debug(f"Error handling route: {e}")
+                await route.continue_()
+
+        # Intercept all navigation requests to modify CSP headers
+        await self.route("**/*", handle_route)
+        page = await _original_new_page_async(self, *args, **kwargs)
+        await handle_navigation_async(page)
+        return page
+
+    def patched_new_page(self: SyncBrowserContext, *args, **kwargs):
+        # Modify CSP to allow required domains
+        def handle_route(route):
+            try:
+                response = route.fetch()
+                headers = dict(response.headers)
+
+                # Find and modify CSP header
+                for header_name in headers:
+                    if header_name.lower() == "content-security-policy":
+                        csp = headers[header_name]
+                        parts = csp.split(";")
+                        for i, part in enumerate(parts):
+                            if "connect-src" in part:
+                                parts[i] = f"{part.strip()} {http_url}"
+                        if not any("connect-src" in part for part in parts):
+                            parts.append(f" connect-src 'self' {http_url}")
+                        headers[header_name] = ";".join(parts)
+
+                route.fulfill(response=response, headers=headers)
+            except Exception as e:
+                logger.debug(f"Error handling route: {e}")
+                route.continue_()
+
+        # Intercept all navigation requests to modify CSP headers
+        self.route("**/*", handle_route)
+        page = _original_new_page(self, *args, **kwargs)
+        handle_navigation(page)
+        return page
+
+    def patch_browser():
+        global _original_new_page, _original_new_page_async
+        if _original_new_page_async is None:
+            _original_new_page_async = BrowserContext.new_page
+            BrowserContext.new_page = patched_new_page_async
+
+        if _original_new_page is None:
+            _original_new_page = SyncBrowserContext.new_page
+            SyncBrowserContext.new_page = patched_new_page
+
+    patch_browser()