lmnr 0.7.17__tar.gz → 0.7.19__tar.gz

{lmnr-0.7.17 → lmnr-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.17
+Version: 0.7.19
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>

{lmnr-0.7.17 → lmnr-0.7.19}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.17"
+version = "0.7.19"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }

{lmnr-0.7.17 → lmnr-0.7.19}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py

@@ -206,15 +206,17 @@ def _set_request_attributes(span, args, kwargs):
             contents = [contents]
         for content in contents:
             processed_content = process_content_union(content)
-            content_str = get_content(processed_content)
+            content_payload = get_content(processed_content)
+            if isinstance(content_payload, dict):
+                content_payload = [content_payload]
 
             set_span_attribute(
                 span,
                 f"{gen_ai_attributes.GEN_AI_PROMPT}.{i}.content",
                 (
-                    content_str
-                    if isinstance(content_str, str)
-                    else json_dumps(content_str)
+                    content_payload
+                    if isinstance(content_payload, str)
+                    else json_dumps(content_payload)
                 ),
             )
             blocks = (
@@ -318,20 +320,22 @@ def _set_response_attributes(span, response: types.GenerateContentResponse):
         for candidate in candidates_list:
             has_content = False
             processed_content = process_content_union(candidate.content)
-            content_str = get_content(processed_content)
+            content_payload = get_content(processed_content)
+            if isinstance(content_payload, dict):
+                content_payload = [content_payload]
 
             set_span_attribute(
                 span, f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.role", "model"
             )
-            if content_str:
+            if content_payload:
                 has_content = True
                 set_span_attribute(
                     span,
                     f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.content",
                     (
-                        content_str
-                        if isinstance(content_str, str)
-                        else json_dumps(content_str)
+                        content_payload
+                        if isinstance(content_payload, str)
+                        else json_dumps(content_payload)
                     ),
                 )
             blocks = (
@@ -380,6 +384,10 @@ def _build_from_streaming_response(
     aggregated_usage_metadata = defaultdict(int)
     model_version = None
     for chunk in response:
+        try:
+            span.add_event("llm.content.completion.chunk")
+        except Exception:
+            pass
         # Important: do all processing in a separate sync function, that is
         # wrapped in @dont_throw. If we did it here, the @dont_throw on top of
         # this function would not be able to catch the errors, as they are
@@ -430,6 +438,10 @@ async def _abuild_from_streaming_response(
     aggregated_usage_metadata = defaultdict(int)
     model_version = None
     async for chunk in response:
+        try:
+            span.add_event("llm.content.completion.chunk")
+        except Exception:
+            pass
         # Important: do all processing in a separate sync function, that is
         # wrapped in @dont_throw. If we did it here, the @dont_throw on top of
         # this function would not be able to catch the errors, as they are

{lmnr-0.7.17 → lmnr-0.7.19}/src/lmnr/opentelemetry_lib/tracing/exporter.py

@@ -1,5 +1,6 @@
 import grpc
 import re
+import threading
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
@@ -22,6 +23,7 @@ class LaminarSpanExporter(SpanExporter):
     headers: dict[str, str]
     timeout: float
     force_http: bool
+    _instance_lock: threading.RLock
 
     def __init__(
         self,
@@ -31,6 +33,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):
@@ -74,27 +77,45 @@ class LaminarSpanExporter(SpanExporter):
                 "- set the OTEL_ENDPOINT environment variable\n"
                 "- pass the base_url parameter to Laminar.initialize"
             )
+        self._init_instance()
 
+    def _init_instance(self):
+        # Create new instance first (outside critical section for performance)
         if self.force_http:
-            self.instance = HTTPOTLPSpanExporter(
+            new_instance = HTTPOTLPSpanExporter(
                 endpoint=self.endpoint,
                 headers=self.headers,
                 compression=HTTPCompression.Gzip,
                 timeout=self.timeout,
             )
         else:
-            self.instance = OTLPSpanExporter(
+            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:
-        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-0.7.17 → lmnr-0.7.19}/src/lmnr/opentelemetry_lib/tracing/processor.py

@@ -1,4 +1,5 @@
 import logging
+import threading
 import uuid
 
 from opentelemetry.sdk.trace.export import (
@@ -30,6 +31,8 @@ class LaminarSpanProcessor(SpanProcessor):
     __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,
@@ -42,6 +45,8 @@ class LaminarSpanProcessor(SpanProcessor):
         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(
@@ -60,20 +65,25 @@ class LaminarSpanProcessor(SpanProcessor):
         )
 
     def on_start(self, span: Span, parent_context: Context | None = None):
-        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
+        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__)
@@ -84,13 +94,16 @@ class LaminarSpanProcessor(SpanProcessor):
             for key, value in graph_context.items():
                 span.set_attribute(f"lmnr.association.properties.{key}", value)
 
-        self.instance.on_start(span, parent_context)
+        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):
@@ -98,23 +111,32 @@ class LaminarSpanProcessor(SpanProcessor):
                 "LaminarSpanProcessor is not using LaminarSpanExporter, cannot force reinit"
             )
             return
-        self.instance.shutdown()
-        disable_batch = isinstance(self.instance, SimpleSpanProcessor)
-        del self.exporter.instance
-        del self.instance
 
+        # Reinitialize exporter (thread-safe, handles its own locking)
         self.exporter._init_instance()
-        self.instance = (
-            SimpleSpanProcessor(self.exporter)
-            if disable_batch
-            else BatchSpanProcessor(
-                self.exporter, max_export_batch_size=self.max_export_batch_size
+
+        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 = {}

{lmnr-0.7.17 → lmnr-0.7.19}/src/lmnr/sdk/laminar.py

@@ -1,5 +1,5 @@
 from contextlib import contextmanager
-from contextvars import Context
+from contextvars import Context, Token
 import warnings
 from lmnr.opentelemetry_lib import TracerManager
 from lmnr.opentelemetry_lib.tracing import TracerWrapper, get_current_context
@@ -434,17 +434,17 @@ class Laminar:
             with Laminar.use_span(span):
                 with Laminar.start_as_current_span("foo_inner"):
                     some_function()
-        
+
         def bar():
             with Laminar.use_span(span):
                 openai_client.chat.completions.create()
-        
+
         span = Laminar.start_span("outer")
         foo(span)
         bar(span)
         # IMPORTANT: End the span manually
         span.end()
-        
+
         # Results in:
         # | outer
         # |   | foo
@@ -642,6 +642,92 @@ class Laminar:
             if end_on_exit:
                 span.end()
 
+    @classmethod
+    def start_active_span(
+        cls,
+        name: str,
+        input: Any = None,
+        span_type: Literal["DEFAULT", "LLM", "TOOL"] = "DEFAULT",
+        context: Context | None = None,
+        parent_span_context: LaminarSpanContext | None = None,
+        tags: list[str] | None = None,
+    ) -> tuple[Span, Token[Context] | None]:
+        """Start a new span. Useful for manual instrumentation.
+        If `span_type` is set to `"LLM"`, you should report usage and response
+        attributes manually. See `Laminar.set_span_attributes` for more
+        information. Returns the span and a context token that can be used to
+        detach the context.
+
+        Usage example:
+        ```python
+        from src.lmnr import Laminar
+        def foo():
+            with Laminar.start_active_span("foo_inner"):
+                some_function()
+        
+        def bar():
+            openai_client.chat.completions.create()
+        
+        span, ctx_token = Laminar.start_active_span("outer")
+        foo()
+        bar()
+        # IMPORTANT: End the span manually
+        Laminar.end_active_span(span, ctx_token)
+        
+        # Results in:
+        # | outer
+        # |   | foo
+        # |   |   | foo_inner
+        # |   | bar
+        # |   |   | openai.chat
+        ```
+
+        Args:
+            name (str): name of the span
+            input (Any, optional): input to the span. Will be sent as an\
+                attribute, so must be json serializable. Defaults to None.
+            span_type (Literal["DEFAULT", "LLM", "TOOL"], optional):\
+                type of the span. If you use `"LLM"`, you should report usage\
+                and response attributes manually. Defaults to "DEFAULT".
+            context (Context | None, optional): raw OpenTelemetry context\
+                to attach the span to. Defaults to None.
+            parent_span_context (LaminarSpanContext | None, optional): parent\
+                span context to use for the span. Useful for continuing traces\
+                across services. If parent_span_context is a\
+                raw OpenTelemetry span context, or if it is a dictionary or string\
+                obtained from `Laminar.get_laminar_span_context_dict()` or\
+                `Laminar.get_laminar_span_context_str()` respectively, it will be\
+                converted to a `LaminarSpanContext` if possible. See also\
+                `Laminar.get_span_context`, `Laminar.get_span_context_dict` and\
+                `Laminar.get_span_context_str` for more information.
+                Defaults to None.
+            tags (list[str] | None, optional): tags to set for the span.
+                Defaults to None.
+        """
+        span = cls.start_span(
+            name, input, span_type, context, parent_span_context, tags
+        )
+        if not cls.is_initialized():
+            return span, None
+        wrapper = TracerWrapper()
+        context = wrapper.push_span_context(span)
+        context_token = context_api.attach(context)
+        return span, context_token
+
+    @classmethod
+    def end_active_span(cls, span: Span, ctx_token: Token[Context]):
+        """End an active span."""
+        span.end()
+        if not cls.is_initialized():
+            return
+        wrapper = TracerWrapper()
+        try:
+            wrapper.pop_span_context()
+            if ctx_token is not None:
+                context_api.detach(ctx_token)
+        except Exception:
+            pass
+
     @classmethod
     def set_span_output(cls, output: Any = None):
         """Set the output of the current span. Useful for manual
@@ -671,12 +757,12 @@ class Laminar:
         instrumentation.
         Example:
         ```python
-        with L.start_as_current_span(
+        with Laminar.start_as_current_span(
             name="my_span_name", input=input["messages"], span_type="LLM"
         ):
             response = await my_custom_call_to_openai(input)
-            L.set_span_output(response["choices"][0]["message"]["content"])
-            L.set_span_attributes({
+            Laminar.set_span_output(response["choices"][0]["message"]["content"])
+            Laminar.set_span_attributes({
                 Attributes.PROVIDER: 'openai',
                 Attributes.REQUEST_MODEL: input["model"],
                 Attributes.RESPONSE_MODEL: response["model"],

{lmnr-0.7.17 → lmnr-0.7.19}/src/lmnr/version.py

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