lmnr 0.5.2__py3-none-any.whl → 0.6.0__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/{openllmetry_sdk/tracing/context_manager.py → opentelemetry_lib/tracing/tracer.py}

@@ -1,6 +1,11 @@
 from contextlib import contextmanager
 
-from lmnr.openllmetry_sdk.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/{openllmetry_sdk → 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.openllmetry_sdk.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__
@@ -8,6 +8,16 @@ from opentelemetry.instrumentation.utils import unwrap
 from opentelemetry.trace import get_tracer, Tracer
 from typing import Collection
 from wrapt import wrap_function_wrapper
+import pydantic
+
+try:
+    from browser_use import AgentHistoryList
+except ImportError as e:
+    raise ImportError(
+        f"Attempted to import {__file__}, but it is designed "
+        "to patch Browser Use, which is not installed. Use `pip install browser-use` "
+        "to install Browser Use or remove this import."
+    ) from e
 
 _instruments = ("browser-use >= 0.1.0",)
 
@@ -18,7 +28,7 @@ WRAPPED_METHODS = [
         "method": "run",
         "span_name": "agent.run",
         "ignore_input": False,
-        "ignore_output": True,
+        "ignore_output": False,
         "span_type": "DEFAULT",
     },
     {
@@ -73,7 +83,14 @@ async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         span.set_attributes(attributes)
         result = await wrapped(*args, **kwargs)
         if not to_wrap.get("ignore_output"):
-            span.set_attribute("lmnr.span.output", json_dumps(result))
+            if isinstance(result, AgentHistoryList):
+                result = result.final_result()
+            serialized = (
+                result.model_dump_json()
+                if isinstance(result, pydantic.BaseModel)
+                else json_dumps(result)
+            )
+            span.set_attribute("lmnr.span.output", serialized)
         return result
 
 

lmnr/sdk/browser/patchright_otel.py

@@ -0,0 +1,177 @@
+from lmnr.sdk.browser.playwright_otel import (
+    _wrap_new_page,
+    _wrap_new_page_async,
+    _wrap_new_browser_sync,
+    _wrap_new_browser_async,
+    _wrap_new_context_sync,
+    _wrap_new_context_async,
+    _wrap_close_browser_sync,
+    _wrap_close_browser_async,
+)
+from lmnr.sdk.client.synchronous.sync_client import LaminarClient
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.trace import get_tracer
+from lmnr.version import __version__
+from typing import Collection
+from wrapt import wrap_function_wrapper
+
+_instruments = ("patchright >= 1.9.0",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "patchright.sync_api",
+        "object": "BrowserContext",
+        "method": "new_page",
+        "wrapper": _wrap_new_page,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_new_page,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "BrowserType",
+        "method": "launch",
+        "wrapper": _wrap_new_browser_sync,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "BrowserType",
+        "method": "connect",
+        "wrapper": _wrap_new_browser_sync,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "BrowserType",
+        "method": "connect_over_cdp",
+        "wrapper": _wrap_new_browser_sync,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "Browser",
+        "method": "close",
+        "wrapper": _wrap_close_browser_sync,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "Browser",
+        "method": "new_context",
+        "wrapper": _wrap_new_context_sync,
+    },
+    {
+        "package": "patchright.sync_api",
+        "object": "BrowserType",
+        "method": "launch_persistent_context",
+        "wrapper": _wrap_new_context_sync,
+    },
+]
+
+WRAPPED_METHODS_ASYNC = [
+    {
+        "package": "patchright.async_api",
+        "object": "BrowserContext",
+        "method": "new_page",
+        "wrapper": _wrap_new_page_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "Browser",
+        "method": "new_page",
+        "wrapper": _wrap_new_page_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "BrowserType",
+        "method": "launch",
+        "wrapper": _wrap_new_browser_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "BrowserType",
+        "method": "connect",
+        "wrapper": _wrap_new_browser_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "BrowserType",
+        "method": "connect_over_cdp",
+        "wrapper": _wrap_new_browser_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "Browser",
+        "method": "close",
+        "wrapper": _wrap_close_browser_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "Browser",
+        "method": "new_context",
+        "wrapper": _wrap_new_context_async,
+    },
+    {
+        "package": "patchright.async_api",
+        "object": "BrowserType",
+        "method": "launch_persistent_context",
+        "wrapper": _wrap_new_context_async,
+    },
+]
+
+
+class PatchrightInstrumentor(BaseInstrumentor):
+    def __init__(self, client: LaminarClient, async_client: AsyncLaminarClient):
+        super().__init__()
+        self.client = client
+        self.async_client = async_client
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+            try:
+                wrap_function_wrapper(
+                    wrap_package,
+                    f"{wrap_object}.{wrap_method}",
+                    wrapped_method.get("wrapper")(
+                        tracer,
+                        self.client,
+                        wrapped_method,
+                    ),
+                )
+            except ModuleNotFoundError:
+                pass
+
+        for wrapped_method in WRAPPED_METHODS_ASYNC:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+            try:
+                wrap_function_wrapper(
+                    wrap_package,
+                    f"{wrap_object}.{wrap_method}",
+                    wrapped_method.get("wrapper")(
+                        tracer,
+                        self.async_client,
+                        wrapped_method,
+                    ),
+                )
+            except ModuleNotFoundError:
+                pass
+
+    def _uninstrument(self, **kwargs):
+        for wrapped_method in WRAPPED_METHODS + WRAPPED_METHODS_ASYNC:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            wrap_method = wrapped_method.get("method")
+            unwrap(wrap_package, f"{wrap_object}.{wrap_method}")

lmnr/sdk/browser/playwright_otel.py

@@ -22,10 +22,11 @@ from typing import Collection
 from wrapt import wrap_function_wrapper
 
 try:
-    from playwright.async_api import Browser, BrowserContext
+    from playwright.async_api import Browser, BrowserContext, Page
     from playwright.sync_api import (
         Browser as SyncBrowser,
         BrowserContext as SyncBrowserContext,
+        Page as SyncPage,
     )
 except ImportError as e:
     raise ImportError(
@@ -88,10 +89,15 @@ def _wrap_new_browser_sync(
             _context_spans[id(context)] = span
         span.set_attribute("lmnr.internal.has_browser_session", True)
         trace_id = format(span.get_span_context().trace_id, "032x")
+
+        def handle_page_navigation(page: SyncPage):
+            return handle_navigation_sync(page, session_id, trace_id, client)
+
         context.on(
             "page",
-            lambda page: handle_navigation_sync(page, session_id, trace_id, client),
+            handle_page_navigation,
         )
+
         for page in context.pages:
             handle_navigation_sync(page, session_id, trace_id, client)
     return browser
@@ -115,7 +121,7 @@ async def _wrap_new_browser_async(
         span.set_attribute("lmnr.internal.has_browser_session", True)
         trace_id = format(span.get_span_context().trace_id, "032x")
 
-        async def handle_page_navigation(page):
+        async def handle_page_navigation(page: Page):
             return await handle_navigation_async(page, session_id, trace_id, client)
 
         context.on("page", handle_page_navigation)
@@ -140,9 +146,12 @@ def _wrap_new_context_sync(
     span.set_attribute("lmnr.internal.has_browser_session", True)
     trace_id = format(span.get_span_context().trace_id, "032x")
 
+    def handle_page_navigation(page: SyncPage):
+        return handle_navigation_sync(page, session_id, trace_id, client)
+
     context.on(
         "page",
-        lambda page: handle_navigation_sync(page, session_id, trace_id, client),
+        handle_page_navigation,
     )
     for page in context.pages:
         handle_navigation_sync(page, session_id, trace_id, client)
@@ -153,7 +162,7 @@ def _wrap_new_context_sync(
 async def _wrap_new_context_async(
     tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
 ):
-    context: SyncBrowserContext = await wrapped(*args, **kwargs)
+    context: BrowserContext = await wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
     span = get_current_span()
     if span == INVALID_SPAN:
@@ -311,10 +320,10 @@ WRAPPED_METHODS_ASYNC = [
         "wrapper": _wrap_new_context_async,
     },
     {
-        "package": "playwright.sync_api",
+        "package": "playwright.async_api",
         "object": "BrowserType",
         "method": "launch_persistent_context",
-        "wrapper": _wrap_new_context_sync,
+        "wrapper": _wrap_new_context_async,
     },
 ]