lmnr 0.4.61__py3-none-any.whl → 0.4.63__py3-none-any.whl

lmnr/__init__.py

@@ -10,6 +10,7 @@ from .sdk.types import (
     TracingLevel,
 )
 from .sdk.decorators import observe
+from .sdk.types import LaminarSpanContext
 from .openllmetry_sdk import Instruments
 from .openllmetry_sdk.tracing.attributes import Attributes
 from opentelemetry.trace import use_span

lmnr/openllmetry_sdk/__init__.py

@@ -76,3 +76,7 @@ class Traceloop:
             project_api_key=project_api_key,
             max_export_batch_size=max_export_batch_size,
         )
+
+    @staticmethod
+    def flush():
+        Traceloop.__tracer_wrapper.flush()

lmnr/openllmetry_sdk/tracing/tracing.py

@@ -38,7 +38,7 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
     BatchSpanProcessor,
 )
-from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
+from opentelemetry.sdk.trace import SpanLimits
 
 from typing import Dict, Optional, Set
 
@@ -69,6 +69,8 @@ EXCLUDED_URLS = """
     githubusercontent.com,
     openaipublic.blob.core.windows.net"""
 
+MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
+
 
 class TracerWrapper(object):
     resource_attributes: dict = {}
@@ -223,6 +225,7 @@ class TracerWrapper(object):
         cls.__span_id_lists = {}
 
     def flush(self):
+        print("Flushing spans")
         self.__spans_processor.force_flush()
 
     def get_tracer(self):
@@ -291,22 +294,21 @@ def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExpor
         )
 
 
+# TODO: check if it's safer to use the default tracer provider obtained from
+# get_tracer_provider()
 def init_tracer_provider(resource: Resource) -> TracerProvider:
-    provider: TracerProvider = None
-    default_provider: TracerProvider = get_tracer_provider()
-
-    if isinstance(default_provider, ProxyTracerProvider):
-        provider = TracerProvider(resource=resource)
-        trace.set_tracer_provider(provider)
-    elif not hasattr(default_provider, "add_span_processor"):
-        module_logger.error(
-            "Cannot add span processor to the default provider since it doesn't support it"
-        )
-        return
-    else:
-        provider = default_provider
+    tracer_provider = TracerProvider(
+        resource=resource,
+        span_limits=SpanLimits(
+            # this defaults to 128, which causes us to drop messages
+            max_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
+            max_span_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
+            max_event_attributes=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
+            max_events=MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN,
+        ),
+    )
 
-    return provider
+    return tracer_provider
 
 
 def init_instrumentations(

lmnr/sdk/browser/playwright_patch.py

@@ -1,9 +1,15 @@
-import opentelemetry
 import uuid
 import asyncio
 import logging
 import time
 import os
+import aiohttp
+import requests
+import threading
+import gzip
+import json
+from lmnr.version import SDK_VERSION, PYTHON_VERSION
+from lmnr import Laminar
 
 logger = logging.getLogger(__name__)
 
@@ -28,80 +34,53 @@ 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;
-
+() => {
+    const BATCH_SIZE = 1000;  // Maximum events to store in memory
+    
     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);
-        }
+    // Utility function to compress individual event data
+    async function compressEventData(data) {
+        const jsonString = JSON.stringify(data);
+        const blob = new Blob([jsonString], { type: 'application/json' });
+        const compressedStream = blob.stream().pipeThrough(new CompressionStream('gzip'));
+        const compressedResponse = new Response(compressedStream);
+        const compressedData = await compressedResponse.arrayBuffer();
+        return Array.from(new Uint8Array(compressedData));
+    }
+    
+    window.lmnrGetAndClearEvents = () => {
+        const events = window.lmnrRrwebEventsBatch;
+        window.lmnrRrwebEventsBatch = [];
+        return events;
     };
 
