lmnr 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

lmnr/opentelemetry_lib/tracing/processor.py

@@ -0,0 +1,96 @@
+import uuid
+
+from typing import Optional, Union
+from opentelemetry.sdk.trace.export import (
+    SpanProcessor,
+    SpanExporter,
+    BatchSpanProcessor,
+    SimpleSpanProcessor,
+)
+from opentelemetry.trace import Span
+from opentelemetry.context import Context, get_value, get_current, set_value
+
+from lmnr.opentelemetry_lib.tracing.attributes import (
+    SPAN_IDS_PATH,
+    SPAN_INSTRUMENTATION_SOURCE,
+    SPAN_LANGUAGE_VERSION,
+    SPAN_PATH,
+    SPAN_SDK_VERSION,
+)
+from lmnr.opentelemetry_lib.tracing.exporter import LaminarSpanExporter
+from lmnr.opentelemetry_lib.tracing.context_properties import (
+    _set_association_properties_attributes,
+)
+from lmnr.version import PYTHON_VERSION, __version__
+
+
+class LaminarSpanProcessor(SpanProcessor):
+    instance: Union[BatchSpanProcessor, SimpleSpanProcessor]
+    __span_id_to_path: dict[int, list[str]] = {}
+    __span_id_lists: dict[int, list[str]] = {}
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        port: Optional[int] = None,
+        api_key: Optional[str] = None,
+        timeout_seconds: int = 30,
+        force_http: bool = False,
+        max_export_batch_size: int = 512,
+        disable_batch: bool = False,
+        exporter: Optional[SpanExporter] = None,
+    ):
+        self.exporter = exporter or LaminarSpanExporter(
+            base_url=base_url,
+            port=port,
+            api_key=api_key,
+            timeout_seconds=timeout_seconds,
+            force_http=force_http,
+        )
+        self.instance = (
+            SimpleSpanProcessor(self.exporter)
+            if disable_batch
+            else BatchSpanProcessor(
+                self.exporter, max_export_batch_size=max_export_batch_size
+            )
+        )
+
+    def on_start(self, span: Span, parent_context: Optional[Context] = None):
+        span_path_in_context = get_value("span_path", parent_context or get_current())
+        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, __version__)
+        span.set_attribute(SPAN_LANGUAGE_VERSION, f"python@{PYTHON_VERSION}")
+
+        association_properties = get_value("association_properties")
+        if association_properties is not None:
+            _set_association_properties_attributes(span, association_properties)
+        self.instance.on_start(span, parent_context)
+
+    def on_end(self, span: Span):
+        self.instance.on_end(span)
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return self.instance.force_flush(timeout_millis)
+
+    def shutdown(self):
+        self.instance.shutdown()
+
+    def clear(self):
+        self.__span_id_to_path = {}
+        self.__span_id_lists = {}

lmnr/opentelemetry_lib/tracing/{context_manager.py → tracer.py}

@@ -1,6 +1,11 @@
 from contextlib import contextmanager
 
-from lmnr.opentelemetry_lib.tracing.tracing import TracerWrapper
+from opentelemetry import trace
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
+
+
+def get_laminar_tracer_provider() -> trace.TracerProvider:
+    return TracerWrapper.instance.__tracer_provider or trace.get_tracer_provider()
 
 
 @contextmanager

lmnr/opentelemetry_lib/utils/package_check.py

@@ -1,6 +1,8 @@
 from importlib.metadata import distributions
 
-installed_packages = {dist.metadata.get("Name", "").lower() for dist in distributions()}
+installed_packages = {
+    (dist.name or dist.metadata.get("Name", "")).lower() for dist in distributions()
+}
 
 
 def is_package_installed(package_name: str) -> bool:

lmnr/sdk/browser/browser_use_otel.py

@@ -1,4 +1,4 @@
-from lmnr.opentelemetry_lib.decorators.base import json_dumps
+from lmnr.opentelemetry_lib.decorators import json_dumps
 from lmnr.sdk.browser.utils import with_tracer_wrapper
 from lmnr.sdk.utils import get_input_from_func_args
 from lmnr.version import __version__

lmnr/sdk/browser/playwright_otel.py

