lmnr 0.6.17__py3-none-any.whl → 0.6.19__py3-none-any.whl

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -261,10 +261,8 @@ class OpenAIInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("openai"):
             return None
-        if not is_package_installed("opentelemetry-instrumentation-openai"):
-            return None
 
-        from opentelemetry.instrumentation.openai import OpenAIInstrumentor
+        from ..opentelemetry.instrumentation.openai import OpenAIInstrumentor
 
         return OpenAIInstrumentor(
             # Default in the package provided is an empty function, which
@@ -274,6 +272,15 @@ class OpenAIInstrumentorInitializer(InstrumentorInitializer):
         )
 
 
+class OpenTelemetryInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        from ..opentelemetry.instrumentation.opentelemetry import (
+            OpentelemetryInstrumentor,
+        )
+
+        return OpentelemetryInstrumentor()
+
+
 class PatchrightInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(
         self, client, async_client, *args, **kwargs
@@ -345,6 +352,7 @@ class SageMakerInstrumentorInitializer(InstrumentorInitializer):
 
         return SageMakerInstrumentor()
 
+
 class SkyvernInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("skyvern"):
@@ -354,6 +362,7 @@ class SkyvernInstrumentorInitializer(InstrumentorInitializer):
 
         return SkyvernInstrumentor()
 
+
 class TogetherInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("together"):

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -34,6 +34,11 @@ class Instruments(Enum):
     MISTRAL = "mistral"
     OLLAMA = "ollama"
     OPENAI = "openai"
+    # Patch OpenTelemetry to fix DataDog's broken Span context
+    # See lmnr.opentelemetry_lib.opentelemetry.instrumentation.opentelemetry
+    # for more details.
+    OPENTELEMETRY = "opentelemetry"
+    ###
     PATCHRIGHT = "patchright"
     PINECONE = "pinecone"
     PLAYWRIGHT = "playwright"
@@ -47,6 +52,7 @@ class Instruments(Enum):
     WATSONX = "watsonx"
     WEAVIATE = "weaviate"
 
+
 INSTRUMENTATION_INITIALIZERS: dict[
     Instruments, initializers.InstrumentorInitializer
 ] = {
@@ -71,6 +77,7 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.MISTRAL: initializers.MistralInstrumentorInitializer(),
     Instruments.OLLAMA: initializers.OllamaInstrumentorInitializer(),
     Instruments.OPENAI: initializers.OpenAIInstrumentorInitializer(),
+    Instruments.OPENTELEMETRY: initializers.OpenTelemetryInstrumentorInitializer(),
     Instruments.PATCHRIGHT: initializers.PatchrightInstrumentorInitializer(),
     Instruments.PINECONE: initializers.PineconeInstrumentorInitializer(),
     Instruments.PLAYWRIGHT: initializers.PlaywrightInstrumentorInitializer(),

lmnr/sdk/browser/browser_use_otel.py

@@ -19,7 +19,7 @@ except ImportError as e:
         "to install Browser Use or remove this import."
     ) from e
 
-_instruments = ("browser-use >= 0.1.0",)
+_instruments = ("browser-use < 0.5.0",)
 
 WRAPPED_METHODS = [
     {

lmnr/sdk/browser/patchright_otel.py

@@ -5,8 +5,6 @@ from lmnr.sdk.browser.playwright_otel import (
     _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
@@ -50,12 +48,6 @@ WRAPPED_METHODS = [
         "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",
@@ -101,12 +93,6 @@ WRAPPED_METHODS_ASYNC = [
         "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",

lmnr/sdk/browser/playwright_otel.py

@@ -13,12 +13,7 @@ from opentelemetry.instrumentation.utils import unwrap
 from opentelemetry.trace import (
     get_tracer,
     Tracer,
-    get_current_span,
-    Span,
-    INVALID_SPAN,
-    set_span_in_context,
 )
-from opentelemetry.context import get_current
 from typing import Collection
 from wrapt import wrap_function_wrapper
 
@@ -54,59 +49,37 @@ except ImportError as e:
 _instruments = ("playwright >= 1.9.0",)
 logger = logging.getLogger(__name__)
 
-_context_spans: dict[str, Span] = {}
-
 
 @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:
-        page = wrapped(*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, client)
-        return page
+    page = wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    handle_navigation_sync(page, session_id, client)
+    return page
 
 
 @with_tracer_and_client_wrapper
 async def _wrap_new_page_async(
     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')}"
-    ) as span:
-        page = await wrapped(*args, **kwargs)
-        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, client)
-        return page
+    page = await wrapped(*args, **kwargs)
+    session_id = str(uuid.uuid4().hex)
+    await handle_navigation_async(page, session_id, client)
+    return page
 
 
 @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)
     for context in browser.contexts:
-        span = get_current_span()
-        if span == INVALID_SPAN:
-            span = tracer.start_span(
-                name=f"{to_wrap.get('object')}.{to_wrap.get('method')}"
-            )
-            set_span_in_context(span, get_current())
-            _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)
+            return handle_navigation_sync(page, session_id, client)
 
         context.on(
             "page",
@@ -114,7 +87,7 @@ def _wrap_new_browser_sync(
         )
 
         for page in context.pages:
-            handle_navigation_sync(page, session_id, trace_id, client)
+            handle_navigation_sync(page, session_id, client)
     return browser
 
 
@@ -122,26 +95,16 @@ def _wrap_new_browser_sync(
 async def _wrap_new_browser_async(
     tracer: Tracer, client: AsyncLaminarClient, to_wrap, wrapped, instance, args, kwargs
 ):
-    global _context_spans
     browser: Browser = await wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
     for context in browser.contexts:
-        span = get_current_span()
-        if span == INVALID_SPAN:
-            span = tracer.start_span(
-                name=f"{to_wrap.get('object')}.{to_wrap.get('method')}"
-            )
-            set_span_in_context(span, get_current())
-            _context_spans[id(context)] = span
-        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: Page):
-            return await handle_navigation_async(page, session_id, trace_id, client)
+            return await handle_navigation_async(page, session_id, client)
 
         context.on("page", handle_page_navigation)
         for page in context.pages:
-            await handle_navigation_async(page, session_id, trace_id, client)
+            await handle_navigation_async(page, session_id, client)
     return browser
 
 
@@ -151,25 +114,16 @@ def _wrap_new_context_sync(
 ):
     context: SyncBrowserContext = wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
-    span = get_current_span()
-    if span == INVALID_SPAN:
-        span = tracer.start_span(
-            name=f"{to_wrap.get('object')}.{to_wrap.get('method')}"
-        )
-        set_span_in_context(span, get_current())
-        _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)
+        return handle_navigation_sync(page, session_id, client)
 
     context.on(
         "page",
         handle_page_navigation,
     )
     for page in context.pages:
-        handle_navigation_sync(page, session_id, trace_id, client)
+        handle_navigation_sync(page, session_id, client)
     return context
 
 
@@ -179,67 +133,16 @@ async def _wrap_new_context_async(
 ):
     context: BrowserContext = await wrapped(*args, **kwargs)
     session_id = str(uuid.uuid4().hex)
-    span = get_current_span()
-    if span == INVALID_SPAN:
-        span = tracer.start_span(
-            name=f"{to_wrap.get('object')}.{to_wrap.get('method')}"
-        )
-        set_span_in_context(span, get_current())
-        _context_spans[id(context)] = span
-    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, client)
+        return await handle_navigation_async(page, session_id, client)
 
     context.on("page", handle_page_navigation)
     for page in context.pages:
-        await handle_navigation_async(page, session_id, trace_id, client)
+        await handle_navigation_async(page, session_id, client)
     return context
 
 
-@with_tracer_and_client_wrapper
-def _wrap_close_browser_sync(
-    tracer: Tracer,
-    client: LaminarClient,
-    to_wrap,
-    wrapped,
-    instance: SyncBrowser,
-    args,
-    kwargs,
-):
-    global _context_spans
-    for context in instance.contexts:
-        key = id(context)
-        span = _context_spans.get(key)
-        if span:
-            if span.is_recording():
-                span.end()
-            _context_spans.pop(key)
-    return wrapped(*args, **kwargs)
-
-
-@with_tracer_and_client_wrapper
-async def _wrap_close_browser_async(
-    tracer: Tracer,
-    client: AsyncLaminarClient,
-    to_wrap,
-    wrapped,
-    instance: Browser,
-    args,
-    kwargs,
-):
-    global _context_spans
-    for context in instance.contexts:
-        key = id(context)
-        span = _context_spans.get(key)
-        if span:
-            if span.is_recording():
-                span.end()
-            _context_spans.pop(key)
-    return await wrapped(*args, **kwargs)
-
-
 WRAPPED_METHODS = [
     {
         "package": "playwright.sync_api",
@@ -271,12 +174,6 @@ WRAPPED_METHODS = [
         "method": "connect_over_cdp",
         "wrapper": _wrap_new_browser_sync,
     },
-    {
-        "package": "playwright.sync_api",
-        "object": "Browser",
-        "method": "close",
-        "wrapper": _wrap_close_browser_sync,
-    },
     {
         "package": "playwright.sync_api",
         "object": "Browser",
@@ -322,12 +219,6 @@ WRAPPED_METHODS_ASYNC = [
         "method": "connect_over_cdp",
         "wrapper": _wrap_new_browser_async,
     },
-    {
-        "package": "playwright.async_api",
-        "object": "Browser",
-        "method": "close",
-        "wrapper": _wrap_close_browser_async,
-    },
     {
         "package": "playwright.async_api",
         "object": "Browser",
@@ -393,13 +284,8 @@ class PlaywrightInstrumentor(BaseInstrumentor):
 
     def _uninstrument(self, **kwargs):
         # Unwrap methods
-        global _context_spans
         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}")
-            for span in _context_spans.values():
-                if span.is_recording():
-                    span.end()
-            _context_spans = {}

lmnr/sdk/browser/pw_utils.py

@@ -12,7 +12,6 @@ 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:
     if is_package_installed("playwright"):
         from playwright.async_api import Page
@@ -110,11 +109,15 @@ async def send_events_async(
         await client._browser_events.send(session_id, trace_id, events)
     except Exception as e:
         if str(e).startswith("Page.evaluate: Execution context was destroyed"):
-            logger.info("Execution context was destroyed, injecting rrweb again")
-            await inject_rrweb_async(page)
+            await inject_session_recorder_async(page)
             await send_events_async(page, session_id, trace_id, client)
         else:
-            logger.debug(f"Could not send events: {e}")
+            # silence the error if the page has been closed, not an issue
+            if (
+                "Page.evaluate: Target page, context or browser has been closed"
+                not in str(e)
+            ):
+                logger.warning(f"Could not send events: {e}")
 
 
 def send_events_sync(
@@ -139,14 +142,18 @@ def send_events_sync(
 
     except Exception as e:
         if str(e).startswith("Page.evaluate: Execution context was destroyed"):
-            logger.info("Execution context was destroyed, injecting rrweb again")
-            inject_rrweb_sync(page)
+            inject_session_recorder_sync(page)
             send_events_sync(page, session_id, trace_id, client)
         else:
-            logger.debug(f"Could not send events: {e}")
+            # silence the error if the page has been closed, not an issue
+            if (
+                "Page.evaluate: Target page, context or browser has been closed"
+                not in str(e)
+            ):
+                logger.warning(f"Could not send events: {e}")
 
 
-def inject_rrweb_sync(page: SyncPage):
+def inject_session_recorder_sync(page: SyncPage):
     try:
         page.wait_for_load_state("domcontentloaded")
 
@@ -156,34 +163,36 @@ def inject_rrweb_sync(page: SyncPage):
                 """() => typeof window.lmnrRrweb !== 'undefined'"""
             )
         except Exception as e:
-            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            logger.debug(f"Failed to check if session recorder is loaded: {e}")
             is_loaded = False
 
         if not is_loaded:
 
-            def load_rrweb():
+            def load_session_recorder():
                 try:
                     page.evaluate(RRWEB_CONTENT)
                     return True
                 except Exception as e:
-                    logger.debug(f"Failed to load rrweb: {e}")
+                    logger.debug(f"Failed to load session recorder: {e}")
                     return False
 
             if not retry_sync(
-                load_rrweb, delay=1, error_message="Failed to load rrweb"
+                load_session_recorder,
+                delay=1,
+                error_message="Failed to load session recorder",
             ):
                 return
 
         try:
             page.evaluate(INJECT_PLACEHOLDER)
         except Exception as e:
-            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+            logger.debug(f"Failed to inject session recorder: {e}")
 
     except Exception as e:
-        logger.error(f"Error during rrweb injection: {e}")
+        logger.error(f"Error during session recorder injection: {e}")
 
 
-async def inject_rrweb_async(page: Page):
+async def inject_session_recorder_async(page: Page):
     try:
         await page.wait_for_load_state("domcontentloaded")
 
@@ -193,38 +202,40 @@ async def inject_rrweb_async(page: Page):
                 """() => typeof window.lmnrRrweb !== 'undefined'"""
             )
         except Exception as e:
-            logger.debug(f"Failed to check if rrweb is loaded: {e}")
+            logger.debug(f"Failed to check if session recorder is loaded: {e}")
             is_loaded = False
 
         if not is_loaded:
 
-            async def load_rrweb():
+            async def load_session_recorder():
                 try:
                     await page.evaluate(RRWEB_CONTENT)
                     return True
                 except Exception as e:
-                    logger.debug(f"Failed to load rrweb: {e}")
+                    logger.debug(f"Failed to load session recorder: {e}")
                     return False
 
             if not await retry_async(
-                load_rrweb, delay=1, error_message="Failed to load rrweb"
+                load_session_recorder,
+                delay=1,
+                error_message="Failed to load session recorder",
             ):
                 return
 
         try:
             await page.evaluate(INJECT_PLACEHOLDER)
         except Exception as e:
-            logger.debug(f"Failed to inject rrweb placeholder: {e}")
+            logger.debug(f"Failed to inject session recorder placeholder: {e}")
 
     except Exception as e:
-        logger.error(f"Error during rrweb injection: {e}")
+        logger.error(f"Error during session recorder injection: {e}")
 
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
-def handle_navigation_sync(
-    page: SyncPage, session_id: str, trace_id: str, client: LaminarClient
-):
-    trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
+def handle_navigation_sync(page: SyncPage, session_id: str, client: LaminarClient):
+    span = trace.get_current_span()
+    trace_id = format(span.get_span_context().trace_id, "032x")
+    span.set_attribute("lmnr.internal.has_browser_session", True)
     original_bring_to_front = page.bring_to_front
 
     def bring_to_front():
@@ -245,7 +256,7 @@ def handle_navigation_sync(
 
     def on_load():
         try:
-            inject_rrweb_sync(page)
+            inject_session_recorder_sync(page)
         except Exception as e:
             logger.error(f"Error in on_load handler: {e}")
 
@@ -266,14 +277,17 @@ def handle_navigation_sync(
 
     page.on("load", on_load)
     page.on("close", on_close)
-    inject_rrweb_sync(page)
+    inject_session_recorder_sync(page)
 
 
 @observe(name="playwright.page", ignore_input=True, ignore_output=True)
 async def handle_navigation_async(
-    page: Page, session_id: str, trace_id: str, client: AsyncLaminarClient
+    page: Page, session_id: str, client: AsyncLaminarClient
 ):
-    trace.get_current_span().set_attribute("lmnr.internal.has_browser_session", True)
+
+    span = trace.get_current_span()
+    trace_id = format(span.get_span_context().trace_id, "032x")
+    span.set_attribute("lmnr.internal.has_browser_session", True)
 
     async def collection_loop():
         try:
@@ -289,7 +303,7 @@ async def handle_navigation_async(
 
     async def on_load():
         try:
-            await inject_rrweb_async(page)
+            await inject_session_recorder_async(page)
         except Exception as e:
             logger.error(f"Error in on_load handler: {e}")
 
@@ -321,4 +335,4 @@ async def handle_navigation_async(
         )
 
     page.bring_to_front = bring_to_front
-    await inject_rrweb_async(page)
+    await inject_session_recorder_async(page)

lmnr/version.py

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