lmnr 0.7.2__tar.gz → 0.7.3__tar.gz

{lmnr-0.7.2 → lmnr-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.2
+Version: 0.7.3
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>

{lmnr-0.7.2 → lmnr-0.7.3}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.2"
+version = "0.7.3"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }
@@ -124,7 +124,7 @@ dev = [
   "pytest-asyncio>=0.26.0",
   "playwright>=1.52.0",
   "vcrpy>=7.0.0",
-  "openai>=1.98.0",
+  "openai>=1.99.3",
   "pytest-recording>=0.13.4",
   "patchright>=1.52.3",
   "google-genai>=1.19.0",

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/__init__.py

@@ -3,6 +3,7 @@ from .sdk.client.asynchronous.async_client import AsyncLaminarClient
 from .sdk.datasets import EvaluationDataset, LaminarDataset
 from .sdk.evaluations import evaluate
 from .sdk.laminar import Laminar
+from .sdk.types import SessionRecordingOptions, MaskInputOptions
 from .sdk.types import (
     AgentOutput,
     FinalOutputChunkContent,
@@ -38,4 +39,6 @@ __all__ = [
     "get_tracer",
     "evaluate",
     "observe",
+    "SessionRecordingOptions",
+    "MaskInputOptions",
 ]

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/opentelemetry_lib/__init__.py

@@ -6,6 +6,7 @@ from opentelemetry.sdk.resources import SERVICE_NAME
 
 from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
+from lmnr.sdk.types import SessionRecordingOptions
 
 MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024 * 10  # 10MB
 
@@ -30,6 +31,7 @@ class TracerManager:
         timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ) -> None:
         enable_content_tracing = True
 
@@ -50,6 +52,7 @@ class TracerManager:
             timeout_seconds=timeout_seconds,
             set_global_tracer_provider=set_global_tracer_provider,
             otel_logger_level=otel_logger_level,
+            session_recording_options=session_recording_options,
         )
 
     @staticmethod

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -1012,7 +1012,7 @@ def _parse_tool_calls(
         # Handle dict or ChatCompletionMessageToolCall
         if isinstance(tool_call, dict):
             tool_call_data = copy.deepcopy(tool_call)
-        elif isinstance(tool_call, ChatCompletionMessageToolCall):
+        elif _is_tool_call_model(tool_call):
             tool_call_data = tool_call.model_dump()
         elif isinstance(tool_call, FunctionCall):
             function_call = tool_call.model_dump()
@@ -1029,6 +1029,17 @@ def _parse_tool_calls(
     return result
 
 
+def _is_tool_call_model(tool_call):
+    try:
+        from openai.types.chat.chat_completion_message_tool_call import (
+            ChatCompletionMessageFunctionToolCall,
+        )
+
+        return isinstance(tool_call, ChatCompletionMessageFunctionToolCall)
+    except Exception:
+        return False
+
+
 @singledispatch
 def _parse_choice_event(choice) -> ChoiceEvent:
     has_message = choice.message is not None

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/opentelemetry_lib/tracing/__init__.py

@@ -5,6 +5,7 @@ import threading
 from lmnr.opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
+from lmnr.sdk.types import SessionRecordingOptions
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.opentelemetry_lib.tracing.instruments import (
     Instruments,
@@ -38,6 +39,7 @@ MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
+    session_recording_options: SessionRecordingOptions = {}
     _lock = threading.Lock()
     _tracer_provider: TracerProvider | None = None
     _logger: logging.Logger
@@ -62,6 +64,7 @@ class TracerWrapper(object):
         timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ) -> "TracerWrapper":
         # Silence some opentelemetry warnings
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
@@ -71,6 +74,9 @@ class TracerWrapper(object):
             if not hasattr(cls, "instance"):
                 cls._initialize_logger(cls)
                 obj = super(TracerWrapper, cls).__new__(cls)
+                
+                # Store session recording options
+                cls.session_recording_options = session_recording_options or {}
 
                 obj._client = LaminarClient(
                     base_url=base_http_url,
@@ -243,6 +249,11 @@ class TracerWrapper(object):
             self._logger.warning("TracerWrapper not fully initialized, cannot flush")
             return False
         return self._span_processor.force_flush()
+    
+    @classmethod
+    def get_session_recording_options(cls) -> SessionRecordingOptions:
+        """Get the session recording options set during initialization."""
+        return cls.session_recording_options
 
     def get_tracer(self):
         if self._tracer_provider is None:

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/sdk/browser/pw_utils.py

@@ -1,5 +1,7 @@
+import orjson
 import logging
 import os
+import time
 
 from opentelemetry import trace
 
@@ -9,6 +11,8 @@ 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
 from lmnr.opentelemetry_lib.tracing.context import get_current_context
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
+from lmnr.sdk.types import MaskInputOptions
 
 try:
     if is_package_installed("playwright"):
@@ -32,17 +36,24 @@ except ImportError as e:
 
 logger = logging.getLogger(__name__)
 
+OLD_BUFFER_TIMEOUT = 60
+
 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()} }}"
 
 INJECT_PLACEHOLDER = """
-() => {
+(mask_input_options) => {
     const BATCH_TIMEOUT = 2000; // Send events after 2 seconds
     const MAX_WORKER_PROMISES = 50; // Max concurrent worker promises
     const HEARTBEAT_INTERVAL = 1000;
-    
+    const CHUNK_SIZE = 256 * 1024; // 256KB chunks
+    const CHUNK_SEND_DELAY = 100; // 100ms delay between chunks
+
     window.lmnrRrwebEventsBatch = [];
+    window.lmnrChunkQueue = [];
+    window.lmnrChunkSequence = 0;
+    window.lmnrCurrentBatchId = null;
 
     // Create a Web Worker for heavy JSON processing with chunked processing
     const createCompressionWorker = () => {
@@ -99,6 +110,25 @@ INJECT_PLACEHOLDER = """
     let compressionWorker = null;
     let workerPromises = new Map();
     let workerId = 0;