@@ -1,6 +1,7 @@
 import logging
 import uuid
 
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 from lmnr.sdk.browser.pw_utils import handle_navigation_async, handle_navigation_sync
 from lmnr.sdk.browser.utils import with_tracer_and_client_wrapper
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
@@ -22,17 +23,31 @@ from typing import Collection
 from wrapt import wrap_function_wrapper
 
 try:
-    from playwright.async_api import Browser, BrowserContext, Page
-    from playwright.sync_api import (
-        Browser as SyncBrowser,
-        BrowserContext as SyncBrowserContext,
-        Page as SyncPage,
-    )
+    if is_package_installed("playwright"):
+        from playwright.async_api import Browser, BrowserContext, Page
+        from playwright.sync_api import (
+            Browser as SyncBrowser,
+            BrowserContext as SyncBrowserContext,
+            Page as SyncPage,
+        )
+    elif is_package_installed("patchright"):
+        from patchright.async_api import Browser, BrowserContext, Page
+        from patchright.sync_api import (
+            Browser as SyncBrowser,
+            BrowserContext as SyncBrowserContext,
+            Page as SyncPage,
+        )
+    else:
+        raise ImportError(
+            "Attempted to import lmnr.sdk.browser.playwright_otel, but neither "
+            "playwright nor patchright is installed. Use `pip install playwright` "
+            "or `pip install patchright` to install one of the supported browsers."
+        )
 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."
+        "or `pip install patchright` to install Playwright or remove this import."
     ) from e
 
 # all available versions at https://pypi.org/project/playwright/#history

lmnr/sdk/browser/pw_utils.py

@@ -6,19 +6,31 @@ import threading
 
 from opentelemetry import trace
 
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 from lmnr.sdk.decorators import observe
 from lmnr.sdk.browser.utils import retry_sync, retry_async
 from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 
+
 try:
-    from playwright.async_api import Page
-    from playwright.sync_api import Page as SyncPage
+    if is_package_installed("playwright"):
+        from playwright.async_api import Page
+        from playwright.sync_api import Page as SyncPage
+    elif is_package_installed("patchright"):
+        from patchright.async_api import Page
+        from patchright.sync_api import Page as SyncPage
+    else:
+        raise ImportError(
+            "Attempted to import lmnr.sdk.browser.pw_utils, but neither "
+            "playwright nor patchright is installed. Use `pip install playwright` "
+            "or `pip install patchright` to install one of the supported browsers."
+        )
 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."
+        "Attempted to import lmnr.sdk.browser.pw_utils, but neither "
+        "playwright nor patchright is installed. Use `pip install playwright` "
+        "or `pip install patchright` to install one of the supported browsers."
     ) from e
 
 logger = logging.getLogger(__name__)
@@ -100,14 +112,16 @@ async def send_events_async(
     """Fetch events from the page and send them to the server"""
     try:
         # Check if function exists first
-        events = await page.evaluate("""
+        events = await page.evaluate(
+            """
         () => {
             if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
                 return [];
             }
             return window.lmnrGetAndClearEvents();
         }
-        """)
+        """
+        )
 
         if not events or len(events) == 0:
             return
@@ -127,14 +141,16 @@ def send_events_sync(
 ):
     """Synchronous version of send_events"""
     try:
-        events = page.evaluate("""
+        events = page.evaluate(
+            """
         () => {
             if (!window.lmnrPageIsFocused || typeof window.lmnrGetAndClearEvents !== 'function') {
                 return [];
             }
             return window.lmnrGetAndClearEvents();
         }
-        """)
+        """
+        )
         if not events or len(events) == 0:
             return
 

lmnr/sdk/client/asynchronous/resources/agent.py

@@ -278,6 +278,8 @@ class AsyncAgent(BaseAsyncResource):
             json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
+            if response.status_code != 200:
+                raise RuntimeError(await response.read())
             async for line in response.aiter_lines():
                 line = str(line)
                 if line.startswith("[DONE]"):
@@ -288,7 +290,7 @@ class AsyncAgent(BaseAsyncResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
-                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                    if chunk.root.chunk_type in ["finalOutput", "error", "timeout"]:
                         break
 
     async def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:

lmnr/sdk/client/synchronous/resources/agent.py

@@ -270,6 +270,8 @@ class Agent(BaseResource):
             json=request.model_dump(by_alias=True),
             headers=self._headers(),
         ) as response:
+            if response.status_code != 200:
+                raise RuntimeError(response.read())
             for line in response.iter_lines():
                 line = str(line)
                 if line.startswith("[DONE]"):
@@ -280,7 +282,7 @@ class Agent(BaseResource):
                 if line:
                     chunk = RunAgentResponseChunk.model_validate_json(line)
                     yield chunk.root
-                    if chunk.root.chunk_type in ["finalOutput", "error"]:
+                    if chunk.root.chunk_type in ["finalOutput", "error", "timeout"]:
                         break
 
     def __run_non_streaming(self, request: RunAgentRequest) -> AgentOutput:

lmnr/sdk/decorators.py

@@ -1,4 +1,4 @@
-from lmnr.opentelemetry_lib.decorators.base import (
+from lmnr.opentelemetry_lib.decorators import (
     entity_method,
     aentity_method,
 )
@@ -8,7 +8,9 @@ from typing import Callable, Literal, Optional, TypeVar, Union, cast
 from typing_extensions import ParamSpec
 
 from lmnr.opentelemetry_lib.tracing.attributes import SESSION_ID
-from lmnr.opentelemetry_lib.tracing.tracing import update_association_properties
+from lmnr.opentelemetry_lib.tracing.context_properties import (
+    update_association_properties,
+)
 
 from .utils import is_async
 

lmnr/sdk/evaluations.py

@@ -1,11 +1,11 @@
 import asyncio
 import re
 import uuid
-import dotenv
+
 from tqdm import tqdm
 from typing import Any, Awaitable, Optional, Set, Union
 
-from lmnr.opentelemetry_lib.instruments import Instruments
+from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing.attributes import SPAN_TYPE
 
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
@@ -111,7 +111,7 @@ class Evaluation:
         trace_export_timeout_seconds: Optional[int] = None,
     ):
         """
-        Initializes an instance of the Evaluations class.
+        Initializes an instance of the Evaluation class.
 
         Parameters:
             data (Union[List[EvaluationDatapoint|dict], EvaluationDataset]):\

lmnr/sdk/laminar.py

@@ -1,21 +1,17 @@
 from contextlib import contextmanager
 from contextvars import Context
 from lmnr.opentelemetry_lib import TracerManager
-from lmnr.opentelemetry_lib.instruments import Instruments
-from lmnr.opentelemetry_lib.tracing import get_tracer
+from lmnr.opentelemetry_lib.tracing.instruments import Instruments
+from lmnr.opentelemetry_lib.tracing.tracer import get_tracer
 from lmnr.opentelemetry_lib.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     Attributes,
     SPAN_TYPE,
 )
-from lmnr.opentelemetry_lib.config import MAX_MANUAL_SPAN_PAYLOAD_SIZE
-from lmnr.opentelemetry_lib.decorators.base import json_dumps
+from lmnr.opentelemetry_lib import MAX_MANUAL_SPAN_PAYLOAD_SIZE
+from lmnr.opentelemetry_lib.decorators import json_dumps
 from opentelemetry import context as context_api, trace
 from opentelemetry.context import attach, detach
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-    OTLPSpanExporter,
-    Compression,
-)
 from opentelemetry.sdk.trace.id_generator import RandomIdGenerator
 from opentelemetry.util.types import AttributeValue
 
@@ -34,7 +30,7 @@ from lmnr.opentelemetry_lib.tracing.attributes import (
     SPAN_OUTPUT,
     TRACE_TYPE,
 )
-from lmnr.opentelemetry_lib.tracing.tracing import (
+from lmnr.opentelemetry_lib.tracing.context_properties import (
     get_association_properties,
     remove_association_properties,
     set_association_properties,
@@ -52,8 +48,6 @@ from .types import (
 
 
 class Laminar:
-    __base_http_url: str
-    __base_grpc_url: str
     __project_api_key: Optional[str] = None
     __initialized: bool = False
 
@@ -65,9 +59,12 @@ class Laminar:
         http_port: Optional[int] = None,
         grpc_port: Optional[int] = None,
         instruments: Optional[Set[Instruments]] = None,
+        disabled_instruments: Optional[Set[Instruments]] = None,
         disable_batch: bool = False,
         max_export_batch_size: Optional[int] = None,
         export_timeout_seconds: Optional[int] = None,
+        set_global_tracer_provider: bool = True,
+        otel_logger_level: int = logging.ERROR,
     ):
         """Initialize Laminar context across the application.
         This method must be called before using any other Laminar methods or
