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

lmnr/opentelemetry_lib/tracing/attributes.py

@@ -14,13 +14,17 @@ SPAN_OUTPUT = "lmnr.span.output"
 SPAN_TYPE = "lmnr.span.type"
 SPAN_PATH = "lmnr.span.path"
 SPAN_IDS_PATH = "lmnr.span.ids_path"
+PARENT_SPAN_PATH = "lmnr.span.parent_path"
+PARENT_SPAN_IDS_PATH = "lmnr.span.parent_ids_path"
 SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source"
 SPAN_SDK_VERSION = "lmnr.span.sdk_version"
 SPAN_LANGUAGE_VERSION = "lmnr.span.language_version"
+HUMAN_EVALUATOR_OPTIONS = "lmnr.span.human_evaluator_options"
 
 ASSOCIATION_PROPERTIES = "lmnr.association.properties"
 SESSION_ID = "session_id"
 USER_ID = "user_id"
+METADATA = "metadata"
 TRACE_TYPE = "trace_type"
 TRACING_LEVEL = "tracing_level"
 

lmnr/opentelemetry_lib/tracing/context.py

@@ -0,0 +1,200 @@
+import threading
+
+from abc import ABC, abstractmethod
+from contextvars import ContextVar
+from typing import Any
+from opentelemetry.context import Context, Token, create_key, get_value, set_value
+
+from lmnr.opentelemetry_lib.tracing.attributes import (
+    METADATA,
+    SESSION_ID,
+    TRACE_TYPE,
+    USER_ID,
+)
+from lmnr.sdk.types import TraceType
+
+
+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)
+
+
+CONTEXT_USER_ID_KEY = create_key(f"lmnr.{USER_ID}")
+CONTEXT_SESSION_ID_KEY = create_key(f"lmnr.{SESSION_ID}")
+CONTEXT_METADATA_KEY = create_key(f"lmnr.{METADATA}")
+CONTEXT_TRACE_TYPE_KEY = create_key(f"lmnr.{TRACE_TYPE}")
+
+
+def get_event_attributes_from_context(context: Context | None = None) -> dict[str, str]:
+    """Get the event attributes from the context."""
+    context = context or get_current_context()
+    attributes = {}
+    if session_id := get_value(CONTEXT_SESSION_ID_KEY, context):
+        attributes["lmnr.event.session_id"] = session_id
+    if user_id := get_value(CONTEXT_USER_ID_KEY, context):
+        attributes["lmnr.event.user_id"] = user_id
+    return attributes
+
+
+def set_association_prop_context(
+    user_id: str | None = None,
+    session_id: str | None = None,
+    trace_type: TraceType | None = None,
+    context: Context | None = None,
+    metadata: dict[str, Any] | None = None,
+    attach: bool = True,
+) -> Context:
+    context = context or get_current_context()
+    if user_id is not None:
+        context = set_value(CONTEXT_USER_ID_KEY, user_id, context)
+    if session_id is not None:
+        context = set_value(CONTEXT_SESSION_ID_KEY, session_id, context)
+    if trace_type is not None:
+        context = set_value(CONTEXT_TRACE_TYPE_KEY, trace_type.value, context)
+    if metadata is not None:
+        context = set_value(CONTEXT_METADATA_KEY, metadata, context)
+    if attach:
+        attach_context(context)
+    return context
+
+
+def pop_span_context() -> 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)
+
+
+def push_span_context(context: Context) -> None:
+    """Push a new span context onto the stack."""
+    token = attach_context(context)
+    token_stack = get_token_stack().copy()
+    token_stack.append(token)
+    set_token_stack(token_stack)
+
+
+def clear_context() -> None:
+    """Clear the isolated context and token stack.
+
+    This is primarily used during force_flush operations in Lambda-like
+    environments to ensure subsequent invocations don't continue traces
+    from previous invocations.
+
+    Warning: This should only be called when you're certain no spans are
+    actively being processed, as it will reset all context state.
+    """
+    # Clear the token stack first
+    try:
+        _isolated_token_stack.set([])
+    except LookupError:
+        pass
+
+    # Clear thread-local storage if it exists
+    if hasattr(_isolated_token_stack_storage, "token_stack"):
+        _isolated_token_stack_storage.token_stack = []
+
+    # Reset the context to a fresh empty context
+    # This doesn't require manually detaching tokens since we're
+    # intentionally resetting everything to a clean state
+    _ISOLATED_RUNTIME_CONTEXT._current_context.set(Context())