-    setInterval(() => window.lmnrSendRrwebEventsBatch(), FLUSH_INTERVAL);
-
-    setInterval(() => {
-        window.lmnrRrwebEventsBatch.push({
+    // Add heartbeat events
+    setInterval(async () => {
+        const heartbeat = {
             type: 6,
-            data: { source: 'heartbeat' },
+            data: await compressEventData({ source: 'heartbeat' }),
             timestamp: Date.now()
-        });
-    }, HEARTBEAT_INTERVAL);
+        };
+        
+        window.lmnrRrwebEventsBatch.push(heartbeat);
+        
+        // Prevent memory issues by limiting batch size
+        if (window.lmnrRrwebEventsBatch.length > BATCH_SIZE) {
+            window.lmnrRrwebEventsBatch = window.lmnrRrwebEventsBatch.slice(-BATCH_SIZE);
+        }
+    }, 1000);
 
     window.lmnrRrweb.record({
-        emit(event) {
-            window.lmnrRrwebEventsBatch.push(event);
+        async emit(event) {
+            // Compress the data field
+            const compressedEvent = {
+                ...event,
+                data: await compressEventData(event.data)
+            };
+            window.lmnrRrwebEventsBatch.push(compressedEvent);
         }
     });
-
-    window.addEventListener('beforeunload', () => {
-        window.lmnrSendRrwebEventsBatch();
-    });
 }
 """
 
@@ -142,199 +121,248 @@ async def retry_async(func, retries=5, delay=0.5, error_message="Operation faile
     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(
+async def send_events_async(
+    page: Page, http_url: str, project_api_key: str, session_id: str, trace_id: str
+):
+    """Fetch events from the page and send them to the server"""
+    try:
+        # Check if function exists first
+        has_function = await page.evaluate(
             """
-            () => typeof window.lmnrRrweb !== 'undefined'
+            () => typeof window.lmnrGetAndClearEvents === 'function'
         """
         )
+        if not has_function:
+            return
 
-        if not is_loaded:
+        events = await page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
+            return
 
-            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
+        payload = {
+            "sessionId": session_id,
+            "traceId": trace_id,
+            "events": events,
+            "source": f"python@{PYTHON_VERSION}",
+            "sdkVersion": SDK_VERSION,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {project_api_key}",
+            "Accept": "application/json",
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{http_url}/v1/browser-sessions/events",
+                json=payload,
+                headers=headers,
+            ) as response:
+                if not response.ok:
+                    logger.error(f"Failed to send events: {response.status}")
+
+    except Exception as e:
+        logger.error(f"Error sending events: {e}")
+
+
+def send_events_sync(
+    page: SyncPage, http_url: str, project_api_key: str, session_id: str, trace_id: str
+):
+    """Synchronous version of send_events"""
+    try:
+        # Check if function exists first
+        has_function = page.evaluate(
             """
-            )
+            () => typeof window.lmnrGetAndClearEvents === 'function'
+        """
+        )
+        if not has_function:
+            return
 
-        if not retry_sync(
-            set_window_vars, error_message="Failed to set window variables"
-        ):
+        events = page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
             return
 
-        # Update the recording setup to include trace ID
-        page.evaluate(
-            INJECT_PLACEHOLDER,
-            [http_url, project_api_key],
-        )
+        payload = {
+            "sessionId": session_id,
+            "traceId": trace_id,
+            "events": events,
+            "source": f"python@{PYTHON_VERSION}",
+            "sdkVersion": SDK_VERSION,
+        }
 
-    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")
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {project_api_key}",
+            "Accept": "application/json",
+            "Content-Encoding": "gzip",  # Add Content-Encoding header
+        }
 
-        # First check if rrweb is already loaded
-        is_loaded = await page.evaluate(
-            """
-            () => typeof window.lmnrRrweb !== 'undefined'
-        """
+        # Compress the payload
+        compressed_payload = gzip.compress(json.dumps(payload).encode("utf-8"))
+
+        response = requests.post(
+            f"{http_url}/v1/browser-sessions/events",
+            data=compressed_payload,  # Use data instead of json for raw bytes
+            headers=headers,
         )
+        if not response.ok:
+            logger.error(f"Failed to send events: {response.status_code}")
+
+    except Exception as e:
+        logger.error(f"Error sending events: {e}")
+
+
+def init_playwright_tracing(http_url: str, project_api_key: str):
 
-        if not is_loaded:
+    def inject_rrweb(page: SyncPage):
+        try:
+            page.wait_for_load_state("domcontentloaded")
 
-            async def load_rrweb():
-                await page.evaluate(RRWEB_CONTENT)
-                # Verify script loaded successfully
-                await page.wait_for_function(
-                    """(() => typeof window.lmnrRrweb !== 'undefined')""",
-                    timeout=5000,
+            # Wrap the evaluate call in a try-catch
+            try:
+                is_loaded = page.evaluate(
+                    """() => typeof window.lmnrRrweb !== 'undefined'"""
                 )
-                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
-            """
-            )
+            except Exception as e:
+                logger.debug(f"Failed to check if rrweb is loaded: {e}")
+                is_loaded = False
+
+            if not is_loaded:
+                def load_rrweb():
+                    try:
+                        page.evaluate(RRWEB_CONTENT)
+                        page.wait_for_function(
+                            """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                            timeout=5000,
+                        )
+                        return True
+                    except Exception as e:
+                        logger.debug(f"Failed to load rrweb: {e}")
+                        return False
+
+                if not retry_sync(
+                    load_rrweb, delay=1, error_message="Failed to load rrweb"
+                ):
+                    return
 
-        if not await retry_async(
-            set_window_vars, error_message="Failed to set window variables"
-        ):
-            return
+            try:
+                page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject rrweb placeholder: {e}")
 
-        # Update the recording setup to include trace ID
-        await page.evaluate(
-            INJECT_PLACEHOLDER,
-            [http_url, project_api_key],
-        )
+        except Exception as e:
+            logger.error(f"Error during rrweb injection: {e}")
+
+    async def inject_rrweb_async(page: Page):
+        try:
+            await page.wait_for_load_state("domcontentloaded")
+
+            # Wrap the evaluate call in a try-catch
+            try:
+                is_loaded = await page.evaluate(
+                    """() => typeof window.lmnrRrweb !== 'undefined'"""
+                )
+            except Exception as e:
+                logger.debug(f"Failed to check if rrweb is loaded: {e}")
+                is_loaded = False
+
+            if not is_loaded:
+                async def load_rrweb():
+                    try:
+                        await page.evaluate(RRWEB_CONTENT)
+                        await page.wait_for_function(
+                            """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                            timeout=5000,
+                        )
+                        return True
+                    except Exception as e:
+                        logger.debug(f"Failed to load rrweb: {e}")
+                        return False
+
+                if not await retry_async(
+                    load_rrweb, delay=1, error_message="Failed to load rrweb"
+                ):
+                    return
+
+            try:
+                await page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject rrweb placeholder: {e}")
 