@@ -92,6 +89,8 @@ class Laminar:
                         enable. Defaults to all instruments. You can pass\
                         an empty set to disable all instruments. Read more:\
                         https://docs.lmnr.ai/tracing/automatic-instrumentation
+            disabled_instruments (Optional[Set[Instruments]], optional): Instruments to\
+                        disable. Defaults to None.
             disable_batch (bool, optional): If set to True, spans will be sent\
                         immediately to the backend. Useful for debugging, but\
                         may cause performance overhead in production.
@@ -100,6 +99,13 @@ class Laminar:
                         exporter. Defaults to 30 seconds (unlike the\
                         OpenTelemetry default of 10 seconds).
                         Defaults to None.
+            set_global_tracer_provider (bool, optional): If set to True, the\
+                        Laminar tracer provider will be set as the global\
+                        tracer provider. OpenTelemetry allows only one tracer\
+                        provider per app, so set this to False, if you are using\
+                        another tracing library. Setting this to False may break\
+                        some external instrumentations, e.g. LiteLLM.
+                        Defaults to True.
 
         Raises:
             ValueError: If project API key is not set
@@ -116,6 +122,8 @@ class Laminar:
 
         url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
         url = url.rstrip("/")
+        if not url.startswith("http"):
+            url = f"https://{url}"
         if match := re.search(r":(\d{1,5})$", url):
             url = url[: -len(match.group(0))]
             if http_port is None:
@@ -124,36 +132,25 @@ class Laminar:
             else:
                 cls.__logger.info(f"Using HTTP port passed as an argument: {http_port}")
 
-        cls.__base_http_url = f"{url}:{http_port or 443}"
-        cls.__base_grpc_url = f"{url}:{grpc_port or 8443}"
-
         cls.__initialized = True
+
         if not os.getenv("OTEL_ATTRIBUTE_COUNT_LIMIT"):
             # each message is at least 2 attributes: role and content,
             # but the default attribute limit is 128, so raise it
             os.environ["OTEL_ATTRIBUTE_COUNT_LIMIT"] = "10000"
 
-        # 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`."
-        #     )
-
         TracerManager.init(
-            base_http_url=cls.__base_http_url,
+            base_url=url,
+            http_port=http_port or 443,
+            port=grpc_port or 8443,
             project_api_key=cls.__project_api_key,
-            exporter=OTLPSpanExporter(
-                endpoint=cls.__base_grpc_url,
-                headers={"authorization": f"Bearer {cls.__project_api_key}"},
-                compression=Compression.Gzip,
-                # default timeout is 10 seconds, increase it to 30 seconds
-                timeout=export_timeout_seconds or 30,
-            ),
             instruments=instruments,
+            block_instruments=disabled_instruments,
             disable_batch=disable_batch,
             max_export_batch_size=max_export_batch_size,
+            timeout_seconds=export_timeout_seconds,
+            set_global_tracer_provider=set_global_tracer_provider,
+            otel_logger_level=otel_logger_level,
         )
 
     @classmethod
@@ -680,7 +677,7 @@ class Laminar:
         """Set the metadata for the current trace.
 
         Args:
-            metadata (dict[str, str]): Metadata to set for the trace. Willl be\
+            metadata (dict[str, str]): Metadata to set for the trace. Will be\
                 sent as attributes, so must be json serializable.
         """
         props = {f"metadata.{k}": json_dumps(v) for k, v in metadata.items()}

lmnr/sdk/utils.py

@@ -37,10 +37,9 @@ def is_async(func: typing.Callable) -> bool:
         return True
 
     # Fallback: check if the function's code object contains 'async'.
-    # This is for cases when a decorator did not properly use
+    # This is for cases when a decorator (not ours) did not properly use
     # `functools.wraps` or `functools.update_wrapper`
-    CO_COROUTINE = inspect.CO_COROUTINE
-    return (func.__code__.co_flags & CO_COROUTINE) != 0
+    return (func.__code__.co_flags & inspect.CO_COROUTINE) != 0
 
 
 def is_async_iterator(o: typing.Any) -> bool:

lmnr/version.py

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