lmnr/opentelemetry_lib/tracing/exporter.py

@@ -1,20 +1,30 @@
 import grpc
 import re
+import threading
+from urllib.parse import urlparse, urlunparse
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter,
 )
-from opentelemetry.exporter.otlp.proto.http import Compression
+from opentelemetry.exporter.otlp.proto.http import Compression as HTTPCompression
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter as HTTPOTLPSpanExporter,
 )
 
-from lmnr.sdk.utils import from_env
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.utils import from_env, get_otel_env_var, parse_otel_headers
+
+logger = get_default_logger(__name__)
 
 
 class LaminarSpanExporter(SpanExporter):
     instance: OTLPSpanExporter | HTTPOTLPSpanExporter
+    endpoint: str
+    headers: dict[str, str]
+    timeout: float
+    force_http: bool
+    _instance_lock: threading.RLock
 
     def __init__(
         self,
@@ -24,6 +34,7 @@ class LaminarSpanExporter(SpanExporter):
         timeout_seconds: int = 30,
         force_http: bool = False,
     ):
+        self._instance_lock = threading.RLock()
         url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
         url = url.rstrip("/")
         if match := re.search(r":(\d{1,5})$", url):
@@ -34,26 +45,109 @@ class LaminarSpanExporter(SpanExporter):
             port = 443 if force_http else 8443
         final_url = f"{url}:{port or 443}"
         api_key = api_key or from_env("LMNR_PROJECT_API_KEY")
