lmnr 0.6.16__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/opentelemetry_lib/opentelemetry/instrumentation/threading/__init__.py

@@ -0,0 +1,197 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Instrument threading to propagate OpenTelemetry context.
+
+Copied from opentelemetry-instrumentation-threading at commit:
+ad2fe813abb2ab0b6e25bedeebef5041ca3189f7
+https://github.com/open-telemetry/opentelemetry-python-contrib/blob/ad2fe813abb2ab0b6e25bedeebef5041ca3189f7/instrumentation/opentelemetry-instrumentation-threading/src/opentelemetry/instrumentation/threading/__init__.py
+
+Modified to use the Laminar isolated context.
+
+Usage
+-----
+
+.. code-block:: python
+
+    from opentelemetry.instrumentation.threading import ThreadingInstrumentor
+
+    ThreadingInstrumentor().instrument()
+
+This library provides instrumentation for the `threading` module to ensure that
+the OpenTelemetry context is propagated across threads. It is important to note
+that this instrumentation does not produce any telemetry data on its own. It
+merely ensures that the context is correctly propagated when threads are used.
+
+
+When instrumented, new threads created using threading.Thread, threading.Timer,
+or within futures.ThreadPoolExecutor will have the current OpenTelemetry
+context attached, and this context will be re-activated in the thread's
+run method or the executor's worker thread."
+"""
+
+from __future__ import annotations
+
+import threading
+from concurrent import futures
+from typing import TYPE_CHECKING, Any, Callable, Collection
+
+from wrapt import (
+    wrap_function_wrapper,  # type: ignore[reportUnknownVariableType]
+)
+
+from lmnr.opentelemetry_lib.tracing.context import (
+    get_current_context,
+    attach_context,
+    detach_context,
+)
+from opentelemetry import context
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+
+_instruments = ()
+
+if TYPE_CHECKING:
+    from typing import Protocol, TypeVar
+
+    R = TypeVar("R")
+
+    class HasOtelContext(Protocol):
+        _otel_context: context.Context
+
+
+class ThreadingInstrumentor(BaseInstrumentor):
+    __WRAPPER_START_METHOD = "start"
+    __WRAPPER_RUN_METHOD = "run"
+    __WRAPPER_SUBMIT_METHOD = "submit"
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs: Any):
+        self._instrument_thread()
+        self._instrument_timer()
+        self._instrument_thread_pool()
+
+    def _uninstrument(self, **kwargs: Any):
+        self._uninstrument_thread()
+        self._uninstrument_timer()
+        self._uninstrument_thread_pool()
+
+    @staticmethod
+    def _instrument_thread():
+        wrap_function_wrapper(
+            threading.Thread,
+            ThreadingInstrumentor.__WRAPPER_START_METHOD,
+            ThreadingInstrumentor.__wrap_threading_start,
+        )
+        wrap_function_wrapper(
+            threading.Thread,
+            ThreadingInstrumentor.__WRAPPER_RUN_METHOD,
+            ThreadingInstrumentor.__wrap_threading_run,
+        )
+
+    @staticmethod
+    def _instrument_timer():
+        wrap_function_wrapper(
+            threading.Timer,
+            ThreadingInstrumentor.__WRAPPER_START_METHOD,
+            ThreadingInstrumentor.__wrap_threading_start,
+        )
+        wrap_function_wrapper(
+            threading.Timer,
+            ThreadingInstrumentor.__WRAPPER_RUN_METHOD,
+            ThreadingInstrumentor.__wrap_threading_run,
+        )
+
+    @staticmethod
+    def _instrument_thread_pool():
+        wrap_function_wrapper(
+            futures.ThreadPoolExecutor,
+            ThreadingInstrumentor.__WRAPPER_SUBMIT_METHOD,
+            ThreadingInstrumentor.__wrap_thread_pool_submit,
+        )
+
+    @staticmethod
+    def _uninstrument_thread():
+        unwrap(threading.Thread, ThreadingInstrumentor.__WRAPPER_START_METHOD)
+        unwrap(threading.Thread, ThreadingInstrumentor.__WRAPPER_RUN_METHOD)
+
+    @staticmethod
+    def _uninstrument_timer():
+        unwrap(threading.Timer, ThreadingInstrumentor.__WRAPPER_START_METHOD)
+        unwrap(threading.Timer, ThreadingInstrumentor.__WRAPPER_RUN_METHOD)
+
+    @staticmethod
+    def _uninstrument_thread_pool():
+        unwrap(
+            futures.ThreadPoolExecutor,
+            ThreadingInstrumentor.__WRAPPER_SUBMIT_METHOD,
+        )
+
+    @staticmethod
+    def __wrap_threading_start(
+        call_wrapped: Callable[[], None],
+        instance: HasOtelContext,
+        args: tuple[()],
+        kwargs: dict[str, Any],
+    ) -> None:
+        instance._lmnr_otel_context = get_current_context()
+        return call_wrapped(*args, **kwargs)
+
+    @staticmethod
+    def __wrap_threading_run(
+        call_wrapped: Callable[..., R],
+        instance: HasOtelContext,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> R:
+        token = None
+        try:
+            # Genearally, this must be set in __wrap_threading_start, but it is
+            # possible to Thread().run() without Thread().start(), so in that case,
+            # we need to capture the context here.
+            # We still want to capture the context in __wrap_threading_start,
+            # in order to stay close to the original implementation.
+            if not hasattr(instance, "_lmnr_otel_context"):
+                instance._lmnr_otel_context = get_current_context()
+            token = attach_context(instance._lmnr_otel_context)
+            return call_wrapped(*args, **kwargs)
+        finally:
+            if token is not None:
+                detach_context(token)
+
+    @staticmethod
+    def __wrap_thread_pool_submit(
+        call_wrapped: Callable[..., R],
+        instance: futures.ThreadPoolExecutor,
+        args: tuple[Callable[..., Any], ...],
+        kwargs: dict[str, Any],
+    ) -> R:
+        # obtain the original function and wrapped kwargs
+        original_func = args[0]
+        otel_context = get_current_context()
+
+        def wrapped_func(*func_args: Any, **func_kwargs: Any) -> R:
+            token = None
+            try:
+                token = attach_context(otel_context)
+                return original_func(*func_args, **func_kwargs)
+            finally:
+                if token is not None:
+                    detach_context(token)
+
+        # replace the original function with the wrapped function
+        new_args: tuple[Callable[..., Any], ...] = (wrapped_func,) + args[1:]
+        return call_wrapped(*new_args, **kwargs)

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -4,15 +4,28 @@ import threading
 
 from lmnr.opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
-from lmnr.sdk.client.synchronous.sync_client import LaminarClient
+from lmnr.sdk.types import SessionRecordingOptions
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.opentelemetry_lib.tracing.instruments import (
     Instruments,
     init_instrumentations,
 )
+from lmnr.opentelemetry_lib.tracing.context import (
+    attach_context,
+    clear_context,
+    pop_span_context as ctx_pop_span_context,
+    get_current_context,
+    get_token_stack,
+    push_span_context as ctx_push_span_context,
+    set_token_stack,
+)
 
 from opentelemetry import trace
-from opentelemetry.instrumentation.threading import ThreadingInstrumentor
+from opentelemetry.context import Context
+
+# instead of importing from opentelemetry.instrumentation.threading,
+# we import from our modified copy to use Laminar's isolated context.
+from ..opentelemetry.instrumentation.threading import ThreadingInstrumentor
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider, SpanProcessor
 from opentelemetry.sdk.trace.export import SpanExporter
@@ -25,13 +38,14 @@ MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
+    session_recording_options: SessionRecordingOptions = {}
     _lock = threading.Lock()
     _tracer_provider: TracerProvider | None = None
     _logger: logging.Logger
-    _client: LaminarClient
     _async_client: AsyncLaminarClient
     _resource: Resource
     _span_processor: SpanProcessor
+    _original_thread_init = None
 
     def __new__(
         cls,
@@ -39,33 +53,36 @@ class TracerWrapper(object):
         exporter: SpanExporter | None = None,
         instruments: set[Instruments] | None = None,
         block_instruments: set[Instruments] | None = None,
-        base_url: str = "https://api.lmnr.ai",
+        base_url: str | None = None,
         port: int = 8443,
         http_port: int = 443,
         project_api_key: str | None = None,
         max_export_batch_size: int | None = None,
         force_http: bool = False,
-        timeout_seconds: int = 10,
+        timeout_seconds: int = 30,
         set_global_tracer_provider: bool = True,
         otel_logger_level: int = logging.ERROR,
+        session_recording_options: SessionRecordingOptions | None = None,
     ) -> "TracerWrapper":
         # Silence some opentelemetry warnings
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
 
-        base_http_url = f"{base_url}:{http_port}"
+        base_http_url = f"{base_url}:{http_port}" if base_url else None
         with cls._lock:
             if not hasattr(cls, "instance"):
                 cls._initialize_logger(cls)
                 obj = super(TracerWrapper, cls).__new__(cls)
 
-                obj._client = LaminarClient(
-                    base_url=base_http_url,
-                    project_api_key=project_api_key,
-                )
-                obj._async_client = AsyncLaminarClient(
-                    base_url=base_http_url,
-                    project_api_key=project_api_key,
-                )
+                # Store session recording options
+                cls.session_recording_options = session_recording_options or {}
+
+                if project_api_key:
+                    obj._async_client = AsyncLaminarClient(
+                        base_url=base_http_url or "https://api.lmnr.ai",
+                        project_api_key=project_api_key,
+                    )
+                else:
+                    obj._async_client = None
 
                 obj._resource = Resource(attributes=TracerWrapper.resource_attributes)
 
@@ -91,6 +108,9 @@ class TracerWrapper(object):
 
                 obj._tracer_provider.add_span_processor(obj._span_processor)
 
+                # Setup threading context inheritance
+                obj._setup_threading_inheritance()
+
                 # This is not a real instrumentation and does not generate telemetry
                 # data, but it is required to ensure that OpenTelemetry context
                 # propagation is enabled.
@@ -102,7 +122,6 @@ class TracerWrapper(object):
                     tracer_provider=obj._tracer_provider,
                     instruments=instruments,
                     block_instruments=block_instruments,
-                    client=obj._client,
                     async_client=obj._async_client,
                 )
 
@@ -113,6 +132,43 @@ class TracerWrapper(object):
 
             return cls.instance
 
+    def _setup_threading_inheritance(self):
+        """Setup threading inheritance for isolated context."""
+        if TracerWrapper._original_thread_init is None:
+            # Monkey patch Thread.__init__ to capture context inheritance
+            TracerWrapper._original_thread_init = threading.Thread.__init__
+
+            def patched_thread_init(thread_self, *args, **kwargs):
+                # Capture current isolated context and token stack for inheritance
+                current_context = get_current_context()
+                current_token_stack = get_token_stack().copy()
+
+                # Get the original target function
+                original_target = kwargs.get("target")
+                if not original_target and args:
+                    original_target = args[0]
+
+                # Only inherit if we have a target function
+                if original_target:
+                    # Create a wrapper function that sets up context
+                    def thread_wrapper(*target_args, **target_kwargs):
+                        # Set inherited context and token stack in the new thread
+                        attach_context(current_context)
+                        set_token_stack(current_token_stack)
+                        # Run original target
+                        return original_target(*target_args, **target_kwargs)
+
+                    # Replace the target with our wrapper
+                    if "target" in kwargs:
+                        kwargs["target"] = thread_wrapper
+                    elif args:
+                        args = (thread_wrapper,) + args[1:]
+
+                # Call original init
+                TracerWrapper._original_thread_init(thread_self, *args, **kwargs)
+
+            threading.Thread.__init__ = patched_thread_init
+
     def exit_handler(self):
         if isinstance(self._span_processor, LaminarSpanProcessor):
             self._span_processor.clear()
@@ -124,6 +180,21 @@ class TracerWrapper(object):
         console_log_handler.setFormatter(VerboseColorfulFormatter())
         self._logger.addHandler(console_log_handler)
 
+    def get_isolated_context(self) -> Context:
+        """Get the current isolated context."""
+        return get_current_context()
+
+    def push_span_context(self, span: trace.Span) -> Context:
+        """Push a new context with the given span onto the stack."""
+        current_ctx = get_current_context()
+        new_context = trace.set_span_in_context(span, current_ctx)
+        ctx_push_span_context(new_context)
+        return new_context
+
+    def pop_span_context(self) -> None:
+        """Pop the current span context from the stack."""
+        ctx_pop_span_context()
+
     @staticmethod
     def set_static_params(
         resource_attributes: dict,
@@ -134,8 +205,19 @@ class TracerWrapper(object):
 
     @classmethod
     def verify_initialized(cls) -> bool:
-        with cls._lock:
-            return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
+        # This is not using lock, but it is fine to return False from here
+        # even if initialization is going on.
+
+        # If we try to acquire the lock here, it may deadlock if an automatic
+        # instrumentation is importing a file that (at the top level) has a
+        # function annotated with Laminar's `observe` decorator.
+        # The decorator is evaluated at import time, inside `init_instrumentations`,
+        # which is called by the `TracerWrapper` constructor while holding the lock.
+        # Without the lock here, we will simply return False, which will cause
+        # the decorator to return the original function. This is fine, at runtime,
+        # the next import statement will re-evaluate the decorator, and Laminar will
+        # have been initialized by that time.
+        return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
 
     @classmethod
     def clear(cls):
@@ -144,6 +226,8 @@ class TracerWrapper(object):
         # Any state cleanup. Now used in between tests
         if isinstance(cls.instance._span_processor, LaminarSpanProcessor):
             cls.instance._span_processor.clear()
+        # Clear the isolated context state for clean test state
+        clear_context()
 
     def shutdown(self):
         if self._tracer_provider is None:
@@ -156,7 +240,24 @@ class TracerWrapper(object):
             return False
         return self._span_processor.force_flush()
 
-    def get_tracer(self):
+    def force_reinit_processor(self):
+        if isinstance(self._span_processor, LaminarSpanProcessor):
+            self._span_processor.force_flush()
+            self._span_processor.force_reinit()
+            # Clear the isolated context to prevent subsequent invocations
+            # (e.g., in Lambda) from continuing traces from previous invocations
+            clear_context()
+        else:
+            self._logger.warning(
+                "Not using LaminarSpanProcessor, cannot force reinit processor"
+            )
+
+    @classmethod
+    def get_session_recording_options(cls) -> SessionRecordingOptions:
+        """Get the session recording options set during initialization."""
+        return cls.session_recording_options
+
+    def get_tracer(self) -> trace.Tracer:
         if self._tracer_provider is None:
             return trace.get_tracer_provider().get_tracer(TRACER_NAME)
         return self._tracer_provider.get_tracer(TRACER_NAME)

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -2,7 +2,10 @@ import abc
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 
-from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
+from lmnr.opentelemetry_lib.utils.package_check import (
+    get_package_version,
+    is_package_installed,
+)
 
 
 class InstrumentorInitializer(abc.ABC):
@@ -27,10 +30,8 @@ class AnthropicInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("anthropic"):
             return None
-        if not is_package_installed("opentelemetry-instrumentation-anthropic"):
-            return None
 
-        from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+        from ..opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
 
         return AnthropicInstrumentor(
             upload_base64_image=None,
@@ -50,13 +51,62 @@ class BedrockInstrumentorInitializer(InstrumentorInitializer):
 
 
 class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
+    """Instruments for different versions of browser-use:
+
+    - browser-use < 0.5: BrowserUseLegacyInstrumentor to track agent_step and
+      other structure spans. Session instrumentation is controlled by
+      Instruments.PLAYWRIGHT (or Instruments.PATCHRIGHT for several versions
+      in 0.4.* that used patchright)
+    - browser-use ~= 0.5: Structure spans live in browser_use package itself.
+      Session instrumentation is controlled by Instruments.PLAYWRIGHT
+    - browser-use >= 0.6.0rc1: BubusInstrumentor to keep spans structure.
+      Session instrumentation is controlled by Instruments.BROWSER_USE_SESSION
+    """
+
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("browser-use"):
             return None
 
-        from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
+        version = get_package_version("browser-use")
+        from packaging.version import parse
+
+        if version and parse(version) < parse("0.5.0"):
+            from lmnr.sdk.browser.browser_use_otel import BrowserUseLegacyInstrumentor
+
+            return BrowserUseLegacyInstrumentor()
+
+        return None
+
+
+class BrowserUseSessionInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(
+        self, async_client, *args, **kwargs
+    ) -> BaseInstrumentor | None:
+        if not is_package_installed("browser-use"):
+            return None
+
+        version = get_package_version("browser-use")
+        from packaging.version import parse
+
+        if version and parse(version) >= parse("0.6.0rc1"):
+            from lmnr.sdk.browser.browser_use_cdp_otel import BrowserUseInstrumentor
+
+            if async_client is None:
+                return None
+
+            return BrowserUseInstrumentor(async_client)
 
-        return BrowserUseInstrumentor()
+        return None
+
+
+class BubusInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("bubus"):
+            return None
+
+        from lmnr.sdk.browser.bubus_otel import BubusInstrumentor
+
+        return BubusInstrumentor()
 
 
 class ChromaInstrumentorInitializer(InstrumentorInitializer):
@@ -71,6 +121,19 @@ class ChromaInstrumentorInitializer(InstrumentorInitializer):
         return ChromaInstrumentor()
 
 
+class ClaudeAgentInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("claude-agent-sdk"):
+            return None
+
+        if not is_package_installed("lmnr-claude-code-proxy"):
+            return None
+
+        from ..opentelemetry.instrumentation.claude_agent import ClaudeAgentInstrumentor
+
+        return ClaudeAgentInstrumentor()
+
+
 class CohereInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("cohere"):
@@ -95,20 +158,24 @@ class CrewAIInstrumentorInitializer(InstrumentorInitializer):
         return CrewAiInstrumentor()
 
 
-class GoogleGenerativeAIInstrumentorInitializer(InstrumentorInitializer):
+class CuaAgentInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
-        if not is_package_installed("google-generativeai"):
+        if not is_package_installed("cua-agent"):
             return None
-        if not is_package_installed(
-            "opentelemetry-instrumentation-google-generativeai"
-        ):
+
+        from ..opentelemetry.instrumentation.cua_agent import CuaAgentInstrumentor
+
+        return CuaAgentInstrumentor()
+
+
+class CuaComputerInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("cua-computer"):
             return None
 
-        from opentelemetry.instrumentation.google_generativeai import (
-            GoogleGenerativeAiInstrumentor,
-        )
+        from ..opentelemetry.instrumentation.cua_computer import CuaComputerInstrumentor
 
-        return GoogleGenerativeAiInstrumentor()
+        return CuaComputerInstrumentor()
 
 
 class GoogleGenAIInstrumentorInitializer(InstrumentorInitializer):
@@ -127,10 +194,8 @@ class GroqInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("groq"):
             return None
-        if not is_package_installed("opentelemetry-instrumentation-groq"):
-            return None
 
-        from opentelemetry.instrumentation.groq import GroqInstrumentor
+        from ..opentelemetry.instrumentation.groq import GroqInstrumentor
 
         return GroqInstrumentor()
 
@@ -147,6 +212,16 @@ class HaystackInstrumentorInitializer(InstrumentorInitializer):
         return HaystackInstrumentor()
 
 
+class KernelInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("kernel"):
+            return None
+
+        from ..opentelemetry.instrumentation.kernel import KernelInstrumentor
+
+        return KernelInstrumentor()
+
+
 class LanceDBInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("lancedb"):
@@ -261,10 +336,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,16 +347,37 @@ class OpenAIInstrumentorInitializer(InstrumentorInitializer):
         )
 
 
+class OpenHandsAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
+        if not is_package_installed("openhands-ai"):
+            return None
+        from ..opentelemetry.instrumentation.openhands_ai import OpenHandsInstrumentor
+
+        return OpenHandsInstrumentor()
+
+
+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
+        self, async_client, *args, **kwargs
     ) -> BaseInstrumentor | None:
         if not is_package_installed("patchright"):
             return None
 
         from lmnr.sdk.browser.patchright_otel import PatchrightInstrumentor
 
-        return PatchrightInstrumentor(client, async_client)
+        if async_client is None:
+            return None
+
+        return PatchrightInstrumentor(async_client)
 
 
 class PineconeInstrumentorInitializer(InstrumentorInitializer):
@@ -300,14 +394,17 @@ class PineconeInstrumentorInitializer(InstrumentorInitializer):
 
 class PlaywrightInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(
-        self, client, async_client, *args, **kwargs
+        self, async_client, *args, **kwargs
     ) -> BaseInstrumentor | None:
         if not is_package_installed("playwright"):
             return None
 
         from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
 
-        return PlaywrightInstrumentor(client, async_client)
+        if async_client is None:
+            return None
+
+        return PlaywrightInstrumentor(async_client)
 
 
 class QdrantInstrumentorInitializer(InstrumentorInitializer):
@@ -345,6 +442,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 +452,7 @@ class SkyvernInstrumentorInitializer(InstrumentorInitializer):
 
         return SkyvernInstrumentor()
 
+
 class TogetherInstrumentorInitializer(InstrumentorInitializer):
     def init_instrumentor(self, *args, **kwargs) -> BaseInstrumentor | None:
         if not is_package_installed("together"):