lmnr 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

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/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/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -56,8 +56,8 @@ from opentelemetry.trace import SpanKind, Tracer
 from opentelemetry.trace.status import Status, StatusCode
 from wrapt import ObjectProxy
 
-from openai.types.chat import ChatCompletionMessageToolCall
 from openai.types.chat.chat_completion_message import FunctionCall
+import pydantic
 
 SPAN_NAME = "openai.chat"
 PROMPT_FILTER_KEY = "prompt_filter_results"
@@ -995,7 +995,7 @@ async def _abuild_from_streaming_response(
 
 
 def _parse_tool_calls(
-    tool_calls: Optional[List[Union[dict, ChatCompletionMessageToolCall]]],
+    tool_calls: Optional[List[Union[dict, pydantic.BaseModel]]],
 ) -> Union[List[ToolCall], None]:
     """
     Util to correctly parse the tool calls data from the OpenAI API to this module's
@@ -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/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)
@@ -72,6 +75,9 @@ class TracerWrapper(object):
                 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,
                     project_api_key=project_api_key,
@@ -244,7 +250,12 @@ class TracerWrapper(object):
             return False
         return self._span_processor.force_flush()
 
-    def get_tracer(self):
+    @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) -> trace.Tracer:
         if self._tracer_provider is None:
             return trace.get_tracer_provider().get_tracer(TRACER_NAME)
         return self._tracer_provider.get_tracer(TRACER_NAME)

lmnr/opentelemetry_lib/tracing/attributes.py

@@ -14,6 +14,8 @@ SPAN_OUTPUT = "lmnr.span.output"
 SPAN_TYPE = "lmnr.span.type"
 SPAN_PATH = "lmnr.span.path"
 SPAN_IDS_PATH = "lmnr.span.ids_path"
+PARENT_SPAN_PATH = "lmnr.span.parent_path"
+PARENT_SPAN_IDS_PATH = "lmnr.span.parent_ids_path"
 SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source"
 SPAN_SDK_VERSION = "lmnr.span.sdk_version"
 SPAN_LANGUAGE_VERSION = "lmnr.span.language_version"

lmnr/opentelemetry_lib/tracing/processor.py

@@ -7,9 +7,11 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
 )
 from opentelemetry.sdk.trace import Span
-from opentelemetry.context import Context, get_value, get_current, set_value
+from opentelemetry.context import Context, get_value
 
 from lmnr.opentelemetry_lib.tracing.attributes import (
+    PARENT_SPAN_IDS_PATH,
+    PARENT_SPAN_PATH,
     SPAN_IDS_PATH,
     SPAN_INSTRUMENTATION_SOURCE,
     SPAN_LANGUAGE_VERSION,
@@ -52,20 +54,18 @@ class LaminarSpanProcessor(SpanProcessor):
         )
 
     def on_start(self, span: Span, parent_context: Context | None = None):
-        span_path_in_context = get_value("span_path", parent_context or get_current())
-        parent_span_path = span_path_in_context or (
+        parent_span_path = list(span.attributes.get(PARENT_SPAN_PATH, tuple())) 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 []
-        )
+        parent_span_ids_path = list(
+            span.attributes.get(PARENT_SPAN_IDS_PATH, tuple())
+        ) or (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
 

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/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/sdk/laminar.py

@@ -13,6 +13,10 @@ from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing.tracer import get_tracer_with_context
 from lmnr.opentelemetry_lib.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
+    PARENT_SPAN_IDS_PATH,
+    PARENT_SPAN_PATH,
+    SPAN_IDS_PATH,
+    SPAN_PATH,
     USER_ID,
     Attributes,
     SPAN_TYPE,
@@ -45,6 +49,7 @@ from .log import VerboseColorfulFormatter
 
 from .types import (
     LaminarSpanContext,
+    SessionRecordingOptions,
     TraceType,
 )
 
@@ -73,6 +78,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 +125,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 +189,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
@@ -309,9 +320,29 @@ class Laminar:
 
         with get_tracer_with_context() as (tracer, isolated_context):
             ctx = context or isolated_context
+            path = []
+            span_ids_path = []
             if parent_span_context is not None:
+                if isinstance(parent_span_context, (dict, str)):
+                    try:
+                        laminar_span_context = LaminarSpanContext.deserialize(
+                            parent_span_context
+                        )
+                        path = laminar_span_context.span_path
+                        span_ids_path = laminar_span_context.span_ids_path
+                    except Exception:
+                        cls.__logger.warning(
+                            f"`start_as_current_span` Could not deserialize parent_span_context: {parent_span_context}. "
+                            "Will use it as is."
+                        )
+                        laminar_span_context = parent_span_context
+                else:
+                    laminar_span_context = parent_span_context
+                    if isinstance(laminar_span_context, LaminarSpanContext):
+                        path = laminar_span_context.span_path
+                        span_ids_path = laminar_span_context.span_ids_path
                 span_context = LaminarSpanContext.try_to_otel_span_context(
-                    parent_span_context, cls.__logger
+                    laminar_span_context, cls.__logger
                 )
                 ctx = trace.set_span_in_context(
                     trace.NonRecordingSpan(span_context), ctx
@@ -345,6 +376,8 @@ class Laminar:
                 context=ctx,
                 attributes={
                     SPAN_TYPE: span_type,
+                    PARENT_SPAN_PATH: path,
+                    PARENT_SPAN_IDS_PATH: span_ids_path,
                     **(label_props),
                     **(tag_props),
                 },
@@ -447,9 +480,29 @@ class Laminar:
 
         with get_tracer_with_context() as (tracer, isolated_context):
             ctx = context or isolated_context
+            path = []
+            span_ids_path = []
             if parent_span_context is not None:
+                if isinstance(parent_span_context, (dict, str)):
+                    try:
+                        laminar_span_context = LaminarSpanContext.deserialize(
+                            parent_span_context
+                        )
+                        path = laminar_span_context.span_path
+                        span_ids_path = laminar_span_context.span_ids_path
+                    except Exception:
+                        cls.__logger.warning(
+                            f"`start_span` Could not deserialize parent_span_context: {parent_span_context}. "
+                            "Will use it as is."
+                        )
+                        laminar_span_context = parent_span_context
+                else:
+                    laminar_span_context = parent_span_context
+                    if isinstance(laminar_span_context, LaminarSpanContext):
+                        path = laminar_span_context.span_path
+                        span_ids_path = laminar_span_context.span_ids_path
                 span_context = LaminarSpanContext.try_to_otel_span_context(
-                    parent_span_context, cls.__logger
+                    laminar_span_context, cls.__logger
                 )
                 ctx = trace.set_span_in_context(
                     trace.NonRecordingSpan(span_context), ctx
@@ -484,6 +537,8 @@ class Laminar:
                 context=ctx,
                 attributes={
                     SPAN_TYPE: span_type,
+                    PARENT_SPAN_PATH: path,
+                    PARENT_SPAN_IDS_PATH: span_ids_path,
                     **(label_props),
                     **(tag_props),
                 },
@@ -655,6 +710,8 @@ class Laminar:
             trace_id=uuid.UUID(int=span.get_span_context().trace_id),
             span_id=uuid.UUID(int=span.get_span_context().span_id),
             is_remote=span.get_span_context().is_remote,
+            span_path=span.attributes.get(SPAN_PATH, []),
+            span_ids_path=span.attributes.get(SPAN_IDS_PATH, []),
         )
 
     @classmethod
@@ -741,7 +798,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/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
 
@@ -169,6 +169,8 @@ class LaminarSpanContext(pydantic.BaseModel):
     trace_id: uuid.UUID
     span_id: uuid.UUID
     is_remote: bool = pydantic.Field(default=False)
+    span_path: list[str] = pydantic.Field(default=[])
+    span_ids_path: list[str] = pydantic.Field(default=[])  # stringified UUIDs
 
     def __str__(self) -> str:
         return self.model_dump_json()
@@ -199,7 +201,7 @@ class LaminarSpanContext(pydantic.BaseModel):
                 "Please use `LaminarSpanContext` instead."
             )
             return span_context
-        elif isinstance(span_context, dict) or isinstance(span_context, str):
+        elif isinstance(span_context, (dict, str)):
             try:
                 laminar_span_context = cls.deserialize(span_context)
                 return SpanContext(
@@ -221,6 +223,9 @@ class LaminarSpanContext(pydantic.BaseModel):
                 "trace_id": data.get("trace_id") or data.get("traceId"),
                 "span_id": data.get("span_id") or data.get("spanId"),
                 "is_remote": data.get("is_remote") or data.get("isRemote", False),
+                "span_path": data.get("span_path") or data.get("spanPath", []),
+                "span_ids_path": data.get("span_ids_path")
+                or data.get("spanIdsPath", []),
             }
             return cls.model_validate(converted_data)
         elif isinstance(data, str):
@@ -346,3 +351,16 @@ 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/version.py

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

{lmnr-0.7.2.dist-info → lmnr-0.7.4.dist-info}/METADATA

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

{lmnr-0.7.2.dist-info → lmnr-0.7.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lmnr/__init__.py,sha256=47422a1fd58f5be3e7870ccb3ed7de4f1ac520d942e0c83cbcf903b0600a08f6,1278
+lmnr/__init__.py,sha256=8be7b56ab62735fd54ca90a0642784c6153ed1d6e0f12734619ca0618dd9fbdb,1398
 lmnr/cli.py,sha256=b8780b51f37fe9e20db5495c41d3ad3837f6b48f408b09a58688d017850c0796,6047
 lmnr/opentelemetry_lib/.flake8,sha256=6c2c6e0e51b1dd8439e501ca3e21899277076a787da868d0254ba37056b79405,150
-lmnr/opentelemetry_lib/__init__.py,sha256=6962aca915d485586ed814b9e799ced898594ac2bc6d35329405705b26eab861,2160
+lmnr/opentelemetry_lib/__init__.py,sha256=1350e8d12ea2f422751ab3a80d7d32d10c27ad8e4c2989407771dc6e544d9c65,2350
 lmnr/opentelemetry_lib/decorators/__init__.py,sha256=216536fb3ac8de18e6dfe4dfb2e571074c727466f97e6dcd609339c8458a345a,11511
 lmnr/opentelemetry_lib/litellm/__init__.py,sha256=8a3679381ca5660cf53e4b7571850906c6635264129149adebda8f3f7c248f68,15127
 lmnr/opentelemetry_lib/litellm/utils.py,sha256=da8cf0553f82dc7203109f117a4c7b4185e8baf34caad12d7823875515201a27,539
@@ -28,7 +28,7 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py,sha25
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/utils.py,sha256=9dff6c2595e79edb38818668aed1220efc188d8a982594c04f4ceeb6e3ff47a6,1512
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/__init__.py,sha256=8b91dc16af927eee75b969c0980c606680b347a87f8533bc0f4a092e5ec6e5c9,2071
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/__init__.py,sha256=9d182c8cef5ee1e205dc4c2f7c8e49d8403ee9fee66072c5cfdd29a0d54f61a2,15149
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=6042b3bcf94f38c90bdebaa2c6c9ac1a4723d1801b8e7c20cf8cc3926cef83ad,38657
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py,sha256=4a1e682cd455661dde3b9442c7c16d055958e77ba5fff24c6fe08ab967c30da2,38882
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/completion_wrappers.py,sha256=3a45c07d9d0f37baf409a48e2a1b577f28041c623c41f59ada1c87b94285ae3b,9537
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/config.py,sha256=8016e4af0291a77484ce88d7d1ca06146b1229ae0e0a0f46e042faf75b456a8f,507
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/embeddings_wrappers.py,sha256=324eeeaf8dd862f49c15bb7290d414e77ad51cdf532c2cfd74358783cdf654a5,9330
@@ -45,13 +45,13 @@ lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/version.py,sha256=4f
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/opentelemetry/__init__.py,sha256=1f86cdf738e2f68586b0a4569bb1e40edddd85c529f511ef49945ddb7b61fab5,2648
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/skyvern/__init__.py,sha256=764e4fe979fb08d7821419a3cc5c3ae89a6664b626ef928259f8f175c939eaea,6334
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/threading/__init__.py,sha256=90aa8558467d7e469fe1a6c75372c113da403557715f03b522b2fab94b287c40,6320
-lmnr/opentelemetry_lib/tracing/__init__.py,sha256=a39e9a48f8a842ce7f7ec53364d793c1a303dcfd485aee7a72ade07d1b3635a2,9662
+lmnr/opentelemetry_lib/tracing/__init__.py,sha256=b96aee7590af1853fffc4c3d8ce9127a67e1ce589f695a99aabe6b37d70b0e48,10203
 lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=a15a46a0515462319195a96f7cdb695e72a1559c3212964f5883ab824031bf70,15125
-lmnr/opentelemetry_lib/tracing/attributes.py,sha256=32fa30565b977c2a92202dc2bf1ded583a81d02a6bf5ba52958f75a8be08cbbe,1497
+lmnr/opentelemetry_lib/tracing/attributes.py,sha256=88afbd1ad56bd423167f27010d86169e061ebca1f00549961da763eca51055db,1591
 lmnr/opentelemetry_lib/tracing/context.py,sha256=83f842be0fc29a96647cbf005c39ea761b0fb5913c4102f965411f47906a6135,4103
 lmnr/opentelemetry_lib/tracing/exporter.py,sha256=6af8e61fd873e8f5db315d9b9f1edbf46b860ba7e50140f0bdcc6864c6d35a03,2082
 lmnr/opentelemetry_lib/tracing/instruments.py,sha256=e3c12315bda301416d1f3bc8d354ad16d4da211e2ecfa019265f4b565307c118,5655
-lmnr/opentelemetry_lib/tracing/processor.py,sha256=fd11e4d48eb5932f47898b8f70b8b5880f7ee7e58478f1ef20caff20e1f34252,3381
+lmnr/opentelemetry_lib/tracing/processor.py,sha256=cbc70f138e70c878ef57b02a2c46ef48dd7f694a522623a82dff1623b73d1e1c,3353
 lmnr/opentelemetry_lib/tracing/tracer.py,sha256=33769a9a97385f5697eb0e0a6b1813a57ed956c7a8379d7ac2523e700e7dd528,1362
 lmnr/opentelemetry_lib/utils/__init__.py,sha256=a4d85fd06def4dde5c728734de2d4c5c36eb89c49a8aa09b8b50cb5a149e90af,604
 lmnr/opentelemetry_lib/utils/json_encoder.py,sha256=74ae9bfdac6bef42182fb56ff9bbb8c27b6f0c3bb29eda2ab0769d76a5fb3f9f,463
@@ -62,7 +62,7 @@ lmnr/sdk/browser/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b
 lmnr/sdk/browser/browser_use_otel.py,sha256=37d26de1af37f76774af176cb226e0b04988fc3bf419a2fd899ad36e79562fad,5104
 lmnr/sdk/browser/patchright_otel.py,sha256=9d22ab1f28f1eddbcfd0032a14fe306bfe00bfc7f11128cb99836c4dd15fb7c8,4800
 lmnr/sdk/browser/playwright_otel.py,sha256=50c0a5a75155a3a7ff5db84790ffb409c9cbd0351eef212d83d923893730223b,9459
-lmnr/sdk/browser/pw_utils.py,sha256=c84079f28c268c531ef86ed923028639671bb7c34a364f12f796556faa747393,20096
+lmnr/sdk/browser/pw_utils.py,sha256=e8b839d729bf4d80e07db0a8bb616b41da43219a019d2ce9596c1b6e9f848074,29061
 lmnr/sdk/browser/recorder/record.umd.min.cjs,sha256=f09c09052c2fc474efb0405e63d8d26ed2184b994513ce8aee04efdac8be155d,181235
 lmnr/sdk/browser/utils.py,sha256=4a668776d2938108d25fbcecd61c8e1710a4da3e56230d5fefca5964dd09e3c1,2371
 lmnr/sdk/client/asynchronous/async_client.py,sha256=e8feae007506cd2e4b08e72706f5f1bb4ea54492b4aa6b68ef184a129de8f466,4948
@@ -82,15 +82,15 @@ lmnr/sdk/client/synchronous/resources/evaluators.py,sha256=3cd6a17e7a9cc0441c2d2
 lmnr/sdk/client/synchronous/resources/tags.py,sha256=123deec43128662c21cb275b2df6a102372f875315b0bd36806555394c1d4b5b,2270
 lmnr/sdk/client/synchronous/sync_client.py,sha256=0bebe88e3aed689505e9ed3d32036f76df4c3496e4d659162bd41abedc026f16,5299
 lmnr/sdk/datasets.py,sha256=3fd851c5f97bf88eaa84b1451a053eaff23b4497cbb45eac2f9ea0e5f2886c00,1708
-lmnr/sdk/decorators.py,sha256=0c6b95b92ec8023f28cd15ddc47849888fa91f2534d575f626e3557f5f0a0c02,6451
+lmnr/sdk/decorators.py,sha256=2ccf9ecd9616ad1d52301febd8af630288ba63db2d36302236f606a460fc08ca,6516
 lmnr/sdk/eval_control.py,sha256=291394ac385c653ae9b5167e871bebeb4fe8fc6b7ff2ed38e636f87015dcba86,184
 lmnr/sdk/evaluations.py,sha256=b41f7737b084dc5b64b2952659b729622e0918fd492bfcddde7177d1a1c690ae,22572
-lmnr/sdk/laminar.py,sha256=c38590ec5d65d5dedad37258f13f4f88f989e9ae10cbdb30bd1acdad5443e1d6,34427
+lmnr/sdk/laminar.py,sha256=24d680407ce694f1a7ec0e9c0524eae3deb7d638ad5caff3a591ddf7963ad480,37533
 lmnr/sdk/log.py,sha256=9edfd83263f0d4845b1b2d1beeae2b4ed3f8628de941f371a893d72b79c348d4,2213
-lmnr/sdk/types.py,sha256=c4868d7d1df2fbd108fe5990900675bff2e595f6ff207afcf166ad4853f5eb0a,12670
+lmnr/sdk/types.py,sha256=49358ddd00a1f1e75ffc8cbba62aaf49f4d3031eebf52de86005715a54a846b7,13244
 lmnr/sdk/utils.py,sha256=4beb884ae6fbbc7d8cf639b036b726ea6a2a658f0a6386faf5735a13d706a2d8,5039
-lmnr/version.py,sha256=66adfc190221595f22dad751cd9efbdcff5c15c74bfe6929880661e779e139a7,1321
-lmnr-0.7.2.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-lmnr-0.7.2.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
-lmnr-0.7.2.dist-info/METADATA,sha256=dc224f7405f3038e9abb2d6dc0ffc8b06c0824e76e887b95b23f71c8636124f5,14196
-lmnr-0.7.2.dist-info/RECORD,,
+lmnr/version.py,sha256=d1c12ee42adc0a3de888632fcfe36693a8dd749bbed2ad12dd1ab2783608bcd2,1321
+lmnr-0.7.4.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+lmnr-0.7.4.dist-info/entry_points.txt,sha256=abdf3411b7dd2d7329a241f2da6669bab4e314a747a586ecdb9f888f3035003c,39
+lmnr-0.7.4.dist-info/METADATA,sha256=91677f6dc8a33790ec9e9e3bc6e1e90561d335359f3a73590c563aed8fb90163,14196
+lmnr-0.7.4.dist-info/RECORD,,