+    let workerSupported = null; // null = unknown, true = supported, false = blocked by CSP
+
+    // Test if workers are supported (not blocked by CSP)
+    function testWorkerSupport() {
+        if (workerSupported !== null) {
+            return workerSupported;
+        }
+        
+        try {
+            const testWorker = createCompressionWorker();
+            testWorker.terminate();
+            workerSupported = true;
+            return true;
+        } catch (error) {
+            console.warn('Web Workers blocked by CSP, will use main thread compression:', error);
+            workerSupported = false;
+            return false;
+        }
+    }
 
     // Cleanup function for worker
     const cleanupWorker = () => {
@@ -222,6 +252,11 @@ INJECT_PLACEHOLDER = """
     // Alternative: Use transferable objects for maximum efficiency
     async function compressLargeObjectTransferable(data) {
         try {
+            // Check if workers are supported first
+            if (!testWorkerSupport()) {
+                return compressSmallObject(data);
+            }
+            
             // Clean up stale promises first
             cleanupStalePromises();
             
@@ -281,49 +316,60 @@ INJECT_PLACEHOLDER = """
 
     // Worker-based compression for large objects
     async function compressLargeObject(data, isLarge = true) {
+        // Check if workers are supported first - if not, use main thread compression
+        if (!testWorkerSupport()) {
+            return await compressSmallObject(data);
+        }
+        
         try {
             // Use transferable objects for better performance
             return await compressLargeObjectTransferable(data);
         } catch (error) {
             console.warn('Transferable failed, falling back to string method:', error);
-            // Fallback to string method
-            const jsonString = await stringifyNonBlocking(data);
+            try {
+                // Fallback to string method with worker
+                const jsonString = await stringifyNonBlocking(data);
+
+                return new Promise((resolve, reject) => {
+                    if (!compressionWorker) {
+                        compressionWorker = createCompressionWorker();
+                        compressionWorker.onmessage = (e) => {
+                            const { id, success, data: result, error } = e.data;
+                            const promise = workerPromises.get(id);
+                            if (promise) {
+                                workerPromises.delete(id);
+                                if (success) {
+                                    promise.resolve(result);
+                                } else {
+                                    promise.reject(new Error(error));
+                                }
+                            }
+                        };
+                        
+                        compressionWorker.onerror = (error) => {
+                            console.error('Compression worker error:', error);
+                            cleanupWorker();
+                        };
+                    }
 
-            return new Promise((resolve, reject) => {
-                if (!compressionWorker) {
-                    compressionWorker = createCompressionWorker();
-                    compressionWorker.onmessage = (e) => {
-                        const { id, success, data: result, error } = e.data;
-                        const promise = workerPromises.get(id);
-                        if (promise) {
+                    const id = ++workerId;
+                    workerPromises.set(id, { resolve, reject });
+                    
+                    // Set timeout to prevent hanging promises
+                    setTimeout(() => {
+                        if (workerPromises.has(id)) {
                             workerPromises.delete(id);
-                            if (success) {
-                                promise.resolve(result);
-                            } else {
-                                promise.reject(new Error(error));
-                            }
+                            reject(new Error('Compression timeout'));
                         }
-                    };
+                    }, 10000);
                     
-                    compressionWorker.onerror = (error) => {
-                        console.error('Compression worker error:', error);
-                        cleanupWorker();
-                    };
-                }
-
-                const id = ++workerId;
-                workerPromises.set(id, { resolve, reject });
-                
-                // Set timeout to prevent hanging promises
-                setTimeout(() => {
-                    if (workerPromises.has(id)) {
-                        workerPromises.delete(id);
-                        reject(new Error('Compression timeout'));
-                    }
-                }, 10000);
-                
-                compressionWorker.postMessage({ jsonString, id });
-            });
+                    compressionWorker.postMessage({ jsonString, id });
+                });
+            } catch (workerError) {
+                console.warn('Worker creation failed, falling back to main thread compression:', workerError);
+                // Final fallback: compress on main thread (may block UI but will work)
+                return await compressSmallObject(data);
+            }
         }
     }
 
@@ -343,15 +389,82 @@ INJECT_PLACEHOLDER = """
         return false;
     }
 
+    // Create chunks from a string with metadata
+    function createChunks(str, batchId) {
+        const chunks = [];
+        const totalChunks = Math.ceil(str.length / CHUNK_SIZE);
+        
+        for (let i = 0; i < str.length; i += CHUNK_SIZE) {
+            const chunk = str.slice(i, i + CHUNK_SIZE);
+            chunks.push({
+                batchId: batchId,
+                chunkIndex: chunks.length,
+                totalChunks: totalChunks,
+                data: chunk,
+                isFinal: chunks.length === totalChunks - 1
+            });
+        }
+        
+        return chunks;
+    }
+
+    // Send chunks with flow control
+    async function sendChunks(chunks) {
+        if (typeof window.lmnrSendEvents !== 'function') {
+            return;
+        }
+
+        window.lmnrChunkQueue.push(...chunks);
+        
+        // Process queue
+        while (window.lmnrChunkQueue.length > 0) {
+            const chunk = window.lmnrChunkQueue.shift();
+            try {
+                await window.lmnrSendEvents(chunk);
+                // Small delay between chunks to avoid overwhelming CDP
+                await new Promise(resolve => setTimeout(resolve, CHUNK_SEND_DELAY));
+            } catch (error) {
+                console.error('Failed to send chunk:', error);
+                // On error, clear failed chunk batch from queue
+                window.lmnrChunkQueue = window.lmnrChunkQueue.filter(c => c.batchId !== chunk.batchId);
+                break;
+            }
+        }
+    }
+
     async function sendBatchIfReady() {
         if (window.lmnrRrwebEventsBatch.length > 0 && typeof window.lmnrSendEvents === 'function') {
             const events = window.lmnrRrwebEventsBatch;
             window.lmnrRrwebEventsBatch = [];
 
             try {
-                await window.lmnrSendEvents(events);
+                // Generate unique batch ID
+                const batchId = `${Date.now()}_${window.lmnrChunkSequence++}`;
+                window.lmnrCurrentBatchId = batchId;
+                
+                // Stringify the entire batch
+                const batchString = JSON.stringify(events);
+                
+                // Check size and chunk if necessary
+                if (batchString.length <= CHUNK_SIZE) {
+                    // Small enough to send as single chunk
+                    const chunk = {
+                        batchId: batchId,
+                        chunkIndex: 0,
+                        totalChunks: 1,
+                        data: batchString,
+                        isFinal: true
+                    };
+                    await window.lmnrSendEvents(chunk);
+                } else {
+                    // Need to chunk
+                    const chunks = createChunks(batchString, batchId);
+                    await sendChunks(chunks);
+                }
             } catch (error) {
                 console.error('Failed to send events:', error);
+                // Clear batch to prevent memory buildup
+                window.lmnrRrwebEventsBatch = [];
             }
         }
     }
@@ -387,7 +500,16 @@ INJECT_PLACEHOLDER = """
         },
         recordCanvas: true,
         collectFonts: true,
-        recordCrossOriginIframes: true
+        recordCrossOriginIframes: true,
+        maskInputOptions: {
+            password: true,
+            textarea: mask_input_options.textarea || false,
+            text: mask_input_options.text || false,
+            number: mask_input_options.number || false,
+            select: mask_input_options.select || false,
+            email: mask_input_options.email || false,
+            tel: mask_input_options.tel || false,
+        }
     });
 
     function heartbeat() {
@@ -407,6 +529,30 @@ INJECT_PLACEHOLDER = """
 """
 
 
+def get_mask_input_setting() -> MaskInputOptions:
+    """Get the mask_input setting from session recording configuration."""
+    try:
+        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,
+        )
+
+
 def inject_session_recorder_sync(page: SyncPage):
     try:
         try:
@@ -435,7 +581,7 @@ def inject_session_recorder_sync(page: SyncPage):
                 return
 
             try:
-                page.evaluate(INJECT_PLACEHOLDER)
+                page.evaluate(INJECT_PLACEHOLDER, get_mask_input_setting())
             except Exception as e:
                 logger.debug(f"Failed to inject session recorder: {e}")
 
@@ -471,7 +617,7 @@ async def inject_session_recorder_async(page: Page):
                 return
 
             try:
-                await page.evaluate(INJECT_PLACEHOLDER)
+                await page.evaluate(INJECT_PLACEHOLDER, get_mask_input_setting())
             except Exception as e:
                 logger.debug(f"Failed to inject session recorder placeholder: {e}")
 
@@ -486,11 +632,54 @@ def start_recording_events_sync(page: SyncPage, session_id: str, client: Laminar
     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)
-
-    def send_events_from_browser(events):
+    
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+    
+    def send_events_from_browser(chunk):
         try:
-            if events and len(events) > 0:
-                client._browser_events.send(session_id, trace_id, events)
+            # 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()
+                }
+            
+            # 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 = ''.join(chunk_buffers[batch_id]['chunks'][i] for i in range(total_chunks))
+                
+                # Parse the JSON
+                events = orjson.loads(full_data)
+                
+                # Send to server
+                if events and len(events) > 0:
+                    client._browser_events.send(session_id, trace_id, events)
+                
+                # 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:
             logger.debug(f"Could not send events: {e}")
 
