lmnr 0.4.61__tar.gz → 0.4.63b0__tar.gz

{lmnr-0.4.61 → lmnr-0.4.63b0}/PKG-INFO

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

{lmnr-0.4.61 → lmnr-0.4.63b0}/pyproject.toml

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

{lmnr-0.4.61 → lmnr-0.4.63b0}/src/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-0.4.61 → lmnr-0.4.63b0}/src/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 = {}
@@ -291,22 +293,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-0.4.63b0/src/lmnr/sdk/browser/playwright_patch.py

@@ -0,0 +1,377 @@
+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__)
+
+try:
+    from playwright.async_api import BrowserContext, Page
+    from playwright.sync_api import (
+        BrowserContext as SyncBrowserContext,
+        Page as SyncPage,
+    )
+except ImportError as e:
+    raise ImportError(
+        f"Attempted to import {__file__}, but it is designed "
+        "to patch Playwright, which is not installed. Use `pip install playwright` "
+        "to install Playwright or remove this import."
+    ) from e
+
+_original_new_page = None
+_original_new_page_async = None
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(current_dir, "rrweb", "rrweb.min.js"), "r") as f:
+    RRWEB_CONTENT = f"() => {{ {f.read()} }}"
+
+INJECT_PLACEHOLDER = """
+() => {
+    const BATCH_SIZE = 1000;  // Maximum events to store in memory
+    
+    window.lmnrRrwebEventsBatch = [];
+    
+    // Utility function to compress individual event data
+    async function compressEventData(data) {
+        const jsonString = JSON.stringify(data);
+        const blob = new Blob([jsonString], { type: 'application/json' });
+        const compressedStream = blob.stream().pipeThrough(new CompressionStream('gzip'));
+        const compressedResponse = new Response(compressedStream);
+        const compressedData = await compressedResponse.arrayBuffer();
+        return Array.from(new Uint8Array(compressedData));
+    }
+    
+    window.lmnrGetAndClearEvents = () => {
+        const events = window.lmnrRrwebEventsBatch;
+        window.lmnrRrwebEventsBatch = [];
+        return events;
+    };
+
+    // Add heartbeat events
+    setInterval(async () => {
+        const heartbeat = {
+            type: 6,
+            data: await compressEventData({ source: 'heartbeat' }),
+            timestamp: Date.now()
+        };
+        
+        window.lmnrRrwebEventsBatch.push(heartbeat);
+        
+        // Prevent memory issues by limiting batch size
+        if (window.lmnrRrwebEventsBatch.length > BATCH_SIZE) {
+            window.lmnrRrwebEventsBatch = window.lmnrRrwebEventsBatch.slice(-BATCH_SIZE);
+        }
+    }, 1000);
+
+    window.lmnrRrweb.record({
+        async emit(event) {
+            // Compress the data field
+            const compressedEvent = {
+                ...event,
+                data: await compressEventData(event.data)
+            };
+            window.lmnrRrwebEventsBatch.push(compressedEvent);
+        }
+    });
+}
+"""
+
+
+def retry_sync(func, retries=5, delay=0.5, error_message="Operation failed"):
+    """Utility function for retry logic in synchronous operations"""
+    for attempt in range(retries):
+        try:
+            result = func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        time.sleep(delay)
+    return None
+
+
+async def retry_async(func, retries=5, delay=0.5, error_message="Operation failed"):
+    """Utility function for retry logic in asynchronous operations"""
+    for attempt in range(retries):
+        try:
+            result = await func()
+            if result:  # If function returns truthy value, consider it successful
+                return result
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message} after all retries")
+                return None
+        except Exception as e:
+            if attempt == retries - 1:  # Last attempt
+                logger.error(f"{error_message}: {e}")
+                return None
+        await asyncio.sleep(delay)
+    return None
+
+
+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.lmnrGetAndClearEvents === 'function'
+        """
+        )
+        if not has_function:
+            return
+
+        events = await page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
+            return
+
+        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
+
+        events = page.evaluate("window.lmnrGetAndClearEvents()")
+        if not events or len(events) == 0:
+            return
+
+        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",
+            "Content-Encoding": "gzip",  # Add Content-Encoding header
+        }
+
+        # 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):
+
+    def inject_rrweb(page: SyncPage):
+        try:
+            page.wait_for_load_state("domcontentloaded")
+
+            # Wrap the evaluate call in a try-catch
+            try:
+                is_loaded = page.evaluate(
+                    """() => typeof window.lmnrRrweb !== 'undefined'"""
+                )
+            except Exception as e:
+                logger.debug(f"Failed to check if rrweb is loaded: {e}")
+                is_loaded = False
+
+            if not is_loaded:
+                def load_rrweb():
+                    try:
+                        page.evaluate(RRWEB_CONTENT)
+                        page.wait_for_function(
+                            """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                            timeout=5000,
+                        )
+                        return True
+                    except Exception as e:
+                        logger.debug(f"Failed to load rrweb: {e}")
+                        return False
+
+                if not retry_sync(
+                    load_rrweb, delay=1, error_message="Failed to load rrweb"
+                ):
+                    return
+
+            try:
+                page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+        except Exception as e:
+            logger.error(f"Error during rrweb injection: {e}")
+
+    async def inject_rrweb_async(page: Page):
+        try:
+            await page.wait_for_load_state("domcontentloaded")
+
+            # Wrap the evaluate call in a try-catch
+            try:
+                is_loaded = await page.evaluate(
+                    """() => typeof window.lmnrRrweb !== 'undefined'"""
+                )
+            except Exception as e:
+                logger.debug(f"Failed to check if rrweb is loaded: {e}")
+                is_loaded = False
+
+            if not is_loaded:
+                async def load_rrweb():
+                    try:
+                        await page.evaluate(RRWEB_CONTENT)
+                        await page.wait_for_function(
+                            """(() => typeof window.lmnrRrweb !== 'undefined')""",
+                            timeout=5000,
+                        )
+                        return True
+                    except Exception as e:
+                        logger.debug(f"Failed to load rrweb: {e}")
+                        return False
+
+                if not await retry_async(
+                    load_rrweb, delay=1, error_message="Failed to load rrweb"
+                ):
+                    return
+
+            try:
+                await page.evaluate(INJECT_PLACEHOLDER)
+            except Exception as e:
+                logger.debug(f"Failed to inject rrweb placeholder: {e}")
+
+        except Exception as e:
+            logger.error(f"Error during rrweb injection: {e}")
+
+    def handle_navigation(page: SyncPage, session_id: str, trace_id: str):
+        def on_load():
+            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)
+
+        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():
+            try:
+                await inject_rrweb_async(page)
+            except Exception as e:
+                logger.error(f"Error in on_load handler: {e}")
+
+        page.on("load", lambda: asyncio.create_task(on_load()))
+        await inject_rrweb_async(page)
+
+        async def collection_loop():
+            try:
+                while not page.is_closed():  # Stop when page closes
+                    await send_events_async(
+                        page, http_url, project_api_key, session_id, trace_id
+                    )
+                    await asyncio.sleep(2)
+                logger.info("Event collection stopped")
+            except Exception as e:
+                logger.error(f"Event collection stopped: {e}")
+
+        # Create and store task
+        task = asyncio.create_task(collection_loop())
+
+        # Clean up task when page closes
+        page.on("close", lambda: task.cancel())
+
+    def patched_new_page(self: SyncBrowserContext, *args, **kwargs):
+        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
+        if _original_new_page_async is None:
+            _original_new_page_async = BrowserContext.new_page
+            BrowserContext.new_page = patched_new_page_async
+
+        if _original_new_page is None:
+            _original_new_page = SyncBrowserContext.new_page
+            SyncBrowserContext.new_page = patched_new_page
+
+    patch_browser()

{lmnr-0.4.61 → lmnr-0.4.63b0}/src/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,73 @@ 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 set_session(
         cls,

{lmnr-0.4.61 → lmnr-0.4.63b0}/src/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-0.4.63b0/src/lmnr/version.py

@@ -0,0 +1,46 @@
+import sys
+import requests
+from packaging import version
+
+
+SDK_VERSION = "0.4.63b0"
+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/src/lmnr/sdk/browser/playwright_patch.py

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

lmnr-0.4.61/src/lmnr/version.py

@@ -1,5 +0,0 @@
-import sys
-
-
-SDK_VERSION = "0.4.61"
-PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"