lmnr 0.4.58__py3-none-any.whl → 0.4.60__py3-none-any.whl

lmnr/openllmetry_sdk/config/__init__.py

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

lmnr/openllmetry_sdk/decorators/base.py

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

lmnr/openllmetry_sdk/tracing/attributes.py

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

lmnr/openllmetry_sdk/tracing/tracing.py

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

lmnr/sdk/browser/playwright_patch.py

@@ -1,6 +1,11 @@
 import opentelemetry
 import uuid
 import asyncio
+import logging
+import time
+import os
+
+logger = logging.getLogger(__name__)
 
 try:
     from playwright.async_api import BrowserContext, Page
@@ -18,21 +23,25 @@ except ImportError as 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.rrwebEventsBatch = [];
+    window.lmnrRrwebEventsBatch = [];
     
-    window.sendBatch = async () => {
-        if (window.rrwebEventsBatch.length === 0) return;
+    window.lmnrSendRrwebEventsBatch = async () => {
+        if (window.lmnrRrwebEventsBatch.length === 0) return;
         
         const eventsPayload = {
-            sessionId: window.rrwebSessionId,
-            traceId: window.traceId,
-            events: window.rrwebEventsBatch
+            sessionId: window.lmnrRrwebSessionId,
+            traceId: window.lmnrTraceId,
+            events: window.lmnrRrwebEventsBatch
         };
         
         try {
@@ -53,69 +62,141 @@ INJECT_PLACEHOLDER = """
                 headers: {
                     'Content-Type': 'application/json',
                     'Content-Encoding': 'gzip',
-                    'Authorization': `Bearer ${projectApiKey}`
+                    'Authorization': `Bearer ${projectApiKey}`,
+                    'Accept': 'application/json'
                 },
                 body: blob,
-                credentials: 'omit',
                 mode: 'cors',
-                cache: 'no-cache',
+                credentials: 'omit'
             });
             
             if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
+                console.error(`HTTP error! status: ${response.status}`);
+                if (response.status === 0) {
+                    console.error('Possible CORS issue - check network tab for details');
+                }
             }
-            
-            window.rrwebEventsBatch = [];
+
+            window.lmnrRrwebEventsBatch = [];
         } catch (error) {
             console.error('Failed to send events:', error);
         }
     };
 
-    setInterval(() => window.sendBatch(), FLUSH_INTERVAL);
+    setInterval(() => window.lmnrSendRrwebEventsBatch(), FLUSH_INTERVAL);
 
     setInterval(() => {
-        window.rrwebEventsBatch.push({
+        window.lmnrRrwebEventsBatch.push({
             type: 6,
             data: { source: 'heartbeat' },
             timestamp: Date.now()
         });
     }, HEARTBEAT_INTERVAL);
 
-    window.rrweb.record({
+    window.lmnrRrweb.record({
         emit(event) {
-            window.rrwebEventsBatch.push(event);            
+            window.lmnrRrwebEventsBatch.push(event);
         }
     });
 
     window.addEventListener('beforeunload', () => {
-        window.sendBatch();
+        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()
-        current_span.set_attribute("lmnr.internal.has_browser_session", True)
+        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)
 
-        # Generate UUID session ID and set trace ID
-        page.evaluate(
-            """([traceId, sessionId]) => {
-            window.rrwebSessionId = sessionId;
-            window.traceId = traceId;
-        }""",
-            [trace_id, session_id],
-        )
+        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
+            """
+            )
 
-        # Load rrweb from CDN
-        page.add_script_tag(
-            url="https://cdn.jsdelivr.net/npm/rrweb@latest/dist/rrweb.min.js"
-        )
+        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(
@@ -124,41 +205,64 @@ def init_playwright_tracing(http_url: str, project_api_key: str):
         )
 
     async def inject_rrweb_async(page: Page):
-        try:
-            # Wait for the page to be in a ready state first
-            await page.wait_for_load_state("domcontentloaded")
+        # 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:
 
-            # Get current trace ID from active span
-            current_span = opentelemetry.trace.get_current_span()
+            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)
 
-            # Generate UUID session ID and set trace ID
+        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.rrwebSessionId = sessionId;
-                window.traceId = traceId;
+                window.lmnrRrwebSessionId = sessionId;
+                window.lmnrTraceId = traceId;
             }""",
                 [trace_id, session_id],
             )
-
-            # Load rrweb from CDN
-            await page.add_script_tag(
-                url="https://cdn.jsdelivr.net/npm/rrweb@latest/dist/rrweb.min.js"
+            return await page.evaluate(
+                """
+                () => window.lmnrRrwebSessionId && window.lmnrTraceId
+            """
             )
 
-            await page.wait_for_function(
-                """(() => window.rrweb || 'rrweb' in window)"""
-            )
+        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],
-            )
-        except Exception as e:
-            print(f"Error injecting rrweb: {e}")
+        # 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():
@@ -187,18 +291,16 @@ def init_playwright_tracing(http_url: str, project_api_key: str):
                         csp = headers[header_name]
                         parts = csp.split(";")
                         for i, part in enumerate(parts):
-                            if "script-src" in part:
-                                parts[i] = f"{part.strip()} cdn.jsdelivr.net"
-                            elif "connect-src" in part:
-                                parts[i] = f"{part.strip()} " + http_url
-                        if not any("connect-src" in part for part in parts):
-                            parts.append(" connect-src 'self' " + http_url)
+                            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:
+            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)
@@ -217,19 +319,18 @@ def init_playwright_tracing(http_url: str, project_api_key: str):
                         csp = headers[header_name]
                         parts = csp.split(";")
                         for i, part in enumerate(parts):
-                            if "script-src" in part:
-                                parts[i] = f"{part.strip()} cdn.jsdelivr.net"
-                            elif "connect-src" in part:
-                                parts[i] = f"{part.strip()} " + http_url
+                            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(" connect-src 'self' " + http_url)
+                            parts.append(f" connect-src 'self' {http_url}")
                         headers[header_name] = ";".join(parts)
 
                 route.fulfill(response=response, headers=headers)
-            except Exception:
-                # Continue with the original request without modification
+            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)