@@ -519,10 +708,55 @@ async def start_recording_events_async(
     trace_id = format(span.get_span_context().trace_id, "032x")
     span.set_attribute("lmnr.internal.has_browser_session", True)
     
-    async def send_events_from_browser(events):
+    # Buffer for reassembling chunks
+    chunk_buffers = {}
+    
+    async def send_events_from_browser(chunk):
         try:
-            if events and len(events) > 0:
-                await client._browser_events.send(session_id, trace_id, events)
+            # 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()
+                }
+            
+            # 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
+                if events and len(events) > 0:
+                    await client._browser_events.send(session_id, trace_id, events)
+                
+                # 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:
             logger.debug(f"Could not send events: {e}")
 

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/sdk/decorators.py

@@ -102,7 +102,8 @@ def observe(
             ):
                 logger.warning("Tags must be a list of strings. Tags will be ignored.")
             else:
-                association_properties["tags"] = tags
+                # list(set(tags)) to deduplicate tags
+                association_properties["tags"] = list(set(tags))
         if input_formatter is not None and ignore_input:
             logger.warning(
                 f"observe, function {func.__name__}: Input formatter"

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/sdk/laminar.py

@@ -45,6 +45,7 @@ from .log import VerboseColorfulFormatter
 
 from .types import (
     LaminarSpanContext,
+    SessionRecordingOptions,
     TraceType,
 )
 
@@ -73,6 +74,7 @@ class Laminar:
         export_timeout_seconds: int | None = None,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ):
         """Initialize Laminar context across the application.
         This method must be called before using any other Laminar methods or
@@ -119,6 +121,10 @@ class Laminar:
                 Defaults to True.
             otel_logger_level (int, optional): OpenTelemetry logger level. Defaults\
                 to logging.ERROR.
+            session_recording_options (SessionRecordingOptions | None, optional): Options\
+                for browser session recording. Currently supports 'mask_input'\
+                (bool) to control whether input fields are masked during recording.\
+                Defaults to None (uses default masking behavior).
 
         Raises:
             ValueError: If project API key is not set
@@ -179,6 +185,7 @@ class Laminar:
             timeout_seconds=export_timeout_seconds,
             set_global_tracer_provider=set_global_tracer_provider,
             otel_logger_level=otel_logger_level,
+            session_recording_options=session_recording_options,
         )
 
     @classmethod
@@ -741,7 +748,8 @@ class Laminar:
                 "Tags must be a list of strings. Tags will be ignored."
             )
             return
-        span.set_attribute(f"{ASSOCIATION_PROPERTIES}.tags", tags)
+        # list(set(tags)) to deduplicate tags
+        span.set_attribute(f"{ASSOCIATION_PROPERTIES}.tags", list(set(tags)))
 
     @classmethod
     def set_trace_session_id(cls, session_id: str | None = None):

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/sdk/types.py

@@ -9,7 +9,7 @@ import uuid
 
 from enum import Enum
 from opentelemetry.trace import SpanContext, TraceFlags
-from typing import Any, Awaitable, Callable, Literal, Optional
+from typing import Any, Awaitable, Callable, Literal, Optional, TypedDict
 
 from .utils import serialize
 
@@ -346,3 +346,15 @@ class RunAgentResponseChunk(pydantic.RootModel):
         | ErrorChunkContent
         | TimeoutChunkContent
     )
+
+
+class MaskInputOptions(TypedDict):
+    textarea: bool | None
+    text: bool | None
+    number: bool | None
+    select: bool | None
+    email: bool | None
+    tel: bool | None
+
+class SessionRecordingOptions(TypedDict):
+    mask_input_options: MaskInputOptions | None

{lmnr-0.7.2 → lmnr-0.7.3}/src/lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"