-        if force_http:
-            self.instance = HTTPOTLPSpanExporter(
-                endpoint=f"{final_url}/v1/traces",
-                headers={"Authorization": f"Bearer {api_key}"},
-                compression=Compression.Gzip,
-                timeout=timeout_seconds,
+        self.endpoint = final_url
+        if api_key:
+            self.headers = (
+                {"Authorization": f"Bearer {api_key}"}
+                if force_http
+                else {"authorization": f"Bearer {api_key}"}
+            )
+        elif get_otel_env_var("HEADERS"):
+            self.headers = parse_otel_headers(get_otel_env_var("HEADERS"))
+        else:
+            self.headers = {}
+        self.timeout = timeout_seconds
+        self.force_http = force_http
+        if get_otel_env_var("ENDPOINT"):
+            if not base_url:
+                self.endpoint = get_otel_env_var("ENDPOINT")
+            else:
+                logger.warning(
+                    "OTEL_ENDPOINT is set, but Laminar base URL is also set. Ignoring OTEL_ENDPOINT."
+                )
+            protocol = get_otel_env_var("PROTOCOL") or "grpc/protobuf"
+            exporter_type = from_env("OTEL_EXPORTER") or "otlp_grpc"
+            self.force_http = (
+                protocol in ("http/protobuf", "http/json")
+                or exporter_type == "otlp_http"
+            )
+        if not self.endpoint:
+            raise ValueError(
+                "Laminar base URL is not set and OTEL_ENDPOINT is not set. Please either\n"
+                "- set the LMNR_BASE_URL environment variable\n"
+                "- set the OTEL_ENDPOINT environment variable\n"
+                "- pass the base_url parameter to Laminar.initialize"
+            )
+        self._init_instance()
+
+    def _normalize_http_endpoint(self, endpoint: str) -> str:
+        """
+        Normalize HTTP endpoint URL by adding /v1/traces path if no path is present.
+
+        Args:
+            endpoint: The endpoint URL to normalize
+
+        Returns:
+            The normalized endpoint URL with /v1/traces path if needed
+        """
+        try:
+            parsed = urlparse(endpoint)
+            # Check if there's no path or only a trailing slash
+            if not parsed.path or parsed.path == "/":
+                # Add /v1/traces to the endpoint
+                new_parsed = parsed._replace(path="/v1/traces")
+                normalized_url = urlunparse(new_parsed)
+                logger.info(
+                    f"No path found in HTTP endpoint URL. "
+                    f"Adding default path /v1/traces: {endpoint} -> {normalized_url}"
+                )
+                return normalized_url
+            return endpoint
+        except Exception as e:
+            logger.warning(
+                f"Failed to parse endpoint URL '{endpoint}': {e}. Using as-is."
+            )
+            return endpoint
+
+    def _init_instance(self):
+        # Create new instance first (outside critical section for performance)
+        if self.force_http:
+            # Normalize HTTP endpoint to ensure it has a path
+            http_endpoint = self._normalize_http_endpoint(self.endpoint)
+            new_instance = HTTPOTLPSpanExporter(
+                endpoint=http_endpoint,
+                headers=self.headers,
+                compression=HTTPCompression.Gzip,
+                timeout=self.timeout,
             )
         else:
-            self.instance = OTLPSpanExporter(
-                endpoint=final_url,
-                headers={"authorization": f"Bearer {api_key}"},
+            new_instance = OTLPSpanExporter(
+                endpoint=self.endpoint,
+                headers=self.headers,
+                timeout=self.timeout,
                 compression=grpc.Compression.Gzip,
-                timeout=timeout_seconds,
             )
 
+        # Atomic swap with proper cleanup
+        with self._instance_lock:
+            old_instance: OTLPSpanExporter | HTTPOTLPSpanExporter | None = getattr(
+                self, "instance", None
+            )
+            if old_instance is not None:
+                try:
+                    old_instance.shutdown()
+                except Exception as e:
+                    logger.warning(f"Error shutting down old exporter instance: {e}")
+            self.instance = new_instance
+
     def export(self, spans: list[ReadableSpan]) -> SpanExportResult:
-        return self.instance.export(spans)
+        with self._instance_lock:
+            return self.instance.export(spans)
 
     def shutdown(self) -> None:
-        return self.instance.shutdown()
+        with self._instance_lock:
+            return self.instance.shutdown()
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        return self.instance.force_flush(timeout_millis)
+        with self._instance_lock:
+            return self.instance.force_flush(timeout_millis)

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -4,7 +4,6 @@ from enum import Enum
 
 from opentelemetry.trace import TracerProvider
 import lmnr.opentelemetry_lib.tracing._instrument_initializers as initializers
-from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
 
 module_logger = logging.getLogger(__name__)
@@ -17,13 +16,18 @@ class Instruments(Enum):
     ANTHROPIC = "anthropic"
     BEDROCK = "bedrock"
     BROWSER_USE = "browser_use"
+    BROWSER_USE_SESSION = "browser_use_session"
+    BUBUS = "bubus"
     CHROMA = "chroma"
+    CLAUDE_AGENT = "claude_agent"
     COHERE = "cohere"
     CREWAI = "crewai"
-    GOOGLE_GENERATIVEAI = "google_generativeai"
+    CUA_AGENT = "cua_agent"
+    CUA_COMPUTER = "cua_computer"
     GOOGLE_GENAI = "google_genai"
     GROQ = "groq"
     HAYSTACK = "haystack"
+    KERNEL = "kernel"
     LANCEDB = "lancedb"
     LANGCHAIN = "langchain"
     LANGGRAPH = "langgraph"
@@ -34,6 +38,12 @@ class Instruments(Enum):
     MISTRAL = "mistral"
     OLLAMA = "ollama"
     OPENAI = "openai"
+    OPENHANDS = "openhands"
+    # 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 +57,7 @@ class Instruments(Enum):
     WATSONX = "watsonx"
     WEAVIATE = "weaviate"
 
+
 INSTRUMENTATION_INITIALIZERS: dict[
     Instruments, initializers.InstrumentorInitializer
 ] = {
@@ -54,13 +65,18 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.ANTHROPIC: initializers.AnthropicInstrumentorInitializer(),
     Instruments.BEDROCK: initializers.BedrockInstrumentorInitializer(),
     Instruments.BROWSER_USE: initializers.BrowserUseInstrumentorInitializer(),
+    Instruments.BROWSER_USE_SESSION: initializers.BrowserUseSessionInstrumentorInitializer(),
+    Instruments.BUBUS: initializers.BubusInstrumentorInitializer(),
     Instruments.CHROMA: initializers.ChromaInstrumentorInitializer(),
+    Instruments.CLAUDE_AGENT: initializers.ClaudeAgentInstrumentorInitializer(),
     Instruments.COHERE: initializers.CohereInstrumentorInitializer(),
     Instruments.CREWAI: initializers.CrewAIInstrumentorInitializer(),
-    Instruments.GOOGLE_GENERATIVEAI: initializers.GoogleGenerativeAIInstrumentorInitializer(),
+    Instruments.CUA_AGENT: initializers.CuaAgentInstrumentorInitializer(),
+    Instruments.CUA_COMPUTER: initializers.CuaComputerInstrumentorInitializer(),
     Instruments.GOOGLE_GENAI: initializers.GoogleGenAIInstrumentorInitializer(),
     Instruments.GROQ: initializers.GroqInstrumentorInitializer(),
     Instruments.HAYSTACK: initializers.HaystackInstrumentorInitializer(),
+    Instruments.KERNEL: initializers.KernelInstrumentorInitializer(),
     Instruments.LANCEDB: initializers.LanceDBInstrumentorInitializer(),
     Instruments.LANGCHAIN: initializers.LangchainInstrumentorInitializer(),
     Instruments.LANGGRAPH: initializers.LanggraphInstrumentorInitializer(),
@@ -71,6 +87,8 @@ INSTRUMENTATION_INITIALIZERS: dict[
     Instruments.MISTRAL: initializers.MistralInstrumentorInitializer(),
     Instruments.OLLAMA: initializers.OllamaInstrumentorInitializer(),
     Instruments.OPENAI: initializers.OpenAIInstrumentorInitializer(),
+    Instruments.OPENHANDS: initializers.OpenHandsAIInstrumentorInitializer(),
+    Instruments.OPENTELEMETRY: initializers.OpenTelemetryInstrumentorInitializer(),
     Instruments.PATCHRIGHT: initializers.PatchrightInstrumentorInitializer(),
     Instruments.PINECONE: initializers.PineconeInstrumentorInitializer(),
     Instruments.PLAYWRIGHT: initializers.PlaywrightInstrumentorInitializer(),
@@ -90,7 +108,6 @@ def init_instrumentations(
     tracer_provider: TracerProvider,
     instruments: set[Instruments] | None = None,
     block_instruments: set[Instruments] | None = None,
-    client: LaminarClient | None = None,
     async_client: AsyncLaminarClient | None = None,
 ):
     block_instruments = block_instruments or set()
@@ -109,7 +126,7 @@ def init_instrumentations(
             continue
 
         try:
-            instrumentor = initializer.init_instrumentor(client, async_client)
+            instrumentor = initializer.init_instrumentor(async_client)
             if instrumentor is None:
                 continue
             if not instrumentor.is_instrumented_by_opentelemetry:

lmnr/opentelemetry_lib/tracing/processor.py

@@ -1,3 +1,5 @@
+import logging
+import threading
 import uuid
 
 from opentelemetry.sdk.trace.export import (
@@ -7,26 +9,41 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
 )
 from opentelemetry.sdk.trace import Span
-from opentelemetry.context import Context, get_value, get_current, set_value
+from opentelemetry.context import Context, get_value
 
 from lmnr.opentelemetry_lib.tracing.attributes import (
+    ASSOCIATION_PROPERTIES,
+    PARENT_SPAN_IDS_PATH,
+    PARENT_SPAN_PATH,
+    SESSION_ID,
     SPAN_IDS_PATH,
     SPAN_INSTRUMENTATION_SOURCE,
     SPAN_LANGUAGE_VERSION,
     SPAN_PATH,
     SPAN_SDK_VERSION,
+    TRACE_TYPE,
+    USER_ID,
 )
-from lmnr.opentelemetry_lib.tracing.exporter import LaminarSpanExporter
-from lmnr.opentelemetry_lib.tracing.context_properties import (
-    _set_association_properties_attributes,
+from lmnr.opentelemetry_lib.tracing.context import (
+    CONTEXT_METADATA_KEY,
+    CONTEXT_SESSION_ID_KEY,
+    CONTEXT_TRACE_TYPE_KEY,
+    CONTEXT_USER_ID_KEY,
 )
+from lmnr.opentelemetry_lib.tracing.exporter import LaminarSpanExporter
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.utils import is_otel_attribute_value_type, json_dumps
 from lmnr.version import PYTHON_VERSION, __version__
 
 
 class LaminarSpanProcessor(SpanProcessor):
     instance: BatchSpanProcessor | SimpleSpanProcessor
+    logger: logging.Logger
     __span_id_to_path: dict[int, list[str]] = {}
     __span_id_lists: dict[int, list[str]] = {}
+    max_export_batch_size: int
+    _instance_lock: threading.RLock
+    _paths_lock: threading.RLock
 
     def __init__(
         self,
@@ -35,10 +52,14 @@ 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,
     ):
+        self._instance_lock = threading.RLock()
+        self._paths_lock = threading.RLock()
+        self.logger = get_default_logger(__name__)
+        self.max_export_batch_size = max_export_batch_size
         self.exporter = exporter or LaminarSpanExporter(
             base_url=base_url,
             port=port,
@@ -55,41 +76,118 @@ class LaminarSpanProcessor(SpanProcessor):
         )
 
     def on_start(self, span: Span, parent_context: Context | None = 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
+        with self._paths_lock:
+            parent_span_path = list(span.attributes.get(PARENT_SPAN_PATH, tuple())) or (
+                self.__span_id_to_path.get(span.parent.span_id) if span.parent else None
+            )
+            parent_span_ids_path = list(
+                span.attributes.get(PARENT_SPAN_IDS_PATH, tuple())
+            ) or (
+                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)
+            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)
+        if parent_context:
+            trace_type = get_value(CONTEXT_TRACE_TYPE_KEY, parent_context)
+            if trace_type:
+                span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{TRACE_TYPE}", trace_type)
+            user_id = get_value(CONTEXT_USER_ID_KEY, parent_context)
+            if user_id:
+                span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{USER_ID}", user_id)
+            session_id = get_value(CONTEXT_SESSION_ID_KEY, parent_context)
+            if session_id:
+                span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{SESSION_ID}", session_id)
+            ctx_metadata = get_value(CONTEXT_METADATA_KEY, parent_context)
+            if ctx_metadata and isinstance(ctx_metadata, dict):
+                span_metadata = {}
+                if hasattr(span, "attributes") and hasattr(span.attributes, "items"):
+                    for key, value in span.attributes.items():
+                        if key.startswith(f"{ASSOCIATION_PROPERTIES}.metadata."):
+                            span_metadata[
+                                key.replace(f"{ASSOCIATION_PROPERTIES}.metadata.", "")
+                            ] = value
+
+                for key, value in {**ctx_metadata, **span_metadata}.items():
+                    span.set_attribute(
+                        f"{ASSOCIATION_PROPERTIES}.metadata.{key}",
+                        (
+                            value
+                            if is_otel_attribute_value_type(value)
+                            else json_dumps(value)
+                        ),
+                    )
+
+        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)
+
+        with self._instance_lock:
+            self.instance.on_start(span, parent_context)
 
     def on_end(self, span: Span):
-        self.instance.on_end(span)
+        with self._instance_lock:
+            self.instance.on_end(span)
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        return self.instance.force_flush(timeout_millis)
+        with self._instance_lock:
+            return self.instance.force_flush(timeout_millis)
+
+    def force_reinit(self):
+        if not isinstance(self.exporter, LaminarSpanExporter):
+            self.logger.warning(
+                "LaminarSpanProcessor is not using LaminarSpanExporter, cannot force reinit"
+            )
+            return
+
+        # Reinitialize exporter (thread-safe, handles its own locking)
+        self.exporter._init_instance()
+
+        with self._instance_lock:
+            old_instance = self.instance
+            disable_batch = isinstance(old_instance, SimpleSpanProcessor)
+
+            try:
+                old_instance.shutdown()
+            except Exception as e:
+                self.logger.debug(f"Error shutting down old processor instance: {e}")
+
+            self.instance = (
+                SimpleSpanProcessor(self.exporter)
+                if disable_batch
+                else BatchSpanProcessor(
+                    self.exporter, max_export_batch_size=self.max_export_batch_size
+                )
+            )
 
     def shutdown(self):
-        self.instance.shutdown()
+        with self._instance_lock:
+            self.instance.shutdown()
 
     def clear(self):
-        self.__span_id_to_path = {}
-        self.__span_id_lists = {}
+        with self._paths_lock:
+            self.__span_id_to_path = {}
+            self.__span_id_lists = {}
+
+    def set_parent_path_info(
+        self,
+        parent_span_id: int,
+        span_path: list[str],
+        span_ids_path: list[str],
+    ):
+        with self._paths_lock:
+            self.__span_id_to_path[parent_span_id] = span_path
+            self.__span_id_lists[parent_span_id] = span_ids_path