-    def handle_navigation(page: SyncPage):
+        except Exception as e:
+            logger.error(f"Error during rrweb injection: {e}")
+
+    def handle_navigation(page: SyncPage, session_id: str, trace_id: str):
         def on_load():
-            inject_rrweb(page)
+            try:
+                inject_rrweb(page)
+            except Exception as e:
+                logger.error(f"Error in on_load handler: {e}")
 
         page.on("load", on_load)
         inject_rrweb(page)
 
-    async def handle_navigation_async(page: Page):
+        def collection_loop():
+            while not page.is_closed():  # Stop when page closes
+                send_events_sync(page, http_url, project_api_key, session_id, trace_id)
+                time.sleep(2)
+
+        thread = threading.Thread(target=collection_loop, daemon=True)
+        thread.start()
+
+    async def handle_navigation_async(page: Page, session_id: str, trace_id: str):
         async def on_load():
-            await inject_rrweb_async(page)
+            try:
+                await inject_rrweb_async(page)
+            except Exception as e:
+                logger.error(f"Error in on_load handler: {e}")
 
         page.on("load", lambda: asyncio.create_task(on_load()))
         await inject_rrweb_async(page)
 
-    async def patched_new_page_async(self: BrowserContext, *args, **kwargs):
-        # Modify CSP to allow required domains
-        async def handle_route(route):
+        async def collection_loop():
             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)
+                while not page.is_closed():  # Stop when page closes
+                    await send_events_async(
+                        page, http_url, project_api_key, session_id, trace_id
+                    )
+                    await asyncio.sleep(2)
+                logger.info("Event collection stopped")
             except Exception as e:
-                logger.debug(f"Error handling route: {e}")
-                await route.continue_()
+                logger.error(f"Event collection stopped: {e}")
+
+        # Create and store task
+        task = asyncio.create_task(collection_loop())
 
-        # 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
+        # Clean up task when page closes
+        page.on("close", lambda: task.cancel())
 
     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
