lmnr 0.5.1a0__py3-none-any.whl → 0.5.3__py3-none-any.whl

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.base 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

@@ -2,7 +2,9 @@ import logging
 import uuid
 
 from lmnr.sdk.browser.pw_utils import handle_navigation_async, handle_navigation_sync
-from lmnr.sdk.browser.utils import with_tracer_wrapper
+from lmnr.sdk.browser.utils import with_tracer_and_client_wrapper
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.version import __version__
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
@@ -16,14 +18,15 @@ from opentelemetry.trace import (
     set_span_in_context,
 )
 from opentelemetry.context import get_current
-from typing import Collection, Optional
+from typing import Collection
 from wrapt import wrap_function_wrapper
 
 try:
-    from playwright.async_api import Browser
+    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(
@@ -37,12 +40,12 @@ _instruments = ("playwright >= 1.9.0",)
 logger = logging.getLogger(__name__)
 
 _context_spans: dict[str, Span] = {}
-_project_api_key: Optional[str] = None
-_base_http_url: Optional[str] = None
 
 
-@with_tracer_wrapper
-def _wrap_new_page(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+@with_tracer_and_client_wrapper
+def _wrap_new_page(
+    tracer: Tracer, client: LaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
     with tracer.start_as_current_span(
         f"{to_wrap.get('object')}.{to_wrap.get('method')}"
     ) as span:
@@ -50,15 +53,13 @@ def _wrap_new_page(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         session_id = str(uuid.uuid4().hex)
         trace_id = format(get_current_span().get_span_context().trace_id, "032x")
         span.set_attribute("lmnr.internal.has_browser_session", True)
-        handle_navigation_sync(
-            page, session_id, trace_id, _project_api_key, _base_http_url
-        )
+        handle_navigation_sync(page, session_id, trace_id, client)
         return page
 
 
-@with_tracer_wrapper
+@with_tracer_and_client_wrapper
 async def _wrap_new_page_async(
-    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
 ):
     with tracer.start_as_current_span(
         f"{to_wrap.get('object')}.{to_wrap.get('method')}"
@@ -67,14 +68,14 @@ async def _wrap_new_page_async(
         session_id = str(uuid.uuid4().hex)
         trace_id = format(span.get_span_context().trace_id, "032x")
         span.set_attribute("lmnr.internal.has_browser_session", True)
-        await handle_navigation_async(
-            page, session_id, trace_id, _project_api_key, _base_http_url
-        )
+        await handle_navigation_async(page, session_id, trace_id, client)
         return page
 
 
-@with_tracer_wrapper
-def _wrap_new_browser_sync(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+@with_tracer_and_client_wrapper
+def _wrap_new_browser_sync(
+    tracer: Tracer, client: LaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
     global _context_spans
     browser: SyncBrowser = wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
@@ -88,22 +89,23 @@ def _wrap_new_browser_sync(tracer: Tracer, to_wrap, wrapped, instance, args, kwa
             _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, _project_api_key, _base_http_url
-            ),
+            handle_page_navigation,
         )
+
         for page in context.pages:
-            handle_navigation_sync(
-                page, session_id, trace_id, _project_api_key, _base_http_url
-            )
+            handle_navigation_sync(page, session_id, trace_id, client)
     return browser
 
 
-@with_tracer_wrapper
+@with_tracer_and_client_wrapper
 async def _wrap_new_browser_async(
-    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+    tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
 ):
     global _context_spans
     browser: Browser = await wrapped(*args, **kwargs)
@@ -119,21 +121,19 @@ 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):
-            return await handle_navigation_async(
-                page, session_id, trace_id, _project_api_key, _base_http_url
-            )
+        async def handle_page_navigation(page: Page):
+            return await handle_navigation_async(page, session_id, trace_id, client)
 
         context.on("page", handle_page_navigation)
         for page in context.pages:
-            await handle_navigation_async(
-                page, session_id, trace_id, _project_api_key, _base_http_url
-            )
+            await handle_navigation_async(page, session_id, trace_id, client)
     return browser
 
 
-@with_tracer_wrapper
-def _wrap_new_context_sync(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+@with_tracer_and_client_wrapper
+def _wrap_new_context_sync(
+    tracer: Tracer, client: LaminarClient, to_wrap, wrapped, instance, args, kwargs
+):
     context: SyncBrowserContext = wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
     span = get_current_span()
@@ -146,24 +146,23 @@ def _wrap_new_context_sync(tracer: Tracer, to_wrap, wrapped, instance, args, kwa
     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, _project_api_key, _base_http_url
-        ),
+        handle_page_navigation,
     )
     for page in context.pages:
-        handle_navigation_sync(
-            page, session_id, trace_id, _project_api_key, _base_http_url
-        )
+        handle_navigation_sync(page, session_id, trace_id, client)
     return context
 
 
-@with_tracer_wrapper
+@with_tracer_and_client_wrapper
 async def _wrap_new_context_async(
-    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+    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:
@@ -176,21 +175,18 @@ async def _wrap_new_context_async(
     trace_id = format(span.get_span_context().trace_id, "032x")
 
     async def handle_page_navigation(page):
-        return await handle_navigation_async(
-            page, session_id, trace_id, _project_api_key, _base_http_url
-        )
+        return await handle_navigation_async(page, session_id, trace_id, client)
 
     context.on("page", handle_page_navigation)
     for page in context.pages:
-        await handle_navigation_async(
-            page, session_id, trace_id, _project_api_key, _base_http_url
-        )
+        await handle_navigation_async(page, session_id, trace_id, client)
     return context
 
 
-@with_tracer_wrapper
+@with_tracer_and_client_wrapper
 def _wrap_close_browser_sync(
     tracer: Tracer,
+    client: LaminarClient,
     to_wrap,
     wrapped,
     instance: SyncBrowser,
@@ -208,9 +204,10 @@ def _wrap_close_browser_sync(
     return wrapped(*args, **kwargs)
 
 
-@with_tracer_wrapper
+@with_tracer_and_client_wrapper
 async def _wrap_close_browser_async(
     tracer: Tracer,
+    client: AsyncLaminarClient,
     to_wrap,
     wrapped,
     instance: Browser,
@@ -323,33 +320,27 @@ 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,
     },
 ]
 
 
 class PlaywrightInstrumentor(BaseInstrumentor):
-    def __init__(self):
+    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):
-        global _project_api_key, _base_http_url
-
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
 
-        if kwargs.get("project_api_key"):
-            _project_api_key = kwargs.get("project_api_key")
-
-        if kwargs.get("base_http_url"):
-            _base_http_url = kwargs.get("base_http_url")
-
         for wrapped_method in WRAPPED_METHODS:
             wrap_package = wrapped_method.get("package")
             wrap_object = wrapped_method.get("object")
@@ -360,6 +351,7 @@ class PlaywrightInstrumentor(BaseInstrumentor):
                     f"{wrap_object}.{wrap_method}",
                     wrapped_method.get("wrapper")(
                         tracer,
+                        self.client,
                         wrapped_method,
                     ),
                 )
@@ -377,6 +369,7 @@ class PlaywrightInstrumentor(BaseInstrumentor):
                     f"{wrap_object}.{wrap_method}",
                     wrapped_method.get("wrapper")(
                         tracer,
+                        self.async_client,
                         wrapped_method,
                     ),
                 )