lmnr 0.4.53.dev0__py3-none-any.whl → 0.7.26__py3-none-any.whl

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

@@ -0,0 +1,153 @@
+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 as HTTPCompression
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as HTTPOTLPSpanExporter,
+)
+
+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,
+        base_url: str | None = None,
+        port: int | None = None,
+        api_key: str | None = None,
+        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):
+            url = url[: -len(match.group(0))]
+            if port is None:
+                port = int(match.group(1))
+        if port is None:
+            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")
+        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:
+            new_instance = OTLPSpanExporter(
+                endpoint=self.endpoint,
+                headers=self.headers,
+                timeout=self.timeout,
+                compression=grpc.Compression.Gzip,
+            )
+
+        # 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:
+        with self._instance_lock:
+            return self.instance.export(spans)
+
+    def shutdown(self) -> None:
+        with self._instance_lock:
+            return self.instance.shutdown()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        with self._instance_lock:
+            return self.instance.force_flush(timeout_millis)

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -0,0 +1,140 @@
+import logging
+
+from enum import Enum
+
+from opentelemetry.trace import TracerProvider
+import lmnr.opentelemetry_lib.tracing._instrument_initializers as initializers
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+
+module_logger = logging.getLogger(__name__)
+
+
+class Instruments(Enum):
+    # The list of libraries which will be autoinstrumented
+    # if no specific instruments are provided to initialize()
+    ALEPHALPHA = "alephalpha"
+    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"
+    CUA_AGENT = "cua_agent"
+    CUA_COMPUTER = "cua_computer"
+    GOOGLE_GENAI = "google_genai"
+    GROQ = "groq"
+    HAYSTACK = "haystack"
+    KERNEL = "kernel"
+    LANCEDB = "lancedb"
+    LANGCHAIN = "langchain"
+    LANGGRAPH = "langgraph"
+    LLAMA_INDEX = "llama_index"
+    MARQO = "marqo"
+    MCP = "mcp"
+    MILVUS = "milvus"
+    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"
+    QDRANT = "qdrant"
+    REPLICATE = "replicate"
+    SAGEMAKER = "sagemaker"
+    SKYVERN = "skyvern"
+    TOGETHER = "together"
+    TRANSFORMERS = "transformers"
+    VERTEXAI = "vertexai"
+    WATSONX = "watsonx"
+    WEAVIATE = "weaviate"
+
+
+INSTRUMENTATION_INITIALIZERS: dict[
+    Instruments, initializers.InstrumentorInitializer
+] = {
+    Instruments.ALEPHALPHA: initializers.AlephAlphaInstrumentorInitializer(),
+    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.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(),
+    Instruments.LLAMA_INDEX: initializers.LlamaIndexInstrumentorInitializer(),
+    Instruments.MARQO: initializers.MarqoInstrumentorInitializer(),
+    Instruments.MCP: initializers.MCPInstrumentorInitializer(),
+    Instruments.MILVUS: initializers.MilvusInstrumentorInitializer(),
+    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(),
+    Instruments.QDRANT: initializers.QdrantInstrumentorInitializer(),
+    Instruments.REPLICATE: initializers.ReplicateInstrumentorInitializer(),
+    Instruments.SAGEMAKER: initializers.SageMakerInstrumentorInitializer(),
+    Instruments.SKYVERN: initializers.SkyvernInstrumentorInitializer(),
+    Instruments.TOGETHER: initializers.TogetherInstrumentorInitializer(),
+    Instruments.TRANSFORMERS: initializers.TransformersInstrumentorInitializer(),
+    Instruments.VERTEXAI: initializers.VertexAIInstrumentorInitializer(),
+    Instruments.WATSONX: initializers.WatsonxInstrumentorInitializer(),
+    Instruments.WEAVIATE: initializers.WeaviateInstrumentorInitializer(),
+}
+
+
+def init_instrumentations(
+    tracer_provider: TracerProvider,
+    instruments: set[Instruments] | None = None,
+    block_instruments: set[Instruments] | None = None,
+    async_client: AsyncLaminarClient | None = None,
+):
+    block_instruments = block_instruments or set()
+    if instruments is None:
+        instruments = set(Instruments)
+    if not isinstance(instruments, set):
+        instruments = set(instruments)
+
+    # Remove any instruments that were explicitly blocked
+    instruments = instruments - block_instruments
+
+    for instrument in instruments:
+        initializer = INSTRUMENTATION_INITIALIZERS.get(instrument)
+        if initializer is None:
+            module_logger.error(f"Invalid instrument: {instrument}")
+            continue
+
+        try:
+            instrumentor = initializer.init_instrumentor(async_client)
+            if instrumentor is None:
+                continue
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument(tracer_provider=tracer_provider)
+        except Exception as e:
+            if "No module named 'langchain_community'" in str(e):
+                # LangChain instrumentor does not require langchain_community,
+                # but throws this error if it's not installed.
+                continue
+            module_logger.error(f"Error initializing instrumentor: {e}")
+            continue

lmnr/opentelemetry_lib/tracing/processor.py

@@ -0,0 +1,193 @@
+import logging
+import threading
+import uuid
+
+from opentelemetry.sdk.trace.export import (
+    SpanProcessor,
+    SpanExporter,
+    BatchSpanProcessor,
+    SimpleSpanProcessor,
+)
+from opentelemetry.sdk.trace import Span
+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.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,
+        base_url: str | None = None,
+        port: int | None = None,
+        api_key: str | None = None,
+        timeout_seconds: int = 30,
+        force_http: bool = False,
+        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,
+            api_key=api_key,
+            timeout_seconds=timeout_seconds,
+            force_http=force_http,
+        )
+        self.instance = (
+            SimpleSpanProcessor(self.exporter)
+            if disable_batch
+            else BatchSpanProcessor(
+                self.exporter, max_export_batch_size=max_export_batch_size
+            )
+        )
+
+    def on_start(self, span: Span, parent_context: Context | None = None):
+        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}")
+
+        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):
+        with self._instance_lock:
+            self.instance.on_end(span)
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        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):
+        with self._instance_lock:
+            self.instance.shutdown()
+
+    def clear(self):
+        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