+        with Laminar.start_as_current_span(name="browser_context.new_page") as span:
+            page = _original_new_page(self, *args, **kwargs)
+
+            session_id = str(uuid.uuid4().hex)
+            span.set_attribute("lmnr.internal.has_browser_session", True)
+
+            trace_id = format(span.get_span_context().trace_id, "032x")
+            session_id = str(uuid.uuid4().hex)
+
+            handle_navigation(page, session_id, trace_id)
+            return page
+
+    async def patched_new_page_async(self: BrowserContext, *args, **kwargs):
+        with Laminar.start_as_current_span(name="browser_context.new_page") as span:
+            page = await _original_new_page_async(self, *args, **kwargs)
+
+            session_id = str(uuid.uuid4().hex)
+
+            span.set_attribute("lmnr.internal.has_browser_session", True)
+            trace_id = format(span.get_span_context().trace_id, "032x")
+            session_id = str(uuid.uuid4().hex)
+            await handle_navigation_async(page, session_id, trace_id)
+            return page
 
     def patch_browser():
         global _original_new_page, _original_new_page_async

lmnr/sdk/laminar.py

@@ -35,6 +35,7 @@ import requests
 import re
 import urllib.parse
 import uuid
+import warnings
 
 from lmnr.openllmetry_sdk.tracing.attributes import (
     SESSION_ID,
@@ -54,6 +55,7 @@ from .types import (
     InitEvaluationResponse,
     EvaluationResultDatapoint,
     GetDatapointsResponse,
+    LaminarSpanContext,
     PipelineRunError,
     PipelineRunResponse,
     NodeInput,
@@ -151,6 +153,14 @@ class Laminar:
         cls.__initialized = True
         cls._initialize_logger()
 
+        # if not is_latest_version():
+        #     cls.__logger.warning(
+        #         "You are using an older version of the Laminar SDK. "
+        #         f"Latest version: {get_latest_pypi_version()}, current version: {SDK_VERSION}.\n"
+        #         "Please update to the latest version by running "
+        #         "`pip install --upgrade lmnr`."
+        #     )
+
         Traceloop.init(
             base_http_url=cls.__base_http_url,
             project_api_key=cls.__project_api_key,
@@ -338,8 +348,10 @@ class Laminar:
             Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]
         ] = "DEFAULT",
         context: Optional[Context] = None,
-        trace_id: Optional[uuid.UUID] = None,
         labels: Optional[dict[str, str]] = None,
+        parent_span_context: Optional[LaminarSpanContext] = None,
+        # deprecated, use parent_span_context instead
+        trace_id: Optional[uuid.UUID] = None,
     ):
         """Start a new span as the current span. Useful for manual
         instrumentation. If `span_type` is set to `"LLM"`, you should report
@@ -362,11 +374,21 @@ class Laminar:
                 and response attributes manually. Defaults to "DEFAULT".
             context (Optional[Context], optional): raw OpenTelemetry context\
                 to attach the span to. Defaults to None.
-            trace_id (Optional[uuid.UUID], optional): [EXPERIMENTAL] override\
-                the trace id for the span. If not provided, use the current\
-                trace id. Defaults to None.
+            parent_span_context (Optional[LaminarSpanContext], optional): parent\
+                span context to use for the span. Useful for continuing traces\
+                across services. If parent_span_context is a\
+                raw OpenTelemetry span context, or if it is a dictionary or string\
+                obtained from `Laminar.get_laminar_span_context_dict()` or\
+                `Laminar.get_laminar_span_context_str()` respectively, it will be\
+                converted to a `LaminarSpanContext` if possible. See also\
+                `Laminar.get_span_context`, `Laminar.get_span_context_dict` and\
+                `Laminar.get_span_context_str` for more information.
+                Defaults to None.
             labels (Optional[dict[str, str]], optional): labels to set for the\
                 span. Defaults to None.
+            trace_id (Optional[uuid.UUID], optional): [Deprecated] override\
+                the trace id for the span. If not provided, use the current\
+                trace id. Defaults to None.
         """
 
         if not cls.is_initialized():
@@ -376,21 +398,29 @@ class Laminar:
         with get_tracer() as tracer:
             ctx = context or context_api.get_current()
             if trace_id is not None:
