lmnr 0.6.20__py3-none-any.whl → 0.7.0__py3-none-any.whl

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

@@ -0,0 +1,190 @@
+# 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._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:
+            token = attach_context(instance._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

@@ -10,9 +10,22 @@ from lmnr.opentelemetry_lib.tracing.instruments import (
     Instruments,
     init_instrumentations,
 )
+from lmnr.opentelemetry_lib.tracing.context import (
+    attach_context,
+    detach_context,
+    get_current_context,
+    get_token_stack,
+    _isolated_token_stack,
+    _isolated_token_stack_storage,
+    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
@@ -32,6 +45,7 @@ class TracerWrapper(object):
     _async_client: AsyncLaminarClient
     _resource: Resource
     _span_processor: SpanProcessor
+    _original_thread_init = None
 
     def __new__(
         cls,
@@ -45,7 +59,7 @@ class TracerWrapper(object):
         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,
     ) -> "TracerWrapper":
@@ -91,6 +105,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.
@@ -113,6 +130,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 +178,31 @@ 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)
+        token = attach_context(new_context)
+
+        # Store the token for later detachment - tokens are much lighter than contexts
+        current_stack = get_token_stack().copy()
+        current_stack.append(token)
+        set_token_stack(current_stack)
+
+        return new_context
+
+    def pop_span_context(self) -> None:
+        """Pop the current span context from the stack."""
+        current_stack = get_token_stack().copy()
+        if current_stack:
+            token = current_stack.pop()
+            set_token_stack(current_stack)
+            detach_context(token)
+
     @staticmethod
     def set_static_params(
         resource_attributes: dict,
@@ -144,6 +223,15 @@ 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
+        try:
+            _isolated_token_stack.set([])
+        except LookupError:
+            pass
+        if hasattr(_isolated_token_stack_storage, "token_stack"):
+            _isolated_token_stack_storage.token_stack = []
+        # Reset the isolated context to a fresh state
+        attach_context(Context())
 
     def shutdown(self):
         if self._tracer_provider is None:

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,
@@ -54,6 +55,12 @@ class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
         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.5.0"):
+            return None
+
         from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
 
         return BrowserUseInstrumentor()
@@ -127,10 +134,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()
 

lmnr/opentelemetry_lib/tracing/context.py

@@ -0,0 +1,109 @@
+import threading
+
+from abc import ABC, abstractmethod
+from contextvars import ContextVar
+from opentelemetry.context import Context, Token
+
+
+class _IsolatedRuntimeContext(ABC):
+    """The isolated RuntimeContext interface, identical to OpenTelemetry's _RuntimeContext
+    but isolated from the global context.
+    """
+
+    @abstractmethod
+    def attach(self, context: Context) -> Token[Context]:
+        """Sets the current `Context` object. Returns a
+        token that can be used to reset to the previous `Context`.
+
+        Args:
+            context: The Context to set.
+        """
+
+    @abstractmethod
+    def get_current(self) -> Context:
+        """Returns the current `Context` object."""
+
+    @abstractmethod
+    def detach(self, token: Token[Context]) -> None:
+        """Resets Context to a previous value
+
+        Args:
+            token: A reference to a previous Context.
+        """
+
+
+class IsolatedContextVarsRuntimeContext(_IsolatedRuntimeContext):
+    """An isolated implementation of the RuntimeContext interface which wraps ContextVar
+    but uses its own ContextVar instead of the global one.
+    """
+
+    def __init__(self) -> None:
+        self._current_context = ContextVar(
+            "isolated_current_context", default=Context()
+        )
+
+    def attach(self, context: Context) -> Token[Context]:
+        """Sets the current `Context` object. Returns a
+        token that can be used to reset to the previous `Context`.
+
+        Args:
+            context: The Context to set.
+        """
+        return self._current_context.set(context)
+
+    def get_current(self) -> Context:
+        """Returns the current `Context` object."""
+        return self._current_context.get()
+
+    def detach(self, token: Token[Context]) -> None:
+        """Resets Context to a previous value
+
+        Args:
+            token: A reference to a previous Context.
+        """
+        self._current_context.reset(token)
+
+
+# Create the isolated runtime context
+_ISOLATED_RUNTIME_CONTEXT = IsolatedContextVarsRuntimeContext()
+
+# Token stack for push/pop API compatibility - much lighter than copying contexts
+_isolated_token_stack: ContextVar[list[Token[Context]]] = ContextVar(
+    "isolated_token_stack", default=[]
+)
+
+# Thread-local storage for threading support
+_isolated_token_stack_storage = threading.local()
+
+
+def get_token_stack() -> list[Token[Context]]:
+    """Get the token stack, supporting both asyncio and threading."""
+    try:
+        return _isolated_token_stack.get()
+    except LookupError:
+        if not hasattr(_isolated_token_stack_storage, "token_stack"):
+            _isolated_token_stack_storage.token_stack = []
+        return _isolated_token_stack_storage.token_stack
+
+
+def set_token_stack(stack: list[Token[Context]]) -> None:
+    """Set the token stack, supporting both asyncio and threading."""
+    try:
+        _isolated_token_stack.set(stack)
+    except LookupError:
+        _isolated_token_stack_storage.token_stack = stack
+
+
+def get_current_context() -> Context:
+    """Get the current isolated context."""
+    return _ISOLATED_RUNTIME_CONTEXT.get_current()
+
+
+def attach_context(context: Context) -> Token[Context]:
+    """Attach a context to the isolated runtime context."""
+    return _ISOLATED_RUNTIME_CONTEXT.attach(context)
+
+
+def detach_context(token: Token[Context]) -> None:
+    """Detach a context from the isolated runtime context."""
+    _ISOLATED_RUNTIME_CONTEXT.detach(token)

lmnr/opentelemetry_lib/tracing/processor.py

@@ -17,9 +17,6 @@ from lmnr.opentelemetry_lib.tracing.attributes import (
     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__
 
 
@@ -35,7 +32,7 @@ class LaminarSpanProcessor(SpanProcessor):
         api_key: str | None = None,
         timeout_seconds: int = 30,
         force_http: bool = False,
-        max_export_batch_size: int = 512,
+        max_export_batch_size: int = 64,
         disable_batch: bool = False,
         exporter: SpanExporter | None = None,
     ):
@@ -76,9 +73,11 @@ class LaminarSpanProcessor(SpanProcessor):
         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)
+        if span.name == "LangGraph.workflow":
+            graph_context = get_value("lmnr.langgraph.graph") or {}
+            for key, value in graph_context.items():
+                span.set_attribute(f"lmnr.association.properties.{key}", value)
+
         self.instance.on_start(span, parent_context)
 
     def on_end(self, span: Span):

lmnr/opentelemetry_lib/tracing/tracer.py

@@ -1,6 +1,8 @@
 from contextlib import contextmanager
+from typing import Generator, Tuple
 
 from opentelemetry import trace
+from opentelemetry.context import Context
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
 
@@ -16,3 +18,30 @@ def get_tracer(flush_on_exit: bool = False):
     finally:
         if flush_on_exit:
             wrapper.flush()
+
+
+@contextmanager
+def get_tracer_with_context(
+    flush_on_exit: bool = False,
+) -> Generator[Tuple[trace.Tracer, Context], None, None]:
+    """Get tracer with isolated context. Returns (tracer, context) tuple."""
+    wrapper = TracerWrapper()
+    try:
+        tracer = wrapper.get_tracer()
+        context = wrapper.get_isolated_context()
+        yield tracer, context
+    finally:
+        if flush_on_exit:
+            wrapper.flush()
+
+
+def copy_current_context() -> Context:
+    """Copy the current isolated context for use in threads/tasks."""
+    wrapper = TracerWrapper()
+    return wrapper.get_isolated_context()
+
+
+def set_context_for_thread(context: Context) -> None:
+    """Set the isolated context for the current thread."""
+    wrapper = TracerWrapper()
+    wrapper.set_isolated_context(context)

lmnr/opentelemetry_lib/utils/package_check.py

@@ -1,5 +1,7 @@
 from importlib.metadata import distributions
 
+from typing import Optional
+
 installed_packages = {
     (dist.name or dist.metadata.get("Name", "")).lower() for dist in distributions()
 }
@@ -7,3 +9,10 @@ installed_packages = {
 
 def is_package_installed(package_name: str) -> bool:
     return package_name.lower() in installed_packages
+
+
+def get_package_version(package_name: str) -> Optional[str]:
+    for dist in distributions():
+        if (dist.name or dist.metadata.get("Name", "")).lower() == package_name.lower():
+            return dist.version
+    return None

lmnr/sdk/browser/browser_use_otel.py

@@ -1,4 +1,5 @@
 from lmnr.opentelemetry_lib.decorators import json_dumps
+from lmnr.sdk.laminar import Laminar
 from lmnr.sdk.browser.utils import with_tracer_wrapper
 from lmnr.sdk.utils import get_input_from_func_args
 from lmnr.version import __version__
@@ -19,7 +20,7 @@ except ImportError as e:
         "to install Browser Use or remove this import."
     ) from e
 
-_instruments = ("browser-use < 0.5.0",)
+_instruments = ("browser-use >= 0.1.0",)
 
 WRAPPED_METHODS = [
     {
@@ -27,8 +28,8 @@ WRAPPED_METHODS = [
         "object": "Agent",
         "method": "run",
         "span_name": "agent.run",
-        "ignore_input": False,
-        "ignore_output": False,
+        "ignore_input": True,
+        "ignore_output": True,
         "span_type": "DEFAULT",
     },
     {
@@ -46,15 +47,15 @@ WRAPPED_METHODS = [
         "method": "act",
         "span_name": "controller.act",
         "ignore_input": True,
-        "ignore_output": False,
+        "ignore_output": True,
         "span_type": "DEFAULT",
     },
     {
         "package": "browser_use.controller.registry.service",
         "object": "Registry",
         "method": "execute_action",
-        "ignore_input": False,
-        "ignore_output": False,
+        "ignore_input": True,
+        "ignore_output": True,
         "span_type": "TOOL",
     },
 ]
@@ -86,7 +87,8 @@ async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         step_info = kwargs.get("step_info", args[0] if len(args) > 0 else None)
         if step_info and hasattr(step_info, "step_number"):
             span_name = f"agent.step.{step_info.step_number}"
-    with tracer.start_as_current_span(span_name, attributes=attributes) as span:
+
+    with Laminar.start_as_current_span(span_name) as span:
         span.set_attributes(attributes)
         result = await wrapped(*args, **kwargs)
         if not to_wrap.get("ignore_output"):