-                if isinstance(trace_id, uuid.UUID):
-                    span_context = trace.SpanContext(
-                        trace_id=int(trace_id),
-                        span_id=random.getrandbits(64),
-                        is_remote=False,
-                        trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
-                    )
-                    ctx = trace.set_span_in_context(
-                        trace.NonRecordingSpan(span_context), ctx
-                    )
-                else:
-                    cls.__logger.warning(
-                        "trace_id provided to `Laminar.start_as_current_span`"
-                        " is not a valid UUID"
-                    )
+                warnings.warn(
+                    "trace_id provided to `Laminar.start_as_current_span`"
+                    " is deprecated, use parent_span_context instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+            if parent_span_context is not None:
+                span_context = LaminarSpanContext.try_to_otel_span_context(
+                    parent_span_context, cls.__logger
+                )
+                ctx = trace.set_span_in_context(
+                    trace.NonRecordingSpan(span_context), ctx
+                )
+            elif trace_id is not None and isinstance(trace_id, uuid.UUID):
+                span_context = trace.SpanContext(
+                    trace_id=int(trace_id),
+                    span_id=random.getrandbits(64),
+                    is_remote=False,
+                    trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
+                )
+                ctx = trace.set_span_in_context(
+                    trace.NonRecordingSpan(span_context), ctx
+                )
             ctx_token = attach(ctx)
             label_props = {}
             try:
@@ -478,8 +508,10 @@ class Laminar:
             Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]
         ] = "DEFAULT",
         context: Optional[Context] = None,
-        trace_id: Optional[uuid.UUID] = None,
+        parent_span_context: Optional[LaminarSpanContext] = None,
         labels: Optional[dict[str, str]] = None,
+        # deprecated, use parent_span_context instead
+        trace_id: Optional[uuid.UUID] = None,
     ):
         """Start a new span. Useful for manual instrumentation.
         If `span_type` is set to `"LLM"`, you should report usage and response
@@ -521,30 +553,48 @@ class Laminar:
                 and response attributes manually. Defaults to "DEFAULT".
             context (Optional[Context], optional): raw OpenTelemetry context\
                 to attach the span to. Defaults to None.
-            trace_id (Optional[uuid.UUID], optional): [EXPERIMENTAL] override\
-                the trace id for the span. If not provided, use the current\
-                trace id. Defaults to None.
+            parent_span_context (Optional[LaminarSpanContext], optional): parent\
+                span context to use for the span. Useful for continuing traces\
+                across services. If parent_span_context is a\
+                raw OpenTelemetry span context, or if it is a dictionary or string\
+                obtained from `Laminar.get_laminar_span_context_dict()` or\
+                `Laminar.get_laminar_span_context_str()` respectively, it will be\
+                converted to a `LaminarSpanContext` if possible. See also\
+                `Laminar.get_span_context`, `Laminar.get_span_context_dict` and\
+                `Laminar.get_span_context_str` for more information.
+                Defaults to None.
             labels (Optional[dict[str, str]], optional): labels to set for the\
                 span. Defaults to None.
+            trace_id (Optional[uuid.UUID], optional): Deprecated, use\
+                `parent_span_context` instead. If provided, it will be used to\
+                set the trace id for the span.
         """
         with get_tracer() as tracer:
             ctx = context or context_api.get_current()
             if trace_id is not None:
-                if isinstance(trace_id, uuid.UUID):
-                    span_context = trace.SpanContext(
-                        trace_id=int(trace_id),
-                        span_id=random.getrandbits(64),
-                        is_remote=False,
-                        trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
-                    )
-                    ctx = trace.set_span_in_context(
-                        trace.NonRecordingSpan(span_context), ctx
-                    )
-                else:
-                    cls.__logger.warning(
-                        "trace_id provided to `Laminar.start_span`"
-                        " is not a valid UUID"
-                    )
+                warnings.warn(
+                    "trace_id provided to `Laminar.start_span`"
+                    " is deprecated, use parent_span_context instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+            if parent_span_context is not None:
+                span_context = LaminarSpanContext.try_to_otel_span_context(
+                    parent_span_context, cls.__logger
+                )
+                ctx = trace.set_span_in_context(
+                    trace.NonRecordingSpan(span_context), ctx
+                )
+            elif trace_id is not None and isinstance(trace_id, uuid.UUID):
+                span_context = trace.SpanContext(
+                    trace_id=int(trace_id),
+                    span_id=random.getrandbits(64),
+                    is_remote=False,
+                    trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
+                )
+                ctx = trace.set_span_in_context(
+                    trace.NonRecordingSpan(span_context), ctx
+                )
             label_props = {}
             try:
                 if labels:
@@ -679,6 +729,77 @@ class Laminar:
             else:
                 span.set_attribute(key.value, value)
 
+    @classmethod
+    def get_laminar_span_context(
+        cls, span: Optional[trace.Span] = None
+    ) -> Optional[LaminarSpanContext]:
+        """Get the laminar span context for a given span.
+        If no span is provided, the current active span will be used.
+        """
+        span = span or trace.get_current_span()
+        if span == trace.INVALID_SPAN:
+            return None
+        return LaminarSpanContext(
+            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,
+        )
+
+    @classmethod
+    def get_laminar_span_context_dict(
+        cls, span: Optional[trace.Span] = None
+    ) -> Optional[dict]:
+        """Get the laminar span context for a given span as a dictionary.
+        If no span is provided, the current active span will be used.
+
+        This is useful for continuing a trace across services.
+
+        Example:
+        ```python
+        # service A:
+        with Laminar.start_as_current_span("service_a"):
+            span_context = Laminar.get_laminar_span_context_dict()
+            # send span_context to service B
+            call_service_b(request, headers={"laminar-span-context": span_context})
+
+        # service B:
+        def call_service_b(request, headers):
+            span_context = LaminarSpanContext.from_dict(headers["laminar-span-context"])
+            with Laminar.start_as_current_span("service_b", parent_span_context=span_context):
+                # rest of the function
+                pass
+        ```
+
+        This will result in a trace like:
+        ```
+        service_a
+          service_b
+        ```
+        """
+        span_context = cls.get_laminar_span_context(span)
+        if span_context is None:
+            return None
+        return span_context.to_dict()
+
+    @classmethod
+    def get_laminar_span_context_str(
+        cls, span: Optional[trace.Span] = None
+    ) -> Optional[str]:
+        span_context = cls.get_laminar_span_context(span)
+        if span_context is None:
+            return None
+        return json.dumps(span_context.to_dict())
+
+    @classmethod
+    def deserialize_laminar_span_context(
+        cls, span_context: Union[dict, str]
+    ) -> LaminarSpanContext:
+        return LaminarSpanContext.deserialize(span_context)
+
+    @classmethod
+    def shutdown(cls):
+        Traceloop.flush()
+
     @classmethod
     def set_session(
         cls,

lmnr/sdk/types.py

@@ -1,6 +1,9 @@
+import logging
 import aiohttp
 import datetime
 from enum import Enum
+import json
+from opentelemetry.trace import SpanContext, TraceFlags
 import pydantic
 from typing import Any, Awaitable, Callable, Optional, Union
 import uuid
@@ -210,3 +213,86 @@ class TracingLevel(Enum):
     OFF = 0
     META_ONLY = 1
     ALL = 2
+
+
+class LaminarSpanContext(pydantic.BaseModel):
+    """
+    A span context that can be used to continue a trace across services. This
+    is a slightly modified version of the OpenTelemetry span context. For
+    usage examples, see `Laminar.get_laminar_span_context_dict`,
+    `Laminar.get_laminar_span_context_str`, `Laminar.get_span_context`, and
+    `Laminar.deserialize_laminar_span_context`.
+
+    The difference between this and the OpenTelemetry span context is that
+    the `trace_id` and `span_id` are stored as UUIDs instead of integers for
+    easier debugging, and the separate trace flags are not currently stored.
+    """
+
+    trace_id: uuid.UUID
+    span_id: uuid.UUID
+    is_remote: bool = pydantic.Field(default=False)
+
+    # uuid is not serializable by default, so we need to convert it to a string
+    def to_dict(self):
+        return {
+            "traceId": str(self.trace_id),
+            "spanId": str(self.span_id),
+            "isRemote": self.is_remote,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "LaminarSpanContext":
+        return cls(
+            trace_id=uuid.UUID(data["traceId"]),
+            span_id=uuid.UUID(data["spanId"]),
+            is_remote=data["isRemote"],
+        )
+
+    @classmethod
+    def try_to_otel_span_context(
+        cls,
+        span_context: Union["LaminarSpanContext", dict[str, Any], str, SpanContext],
+        logger: Optional[logging.Logger] = None,
+    ) -> SpanContext:
+        if logger is None:
+            logger = logging.getLogger(__name__)
+
+        if isinstance(span_context, LaminarSpanContext):
+            return SpanContext(
+                trace_id=span_context.trace_id.int,
+                span_id=span_context.span_id.int,
+                is_remote=span_context.is_remote,
+                trace_flags=TraceFlags(TraceFlags.SAMPLED),
+            )
+        elif isinstance(span_context, SpanContext) or (
+            isinstance(getattr(span_context, "trace_id", None), int)
+            and isinstance(getattr(span_context, "span_id", None), int)
+        ):
+            logger.warning(
+                "span_context provided"
+                " is likely a raw OpenTelemetry span context. Will try to use it. "
+                "Please use `LaminarSpanContext` instead."
+            )
+            return span_context
+        elif isinstance(span_context, dict) or isinstance(span_context, str):
+            try:
+                laminar_span_context = cls.deserialize(span_context)
+                return SpanContext(
+                    trace_id=laminar_span_context.trace_id.int,
+                    span_id=laminar_span_context.span_id.int,
+                    is_remote=laminar_span_context.is_remote,
+                    trace_flags=TraceFlags(TraceFlags.SAMPLED),
+                )
+            except Exception:
+                raise ValueError("Invalid span_context provided")
+        else:
+            raise ValueError("Invalid span_context provided")
+
+    @classmethod
+    def deserialize(cls, data: Union[dict[str, Any], str]) -> "LaminarSpanContext":
+        if isinstance(data, dict):
+            return cls.from_dict(data)
+        elif isinstance(data, str):
+            return cls.from_dict(json.loads(data))
+        else:
+            raise ValueError("Invalid span_context provided")

lmnr/version.py

@@ -1,5 +1,46 @@
 import sys
+import requests
+from packaging import version
 
 
-SDK_VERSION = "0.4.61"
+SDK_VERSION = "0.4.63"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+
+def is_latest_version() -> bool:
+    try:
+        return version.parse(SDK_VERSION) >= version.parse(get_latest_pypi_version())
+    except Exception:
+        return True
+
+
+def get_latest_pypi_version() -> str:
+    """
+    Get the latest stable version of lmnr package from PyPI.
+    Returns the version string or raises an exception if unable to fetch.
+    """
+    try:
+        response = requests.get("https://pypi.org/pypi/lmnr/json")
+        response.raise_for_status()
+
+        releases = response.json()["releases"]
+        stable_versions = [
+            ver
+            for ver in releases.keys()
+            if not version.parse(ver).is_prerelease
+            and not version.parse(ver).is_devrelease
+            and not any(release.get("yanked", False) for release in releases[ver])
+        ]
+
+        if not stable_versions:
+            # do not scare the user, assume they are on
+            # latest version
+            return SDK_VERSION
+
+        latest_version = max(stable_versions, key=version.parse)
+        return latest_version
+
+    except Exception:
+        # do not scare the user, assume they are on
+        # latest version
+        return SDK_VERSION

{lmnr-0.4.61.dist-info → lmnr-0.4.63.dist-info}/METADATA

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

{lmnr-0.4.61.dist-info → lmnr-0.4.63.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lmnr/__init__.py,sha256=Bqxs-8Mh4h69pOHURgBCgo9EW1GwChebxP6wUX2-bsU,452
+lmnr/__init__.py,sha256=UiFNMZL5IqflaxgAv5FXcbvFmw4xCQbF6RwXlNYmAAU,494
 lmnr/cli.py,sha256=4J2RZQhHM3jJcjFvBC4PChQTS-ukxykVvI0X6lTkK-o,2918
 lmnr/openllmetry_sdk/.flake8,sha256=bCxuDlGx3YQ55QHKPiGJkncHanh9qGjQJUujcFa3lAU,150
-lmnr/openllmetry_sdk/__init__.py,sha256=TpFNPrRosz-BUpWdfT9ROiZPTGA_JshNwqOfiXlR0MU,2643
+lmnr/openllmetry_sdk/__init__.py,sha256=Nz20nI8tzeJcoLavPeemqHdHFUQ9-VoB9MBF9m_qoZs,2722
 lmnr/openllmetry_sdk/config/__init__.py,sha256=5aGdIdo1LffBkNwIBUbqzN6OUCMCrURU4b0rf5LBSI0,300
 lmnr/openllmetry_sdk/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/openllmetry_sdk/decorators/base.py,sha256=RNyvSreGBwwh8EWaa3O9samrnmKoZHK7eBzGOPT3lHc,7132
@@ -10,7 +10,7 @@ lmnr/openllmetry_sdk/tracing/__init__.py,sha256=xT73L1t2si2CM6QmMiTZ7zn-dKKYBLNr
 lmnr/openllmetry_sdk/tracing/attributes.py,sha256=cLBmSp4AMv9E91Ck3yD5Z1Qx1L5ZRV-80VJxFA-sO0Q,1426
 lmnr/openllmetry_sdk/tracing/content_allow_list.py,sha256=3feztm6PBWNelc8pAZUcQyEGyeSpNiVKjOaDk65l2ps,846
 lmnr/openllmetry_sdk/tracing/context_manager.py,sha256=rdSus-p-TaevQ8hIAhfbnZr5dTqRvACDkzXGDpflncY,306
-lmnr/openllmetry_sdk/tracing/tracing.py,sha256=aQsQRI4NKl3K3e0W7TZvbNqtdiWngbmj7lnY9VOak1I,34026
+lmnr/openllmetry_sdk/tracing/tracing.py,sha256=TaVNtw3kQNP-5QxKVXOw2wbSe21G8e8-nAbajXxFXPI,34113
 lmnr/openllmetry_sdk/utils/__init__.py,sha256=pNhf0G3vTd5ccoc03i1MXDbricSaiqCbi1DLWhSekK8,604
 lmnr/openllmetry_sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 lmnr/openllmetry_sdk/utils/json_encoder.py,sha256=dK6b_axr70IYL7Vv-bu4wntvDDuyntoqsHaddqX7P58,463
@@ -18,19 +18,19 @@ lmnr/openllmetry_sdk/utils/package_check.py,sha256=_-Fu9Zbp9tOyy27_-Rul7tDc8JaXY
 lmnr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/sdk/browser/__init__.py,sha256=NSP5sB-dm-f0FP70_GMvVrNFwc5rHf7SW0_Oisyo3cE,343
-lmnr/sdk/browser/playwright_patch.py,sha256=URg6zOlidIXHnkVu4OpMc8-kvm51j8rb5BNUtuNxDXM,12091
+lmnr/sdk/browser/playwright_patch.py,sha256=wfbkFXYMl6VmsxzLfaArmuCKtASnd3hUtlL7Shj6lss,13071
 lmnr/sdk/browser/rrweb/rrweb.min.js,sha256=X5pgaoX1j_OjKTqGQgKB-83xUSuydNLQa-Kkh1AAZYM,140485
 lmnr/sdk/datasets.py,sha256=hJcQcwTJbtA4COoVG3god4xll9TBSDMfvrhKmMfanjg,1567
 lmnr/sdk/decorators.py,sha256=g0VBqUEMCPRbgjgGHauVuKK1wHEd9rkiGzlYUYrcml4,2336
 lmnr/sdk/eval_control.py,sha256=G6Fg3Xx_KWv72iBaWlNMdyRTF2bZFQnwJ68sJNSpIcY,177
 lmnr/sdk/evaluations.py,sha256=WmPAgQVm2C83xsG-qMdPrMuvCMFMoVdO37LqZtLc8xw,18702
-lmnr/sdk/laminar.py,sha256=LzhIiBgtOi3GHrG5laR64q4r1mHZBcugyz_xhYbFn5U,33448
+lmnr/sdk/laminar.py,sha256=1KkEq8DDogobtrFwgTOo71hDptX1oMMkDcYn973S-eU,38717
 lmnr/sdk/log.py,sha256=nt_YMmPw1IRbGy0b7q4rTtP4Yo3pQfNxqJPXK3nDSNQ,2213
-lmnr/sdk/types.py,sha256=Y4msdSM_IvQ5LOfV2jvk4R0-6skW5Ilml466a6swul4,6506
+lmnr/sdk/types.py,sha256=NUVAIZAjjyWB6Ze7naa3Vx9g14Em6OtIXsSNSCJWISE,9892
 lmnr/sdk/utils.py,sha256=sD1YEqhdPaHweY2VGmjMF9MC-X7Ikdc49E01D-HF77E,3377
-lmnr/version.py,sha256=uQK5Bt__rGV1lmIQ4s11hI7eSOu7SczAWFNzRe-9DUU,106
-lmnr-0.4.61.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.4.61.dist-info/METADATA,sha256=Nvo3FOzpnISMf8jYxsJI-ULPWCuhOMTWcwVb-FZXx-A,13827
-lmnr-0.4.61.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-lmnr-0.4.61.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
-lmnr-0.4.61.dist-info/RECORD,,
+lmnr/version.py,sha256=p-p1byXt34iI6GQ66e7VKFuYQ2oQw2NJDAhhok0qD4M,1328
+lmnr-0.4.63.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.4.63.dist-info/METADATA,sha256=4W-ucM1arTuxaQnThJempZ0ByTlp2gUkIR7pgaYHYGo,13827
+lmnr-0.4.63.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+lmnr-0.4.63.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
+lmnr-0.4.63.dist-info/RECORD,,