langwatch 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

langwatch/__version__.py

@@ -1,3 +1,3 @@
 """Version information for LangWatch."""
 
-__version__ = "0.2.16"
+__version__ = "0.2.18"

langwatch/client.py

@@ -1,7 +1,7 @@
 import atexit
 import os
 import logging
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, ClassVar
 
 from langwatch.__version__ import __version__
 from langwatch.attributes import AttributeKey
@@ -14,7 +14,7 @@ from opentelemetry.sdk.resources import Resource
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.trace.sampling import TraceIdRatioBased, ALWAYS_OFF
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
-from opentelemetry.trace import Span
+from opentelemetry.sdk.trace import ReadableSpan
 
 
 from .exporters.filterable_batch_span_exporter import FilterableBatchSpanProcessor
@@ -25,7 +25,7 @@ from .generated.langwatch_rest_api_client import Client as LangWatchApiClient
 import opentelemetry.trace
 from opentelemetry.util._once import Once
 
-logger = logging.getLogger(__name__)
+logger: logging.Logger = logging.getLogger(__name__)
 
 
 class Client(LangWatchClientProtocol):
@@ -33,17 +33,47 @@ class Client(LangWatchClientProtocol):
     Client for the LangWatch tracing SDK.
     """
 
-    _debug: bool = False
-    _api_key: str
-    _endpoint_url: str
-    instrumentors: Sequence[BaseInstrumentor] = []
-    base_attributes: BaseAttributes = {}
-    _disable_sending: bool = False
-    _flush_on_exit: bool = True
-    _span_exclude_rules: List[SpanProcessingExcludeRule] = []
-    _ignore_global_tracer_provider_override_warning: bool = False
-    _skip_open_telemetry_setup: bool = False
-    _rest_api_client: LangWatchApiClient
+    # Class variables - shared across all instances
+    _instance: ClassVar[Optional["Client"]] = None
+    _debug: ClassVar[bool] = False
+    _api_key: ClassVar[str] = ""
+    _endpoint_url: ClassVar[str] = ""
+    _base_attributes: ClassVar[BaseAttributes] = {}
+    _instrumentors: ClassVar[Sequence[BaseInstrumentor]] = ()
+    _disable_sending: ClassVar[bool] = False
+    _flush_on_exit: ClassVar[bool] = True
+    _span_exclude_rules: ClassVar[List[SpanProcessingExcludeRule]] = []  # type: ignore[misc]
+    _ignore_global_tracer_provider_override_warning: ClassVar[bool] = False
+    _skip_open_telemetry_setup: ClassVar[bool] = False
+    _tracer_provider: ClassVar[Optional[TracerProvider]] = None
+    _rest_api_client: ClassVar[Optional[LangWatchApiClient]] = None
+    _registered_instrumentors: ClassVar[
+        dict[opentelemetry.trace.TracerProvider, set[BaseInstrumentor]]
+    ] = {}
+
+    # Regular attributes for protocol compatibility
+    base_attributes: BaseAttributes
+    tracer_provider: Optional[TracerProvider]
+    instrumentors: Sequence[BaseInstrumentor]
+
+    def __new__(
+        cls,
+        api_key: Optional[str] = None,
+        endpoint_url: Optional[str] = None,
+        base_attributes: Optional[BaseAttributes] = None,
+        instrumentors: Optional[Sequence[BaseInstrumentor]] = None,
+        tracer_provider: Optional[TracerProvider] = None,
+        debug: Optional[bool] = None,
+        disable_sending: Optional[bool] = None,
+        flush_on_exit: Optional[bool] = None,
+        span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
+        ignore_global_tracer_provider_override_warning: Optional[bool] = None,
+        skip_open_telemetry_setup: Optional[bool] = None,
+    ) -> "Client":
+        """Ensure only one instance of Client exists (singleton pattern)."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
 
     def __init__(
         self,
@@ -52,12 +82,12 @@ class Client(LangWatchClientProtocol):
         base_attributes: Optional[BaseAttributes] = None,
         instrumentors: Optional[Sequence[BaseInstrumentor]] = None,
         tracer_provider: Optional[TracerProvider] = None,
-        debug: bool = False,
-        disable_sending: bool = False,
-        flush_on_exit: bool = True,
+        debug: Optional[bool] = None,
+        disable_sending: Optional[bool] = None,
+        flush_on_exit: Optional[bool] = None,
         span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
-        ignore_global_tracer_provider_override_warning: bool = False,
-        skip_open_telemetry_setup: bool = False,
+        ignore_global_tracer_provider_override_warning: Optional[bool] = None,
+        skip_open_telemetry_setup: Optional[bool] = None,
     ):
         """
         Initialize the LangWatch tracing client.
@@ -75,87 +105,294 @@ class Client(LangWatchClientProtocol):
                 skip_open_telemetry_setup: Optional. If True, OpenTelemetry setup will be skipped entirely. This is useful when you want to handle OpenTelemetry setup yourself.
         """
 
-        self._api_key = api_key or os.getenv("LANGWATCH_API_KEY", "")
-        self._endpoint_url = (
-            endpoint_url
-            or os.getenv("LANGWATCH_ENDPOINT")
-            or "https://app.langwatch.ai"
-        )
-        self._debug = debug or os.getenv("LANGWATCH_DEBUG") == "true"
-        self._disable_sending = disable_sending
-        self._flush_on_exit = flush_on_exit
-        self._span_exclude_rules = span_exclude_rules or []
-        self._ignore_global_tracer_provider_override_warning = (
-            ignore_global_tracer_provider_override_warning
-        )
-        self._skip_open_telemetry_setup = skip_open_telemetry_setup
-        self.base_attributes = base_attributes or {}
-        self.base_attributes[AttributeKey.LangWatchSDKName] = (
+        # Check if this instance has already been initialized
+        if hasattr(self, "_initialized"):
+            # Instance already exists, update it with new parameters
+            debug_flag = debug or os.getenv("LANGWATCH_DEBUG") == "true"
+            if debug_flag:
+                logger.debug("Updating existing LangWatch client instance")
+
+            # Update via public setters so side-effects run
+            if api_key is not None and api_key != self.api_key:
+                self.api_key = api_key
+            if endpoint_url is not None and endpoint_url != Client._endpoint_url:
+                Client._endpoint_url = endpoint_url
+                if (
+                    not Client._skip_open_telemetry_setup
+                    and not Client._disable_sending
+                ):
+                    self.__shutdown_tracer_provider()
+                    self.__setup_tracer_provider()
+            if debug is not None:
+                Client._debug = debug
+            if (
+                disable_sending is not None
+                and disable_sending != Client._disable_sending
+            ):
+                self.disable_sending = disable_sending
+            if flush_on_exit is not None:
+                Client._flush_on_exit = flush_on_exit
+            if span_exclude_rules is not None:
+                Client._span_exclude_rules = span_exclude_rules
+            if ignore_global_tracer_provider_override_warning is not None:
+                Client._ignore_global_tracer_provider_override_warning = (
+                    ignore_global_tracer_provider_override_warning
+                )
+            if skip_open_telemetry_setup is not None:
+                Client._skip_open_telemetry_setup = skip_open_telemetry_setup
+            if base_attributes is not None:
+                Client._base_attributes = base_attributes
+                # Ensure required SDK attributes remain present after reconfiguration
+                Client._base_attributes[AttributeKey.LangWatchSDKName] = (
+                    "langwatch-observability-sdk"
+                )
+                Client._base_attributes[AttributeKey.LangWatchSDKVersion] = str(
+                    __version__
+                )
+                Client._base_attributes[AttributeKey.LangWatchSDKLanguage] = "python"
+            if instrumentors is not None:
+                Client._instrumentors = instrumentors
+            if tracer_provider is not None:
+                Client._tracer_provider = tracer_provider
+            # Ensure OTEL is configured and instrumentors are registered for the active provider
+            if not Client._skip_open_telemetry_setup:
+                Client._tracer_provider = self.__ensure_otel_setup(
+                    Client._tracer_provider
+                )
+            current_tracer_provider = (
+                Client._tracer_provider or trace.get_tracer_provider()
+            )
+            if current_tracer_provider not in Client._registered_instrumentors:
+                Client._registered_instrumentors[current_tracer_provider] = set()
+            for instrumentor in Client._instrumentors:
+                if (
+                    instrumentor
+                    not in Client._registered_instrumentors[current_tracer_provider]
+                ):
+                    instrumentor.instrument(tracer_provider=current_tracer_provider)
+                    Client._registered_instrumentors[current_tracer_provider].add(
+                        instrumentor
+                    )
+            # Refresh REST client for endpoint/api-key updates
+            self._setup_rest_api_client()
+            return
+
+        # Mark this instance as initialized
+        self._initialized = True
+
+        # Update class variables with provided values or environment defaults
+        if api_key is not None:
+            Client._api_key = api_key
+        elif not Client._api_key:
+            Client._api_key = os.getenv("LANGWATCH_API_KEY", "")
+
+        if endpoint_url is not None:
+            Client._endpoint_url = endpoint_url
+        elif not Client._endpoint_url:
+            Client._endpoint_url = (
+                os.getenv("LANGWATCH_ENDPOINT") or "https://app.langwatch.ai"
+            )
+
+        if debug is not None:
+            Client._debug = debug
+        elif not Client._debug:
+            Client._debug = os.getenv("LANGWATCH_DEBUG") == "true"
+
+        if disable_sending is not None:
+            Client._disable_sending = disable_sending
+
+        if flush_on_exit is not None:
+            Client._flush_on_exit = flush_on_exit
+
+        if span_exclude_rules is not None:
+            Client._span_exclude_rules = span_exclude_rules
+
+        if ignore_global_tracer_provider_override_warning is not None:
+            Client._ignore_global_tracer_provider_override_warning = (
+                ignore_global_tracer_provider_override_warning
+            )
+
+        if skip_open_telemetry_setup is not None:
+            Client._skip_open_telemetry_setup = skip_open_telemetry_setup
+
+        if base_attributes is not None:
+            Client._base_attributes = base_attributes
+        elif not Client._base_attributes:
+            Client._base_attributes = {}
+
+        if instrumentors is not None:
+            Client._instrumentors = instrumentors
+        elif not Client._instrumentors:
+            Client._instrumentors = ()
+
+        if tracer_provider is not None:
+            Client._tracer_provider = tracer_provider
+
+        # Set up base attributes with SDK info
+        Client._base_attributes[AttributeKey.LangWatchSDKName] = (
             "langwatch-observability-sdk"
         )
-        self.base_attributes[AttributeKey.LangWatchSDKVersion] = str(__version__)
-        self.base_attributes[AttributeKey.LangWatchSDKLanguage] = "python"
-
-        if not self._skip_open_telemetry_setup:
-            self.tracer_provider = self.__ensure_otel_setup(tracer_provider)
+        Client._base_attributes[AttributeKey.LangWatchSDKVersion] = str(__version__)
+        Client._base_attributes[AttributeKey.LangWatchSDKLanguage] = "python"
+
+        # Set up OpenTelemetry if not skipped
+        if not Client._skip_open_telemetry_setup:
+            Client._tracer_provider = self.__ensure_otel_setup(Client._tracer_provider)
+        elif Client._debug:
+            logger.debug("Skipping OpenTelemetry setup as requested")
+
+        # Run instrumentors only if they haven't been registered with the current tracer provider
+        current_tracer_provider = Client._tracer_provider or trace.get_tracer_provider()
+        if current_tracer_provider not in Client._registered_instrumentors:
+            Client._registered_instrumentors[current_tracer_provider] = set()
+
+        for instrumentor in Client._instrumentors:
+            if (
+                instrumentor
+                not in Client._registered_instrumentors[current_tracer_provider]
+            ):
+                instrumentor.instrument(tracer_provider=current_tracer_provider)
+                Client._registered_instrumentors[current_tracer_provider].add(
+                    instrumentor
+                )
 
-            self.instrumentors = instrumentors or []
-            for instrumentor in self.instrumentors:
-                instrumentor.instrument(tracer_provider=self.tracer_provider)
-        else:
-            self.tracer_provider = tracer_provider
-            self.instrumentors = instrumentors or []
-            if self._debug:
-                logger.debug("Skipping OpenTelemetry setup as requested")
+        # Initialize instance attributes for protocol compatibility
+        self.base_attributes = (
+            self._base_attributes.copy() if self._base_attributes else {}
+        )
+        self.tracer_provider = self._tracer_provider
+        self.instrumentors = list(self._instrumentors) if self._instrumentors else []
 
         self._setup_rest_api_client()
 
+    @classmethod
+    def _get_instance(cls) -> Optional["Client"]:
+        """Get the singleton instance of the LangWatch client. Internal use only."""
+        return cls._instance
+
+    @classmethod
+    def _create_instance(
+        cls,
+        api_key: Optional[str] = None,
+        endpoint_url: Optional[str] = None,
+        base_attributes: Optional[BaseAttributes] = None,
+        instrumentors: Optional[Sequence[BaseInstrumentor]] = None,
+        tracer_provider: Optional[TracerProvider] = None,
+        debug: Optional[bool] = None,
+        disable_sending: Optional[bool] = None,
+        flush_on_exit: Optional[bool] = True,
+        span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
+        ignore_global_tracer_provider_override_warning: Optional[bool] = None,
+        skip_open_telemetry_setup: Optional[bool] = None,
+    ) -> "Client":
+        """Create or get the singleton instance of the LangWatch client. Internal use only."""
+        if cls._instance is None:
+            cls._instance = cls(
+                api_key=api_key,
+                endpoint_url=endpoint_url,
+                base_attributes=base_attributes,
+                instrumentors=instrumentors,
+                tracer_provider=tracer_provider,
+                debug=debug,
+                disable_sending=disable_sending,
+                flush_on_exit=flush_on_exit,
+                span_exclude_rules=span_exclude_rules,
+                ignore_global_tracer_provider_override_warning=ignore_global_tracer_provider_override_warning,
+                skip_open_telemetry_setup=skip_open_telemetry_setup,
+            )
+        return cls._instance
+
+    @classmethod
+    def _reset_instance(cls) -> None:
+        """Reset the singleton instance. Internal use only, primarily for testing."""
+        if cls._instance is not None:
+            # Shutdown the existing instance if it has a tracer provider
+            if (
+                hasattr(cls._instance, "tracer_provider")
+                and cls._instance.tracer_provider
+            ):
+                cls._instance.__shutdown_tracer_provider()
+            cls._instance = None
+
+        # Reset all class variables to their default values
+        cls._debug = False
+        cls._api_key = ""
+        cls._endpoint_url = ""
+        cls._base_attributes = {}
+        cls._instrumentors = ()
+        cls._disable_sending = False
+        cls._flush_on_exit = True
+        cls._span_exclude_rules = []
+        cls._ignore_global_tracer_provider_override_warning = False
+        cls._skip_open_telemetry_setup = False
+        cls._tracer_provider = None
+        cls._rest_api_client = None
+        cls._registered_instrumentors.clear()
+
+    @classmethod
+    def reset_for_testing(cls) -> None:
+        """Reset the singleton instance for testing purposes."""
+        cls._reset_instance()
+
+    @classmethod
+    def get_singleton_instance(cls) -> Optional["Client"]:
+        """Get the singleton instance for testing purposes."""
+        return cls._instance
+
+    @property
+    def is_initialized(self) -> bool:
+        """Check if this instance has been initialized for testing purposes."""
+        return hasattr(self, "_initialized") and self._initialized
+
     @property
     def debug(self) -> bool:
         """Get the debug flag for the client."""
-        return self._debug
+        return Client._debug
 
     @debug.setter
     def debug(self, value: bool) -> None:
         """Set the debug flag for the client."""
-        self._debug = value
+        Client._debug = value
 
     @property
     def endpoint_url(self) -> str:
         """Get the endpoint URL for the client."""
-        return self._endpoint_url
+        return Client._endpoint_url
 
     @property
     def flush_on_exit(self) -> bool:
         """Get the flush on exit flag for the client."""
-        return self._flush_on_exit
+        return Client._flush_on_exit
 
     @property
     def api_key(self) -> str:
         """Get the API key for the client."""
-        return self._api_key
+        return Client._api_key
 
     @api_key.setter
     def api_key(self, value: str) -> None:
         """Set the API key for the client."""
-        if value == self._api_key:
+        if value == Client._api_key:
             return
 
-        api_key_has_changed = bool(self._api_key)
-
-        self._api_key = value
+        previous_key = Client._api_key
+        Client._api_key = value
 
-        if api_key_has_changed and not self._skip_open_telemetry_setup:
+        if previous_key and not Client._skip_open_telemetry_setup:
             # Shut down any existing tracer provider, as API key change requires re-initialization.
             self.__shutdown_tracer_provider()
 
             # HACK: set global tracer provider to a proxy tracer provider back
-            opentelemetry.trace._TRACER_PROVIDER = None
-            opentelemetry.trace._TRACER_PROVIDER_SET_ONCE = Once()
+            opentelemetry.trace._TRACER_PROVIDER = None  # type: ignore
+            opentelemetry.trace._TRACER_PROVIDER_SET_ONCE = Once()  # type: ignore
 
-            # If a new API key is provided and sending is not disabled, set up a new tracer provider.
-            if value and not self._disable_sending:
-                self.__setup_tracer_provider()
+        # Ensure provider/exporter exist after setting the key
+        if (
+            value
+            and not Client._disable_sending
+            and not Client._skip_open_telemetry_setup
+        ):
+            self.__setup_tracer_provider()
 
         if value:
             self._setup_rest_api_client()
@@ -163,67 +400,71 @@ class Client(LangWatchClientProtocol):
     @property
     def disable_sending(self) -> bool:
         """Get whether sending is disabled."""
-        return self._disable_sending
+        return Client._disable_sending
 
     @property
     def rest_api_client(self) -> LangWatchApiClient:
         """Get the REST API client for the client."""
-        return self._rest_api_client
+        if Client._rest_api_client is None:
+            raise RuntimeError(
+                "REST API client not initialized. Call _setup_rest_api_client() first."
+            )
+        return Client._rest_api_client
 
     @property
     def skip_open_telemetry_setup(self) -> bool:
         """Get whether OpenTelemetry setup is skipped."""
-        return self._skip_open_telemetry_setup
+        return Client._skip_open_telemetry_setup
 
     @disable_sending.setter
     def disable_sending(self, value: bool) -> None:
-        """Set whether sending is disabled. If enabling, this will create a new global tracer provider."""
-        if self._disable_sending == value:
+        """Set whether sending is disabled. Spans are still created; the exporter conditionally drops them."""
+        if Client._disable_sending == value:
             return
 
         # force flush the tracer provider before changing the disable_sending flag
-        if self.tracer_provider and not self._skip_open_telemetry_setup:
-            self.tracer_provider.force_flush()
+        if Client._tracer_provider and not Client._skip_open_telemetry_setup:
+            Client._tracer_provider.force_flush()
 
-        self._disable_sending = value
+        Client._disable_sending = value
 
     def __shutdown_tracer_provider(self) -> None:
         """Shuts down the current tracer provider, including flushing."""
-        if self.tracer_provider:
+        if self._tracer_provider:
             if self._flush_on_exit:
                 try:
                     # Unregister the atexit hook if it was registered.
-                    atexit.unregister(self.tracer_provider.force_flush)
+                    atexit.unregister(self._tracer_provider.force_flush)
                 except ValueError:
                     pass  # Handler was never registered or already unregistered.
 
-            if hasattr(self.tracer_provider, "force_flush") and callable(
-                getattr(self.tracer_provider, "force_flush")
-            ):
+            force_flush = getattr(self._tracer_provider, "force_flush", None)
+            if callable(force_flush):
                 if self._debug:
                     logger.debug("Forcing flush of tracer provider before shutdown.")
-                self.tracer_provider.force_flush()
+                force_flush()
 
-            if self._debug:
+            if Client._debug:
                 logger.debug("Shutting down tracer provider.")
-            self.tracer_provider.shutdown()
-            self.tracer_provider = None
+            if Client._tracer_provider is not None:
+                Client._tracer_provider.shutdown()
+            Client._tracer_provider = None
 
     def __setup_tracer_provider(self) -> None:
         """Sets up the tracer provider if not already active."""
-        if self._skip_open_telemetry_setup:
-            if self._debug:
+        if Client._skip_open_telemetry_setup:
+            if Client._debug:
                 logger.debug("Skipping tracer provider setup as requested.")
             return
 
-        if not self.tracer_provider:
-            if self._debug:
+        if not Client._tracer_provider:
+            if Client._debug:
                 logger.debug("Setting up new tracer provider.")
-            self.tracer_provider = self.__ensure_otel_setup()
+            Client._tracer_provider = self.__ensure_otel_setup()
 
             return
 
-        if self._debug:
+        if Client._debug:
             logger.debug("Tracer provider already active, not setting up again.")
 
     def __ensure_otel_setup(
@@ -239,34 +480,43 @@ class Client(LangWatchClientProtocol):
                 trace.set_tracer_provider(settable_tracer_provider)
                 return settable_tracer_provider
 
-            if not self._ignore_global_tracer_provider_override_warning:
-                logger.warning(
-                    "An existing global trace provider was found. LangWatch will not override it automatically, but instead is attaching another span processor and exporter to it. You can disable this warning by setting `ignore_global_tracer_provider_override_warning` to `True`."
-                )
-            self.__set_langwatch_exporter(settable_tracer_provider)
-
-            return settable_tracer_provider
+            if isinstance(global_provider, TracerProvider):
+                if not self._ignore_global_tracer_provider_override_warning:
+                    logger.warning(
+                        "An existing global tracer provider was found. Attaching LangWatch exporter to the existing provider. Set `ignore_global_tracer_provider_override_warning=True` to suppress this warning."
+                    )
+                self.__set_langwatch_exporter(global_provider)
+                return global_provider
+            else:
+                if Client._debug:
+                    logger.debug(
+                        "Global tracer provider is not an SDK TracerProvider; creating/using a new provider for LangWatch exporter."
+                    )
+                self.__set_langwatch_exporter(settable_tracer_provider)
+                return settable_tracer_provider
 
         except Exception as e:
             raise RuntimeError(
-                f"Failed to setup OpenTelemetry tracer provider: {str(e)}"
+                f"Failed to setup OpenTelemetry tracer provider: {e}"
             ) from e
 
     def __create_new_tracer_provider(self) -> TracerProvider:
         try:
-            resource = Resource.create(self.base_attributes)
-            sampler = ALWAYS_OFF if self._disable_sending else TraceIdRatioBased(1.0)
+            resource = Resource.create(Client._base_attributes)
+            sampler = ALWAYS_OFF if Client._disable_sending else TraceIdRatioBased(1.0)
             provider = TracerProvider(resource=resource, sampler=sampler)
 
-            self.__set_langwatch_exporter(provider)
+            # Only set up LangWatch exporter if sending is not disabled
+            if not Client._disable_sending:
+                self.__set_langwatch_exporter(provider)
 
-            if self._flush_on_exit:
+            if Client._flush_on_exit:
                 logger.info(
                     "Registering atexit handler to flush tracer provider on exit"
                 )
                 atexit.register(provider.force_flush)
 
-            if self.debug:
+            if Client._debug:
                 logger.info(
                     "Successfully configured tracer provider with OTLP exporter"
                 )
@@ -274,25 +524,25 @@ class Client(LangWatchClientProtocol):
             return provider
         except Exception as e:
             raise RuntimeError(
-                f"Failed to create and configure tracer provider: {str(e)}"
+                f"Failed to create and configure tracer provider: {e}"
             ) from e
 
     def __set_langwatch_exporter(self, provider: TracerProvider) -> None:
-        if not self.api_key:
+        if not Client._api_key:
             raise ValueError("LangWatch API key is required but not provided")
 
         headers = {
-            "Authorization": f"Bearer {self.api_key}",
+            "Authorization": f"Bearer {Client._api_key}",
             "X-LangWatch-SDK-Version": str(__version__),
         }
 
-        if self.debug:
+        if Client._debug:
             logger.info(
-                f"Configuring OTLP exporter with endpoint: {self._endpoint_url}/api/otel/v1/traces"
+                f"Configuring OTLP exporter with endpoint: {Client._endpoint_url}/api/otel/v1/traces"
             )
 
         otlp_exporter = OTLPSpanExporter(
-            endpoint=f"{self._endpoint_url}/api/otel/v1/traces",
+            endpoint=f"{Client._endpoint_url}/api/otel/v1/traces",
             headers=headers,
             timeout=int(os.getenv("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT", 30)),
         )
@@ -304,7 +554,7 @@ class Client(LangWatchClientProtocol):
 
         processor = FilterableBatchSpanProcessor(
             span_exporter=conditional_exporter,
-            exclude_rules=self._span_exclude_rules,
+            exclude_rules=Client._span_exclude_rules,
             max_export_batch_size=int(os.getenv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", 100)),
             max_queue_size=int(os.getenv("OTEL_BSP_MAX_QUEUE_SIZE", 512)),
             schedule_delay_millis=float(os.getenv("OTEL_BSP_SCHEDULE_DELAY", 1000)),
@@ -316,20 +566,20 @@ class Client(LangWatchClientProtocol):
         """
         Sets up the REST API client for the client.
         """
-        self._rest_api_client = LangWatchApiClient(
-            base_url=self._endpoint_url,
-            headers={"X-Auth-Token": self._api_key},
+        Client._rest_api_client = LangWatchApiClient(
+            base_url=Client._endpoint_url,
+            headers={"X-Auth-Token": Client._api_key},
             raise_on_unexpected_status=True,
         )
 
-        return self._rest_api_client
+        return Client._rest_api_client
 
 
 class ConditionalSpanExporter(SpanExporter):
     def __init__(self, wrapped_exporter: SpanExporter):
-        self.wrapped_exporter = wrapped_exporter
+        self.wrapped_exporter: SpanExporter = wrapped_exporter
 
-    def export(self, spans: Sequence[Span]) -> SpanExportResult:
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         # Check your singleton's disable flag
         client = get_instance()
         if client and client.disable_sending:
@@ -342,8 +592,10 @@ class ConditionalSpanExporter(SpanExporter):
     def shutdown(self) -> None:
         return self.wrapped_exporter.shutdown()
 
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
+    def force_flush(self, timeout_millis: Optional[int] = 30000) -> bool:
         client = get_instance()
         if client and client.disable_sending:
             return True  # Nothing to flush
-        return self.wrapped_exporter.force_flush(timeout_millis)
+        # Handle None case by providing default value
+        actual_timeout = timeout_millis if timeout_millis is not None else 30000
+        return self.wrapped_exporter.force_flush(actual_timeout)

langwatch/evaluations.py

@@ -7,7 +7,7 @@ from deprecated import deprecated
 import httpx
 import langwatch
 from langwatch.domain import SpanTimestamps
-import nanoid
+from pksuid import PKSUID
 from langwatch.telemetry.span import LangWatchSpan
 from langwatch.telemetry.context import get_current_span
 from langwatch.state import get_api_key, get_endpoint, get_instance
@@ -424,7 +424,7 @@ def _add_evaluation(  # type: ignore
             span_id = format(span_ctx.span_id, "x")
 
         evaluation = Evaluation(
-            evaluation_id=evaluation_id or f"eval_{nanoid.generate()}",
+            evaluation_id=evaluation_id or str(PKSUID("eval")),
             span_id=span_id,
             name=name,
             type=type,

langwatch/litellm.py

@@ -14,7 +14,6 @@ from typing import (
 from langwatch.tracer import (
     ContextSpan,
     ContextTrace,
-    get_current_span,
     get_current_trace,
 )
 
@@ -122,10 +121,7 @@ class LiteLLMPatch:
         if not trace or trace not in self.tracked_traces:
             return await cast(Any, self.client)._original_acompletion(*args, **kwargs)
 
-        span = trace.span(
-            type="llm",
-            parent=get_current_span(),
-        ).__enter__()
+        span = trace.span(type="llm").__enter__()
 
         started_at = milliseconds_timestamp()
 

langwatch/openai.py

@@ -18,7 +18,6 @@ from langwatch.utils.capture import (
     capture_chunks_with_timings_and_reyield,
 )
 from langwatch.utils.utils import milliseconds_timestamp, safe_get
-import nanoid
 from langwatch.telemetry.span import LangWatchSpan
 from langwatch.telemetry.tracing import LangWatchTrace
 
@@ -65,9 +64,7 @@ class OpenAITracer:
         if trace:
             self.trace = trace
         else:
-            self.trace = ContextTrace(
-                trace_id=trace_id or nanoid.generate(), metadata=metadata
-            )
+            self.trace = ContextTrace()
         self.completion_tracer = OpenAICompletionTracer(client=client, trace=self.trace)
         self.chat_completion_tracer = OpenAIChatCompletionTracer(
             client=client, trace=self.trace
@@ -123,9 +120,7 @@ class OpenAICompletionTracer:
         if trace:
             self.trace = trace
         else:
-            self.trace = ContextTrace(
-                trace_id=trace_id or nanoid.generate(), metadata=metadata
-            )
+            self.trace = ContextTrace()
         self.tracked_traces.add(self.trace)
 
         if not hasattr(self.client.completions, "_original_create"):
@@ -155,10 +150,7 @@ class OpenAICompletionTracer:
         if not trace or trace not in self.tracked_traces:
             return cast(Any, self.client.completions)._original_create(*args, **kwargs)
 
-        span = trace.span(
-            type="llm",
-            parent=trace.get_current_span(),
-        ).__enter__()
+        span = trace.span(type="llm").__enter__()
 
         started_at = milliseconds_timestamp()
         try:
@@ -214,10 +206,7 @@ class OpenAICompletionTracer:
                 *args, **kwargs
             )
 
-        span = trace.span(
-            type="llm",
-            parent=trace.get_current_span(),
-        ).__enter__()
+        span = trace.span(type="llm").__enter__()
 
         started_at = milliseconds_timestamp()
         response: Union[Completion, AsyncStream[Completion]] = await cast(
@@ -403,9 +392,7 @@ class OpenAIChatCompletionTracer:
         if trace:
             self.trace = trace
         else:
-            self.trace = ContextTrace(
-                trace_id=trace_id or nanoid.generate(), metadata=metadata
-            )
+            self.trace = ContextTrace()
         self.tracked_traces.add(self.trace)
 
         if not hasattr(self.client.chat.completions, "_original_create"):
@@ -560,7 +547,7 @@ class OpenAIChatCompletionTracer:
                 delta = choice.delta
                 if delta.role:
                     chat_message: ChatMessage = {
-                        "role": delta.role,
+                        "role": delta.role,  # type: ignore
                         "content": delta.content,
                     }
                     if delta.function_call:

langwatch/telemetry/__tests__/test_tracing.py

@@ -0,0 +1,48 @@
+import pytest
+from langwatch.telemetry.tracing import LangWatchTrace
+
+
+def test_metadata_initialization_and_update_merge():
+    # Initial metadata
+    trace = LangWatchTrace(metadata={"foo": 1, "bar": 2})
+    assert trace.metadata == {"foo": 1, "bar": 2}
+
+    # Update with new metadata (should merge, not replace)
+    trace.update(metadata={"baz": 3, "foo": 42})
+    # 'foo' should be overwritten, 'bar' should remain, 'baz' should be added
+    assert trace.metadata == {"foo": 42, "bar": 2, "baz": 3}
+
+    # Update with metadata=None (should not clear metadata)
+    trace.update(metadata=None)
+    assert trace.metadata == {"foo": 42, "bar": 2, "baz": 3}
+
+    # Update with another dict
+    trace.update(metadata={"new": "val"})
+    assert trace.metadata == {"foo": 42, "bar": 2, "baz": 3, "new": "val"}
+
+
+def test_metadata_on_root_span():
+    # Create trace with metadata and root span
+    trace = LangWatchTrace(metadata={"a": 1, "b": 2})
+    with trace:
+        trace.update(metadata={"b": 3, "c": 4})
+        # The root span's metadata attribute should match the merged metadata
+        root_metadata = trace.root_span._span.attributes.get("metadata")
+        import json
+
+        assert json.loads(root_metadata) == {"a": 1, "b": 3, "c": 4}
+
+
+def test_metadata_not_lost_on_multiple_updates():
+    trace = LangWatchTrace(metadata={"x": 1})
+    trace.update(metadata={"y": 2})
+    trace.update(metadata={"z": 3})
+    assert trace.metadata == {"x": 1, "y": 2, "z": 3}
+
+    # Overwrite a key
+    trace.update(metadata={"y": 99})
+    assert trace.metadata == {"x": 1, "y": 99, "z": 3}
+
+    # None update should not clear
+    trace.update(metadata=None)
+    assert trace.metadata == {"x": 1, "y": 99, "z": 3}

langwatch/telemetry/context.py

@@ -1,8 +1,9 @@
 import threading
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Dict, List
 import contextvars
 import warnings
 from opentelemetry import trace as trace_api
+from opentelemetry import context
 
 from langwatch.utils.initialization import ensure_setup
 
@@ -44,7 +45,19 @@ def get_current_trace(
 
     trace = LangWatchTrace()
     if start_if_none:
-        return trace.__enter__()
+        otel_span = trace_api.get_current_span()
+        otel_span_id = otel_span.get_span_context().span_id
+        trace.__enter__()
+
+        # Keep the previous span in the context if we are starting a new trace not at root level
+        if otel_span_id != 0:
+            ctx = trace_api.set_span_in_context(otel_span)
+            context.attach(ctx)
+        otel_span = trace_api.get_current_span()
+
+        trace.__exit__(None, None, None)
+
+        return trace
     return trace
 
 
@@ -57,20 +70,20 @@ def get_current_span() -> "LangWatchSpan":
     """
     ensure_setup()
 
-    # First try getting from LangWatch context
-    span = stored_langwatch_span.get(None)
-    if span is not None:
-        return span
-
-    if _is_on_child_thread() and len(main_thread_langwatch_span) > 0:
-        return main_thread_langwatch_span[-1]
-
-    # Fall back to OpenTelemetry context
     otel_span = trace_api.get_current_span()
-    trace = get_current_trace()
+    otel_span_id = otel_span.get_span_context().span_id
+
+    # If on a child thread and there is no parent, try to find a parent from the main thread
+    if (
+        _is_on_child_thread()
+        and len(main_thread_langwatch_span) > 0
+        and otel_span_id == 0
+    ):
+        return main_thread_langwatch_span[-1]
 
     from langwatch.telemetry.span import LangWatchSpan
 
+    trace = get_current_trace()
     return LangWatchSpan.wrap_otel_span(otel_span, trace)
 
 
@@ -91,11 +104,8 @@ def _set_current_span(span: "LangWatchSpan"):
     if not _is_on_child_thread():
         main_thread_langwatch_span.append(span)
 
-    try:
-        return stored_langwatch_span.set(span)
-    except Exception as e:
-        warnings.warn(f"Failed to set LangWatch span context: {e}")
-        return None
+    # Dummy token, just for the main thread span list
+    return "token"
 
 
 def _reset_current_trace(token: contextvars.Token):
@@ -112,19 +122,12 @@ def _reset_current_trace(token: contextvars.Token):
             warnings.warn(f"Failed to reset LangWatch trace context: {e}")
 
 
-def _reset_current_span(token: contextvars.Token):
+def _reset_current_span(_token: str):
     global main_thread_langwatch_span
     if not _is_on_child_thread():
         if len(main_thread_langwatch_span) > 0:
             main_thread_langwatch_span.pop()
 
-    try:
-        stored_langwatch_span.reset(token)
-    except Exception as e:
-        # Only warn if it's not a context error
-        if "different Context" not in str(e):
-            warnings.warn(f"Failed to reset LangWatch span context: {e}")
-
 
 def _is_on_child_thread() -> bool:
     return threading.current_thread() != threading.main_thread()

langwatch/telemetry/tracing.py

@@ -12,6 +12,7 @@ from langwatch.utils.transformation import (
 )
 from opentelemetry import trace as trace_api
 from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.trace import Link
 from typing import (
     Dict,
     List,
@@ -214,6 +215,19 @@ class LangWatchTrace:
                     root_span_params["timestamps"], cls=SerializableWithStringFallback
                 )
 
+            # Check if we're creating this trace within an existing OpenTelemetry trace context
+            current_span = trace_api.get_current_span()
+            if current_span.get_span_context().is_valid:
+                # Add link to current span
+                links = root_span_params.get("links", [])
+                links.append(
+                    Link(
+                        current_span.get_span_context(),
+                        {"relationship": "parent_trace"},
+                    )
+                )
+                root_span_params["links"] = links
+
             self.root_span = LangWatchSpan(trace=self, **root_span_params)
             self.root_span.__enter__()
             context = self.root_span.get_span_context()
@@ -477,6 +491,7 @@ class LangWatchTrace:
 
             @functools.wraps(func)
             async def wrapper(*args: Any, **kwargs: Any) -> Any:
+                # Always create a new trace, but it will be nested if there's already a current trace
                 async with self._clone() as trace:
                     trace._set_callee_input_information(func, *args, **kwargs)
                     items = []
@@ -496,6 +511,7 @@ class LangWatchTrace:
 
             @functools.wraps(func)
             def wrapper(*args: Any, **kwargs: Any) -> Any:
+                # Always create a new trace, but it will be nested if there's already a current trace
                 with self._clone() as trace:
                     trace._set_callee_input_information(func, *args, **kwargs)
                     items = []
@@ -515,6 +531,7 @@ class LangWatchTrace:
 
             @functools.wraps(func)
             async def wrapper(*args: Any, **kwargs: Any) -> Any:
+                # Always create a new trace, but it will be nested if there's already a current trace
                 async with self._clone() as trace:
                     trace._set_callee_input_information(func, *args, **kwargs)
                     output = await func(*args, **kwargs)
@@ -526,6 +543,7 @@ class LangWatchTrace:
 
             @functools.wraps(func)
             def wrapper(*args: Any, **kwargs: Any) -> Any:
+                # Create new trace
                 with self._clone() as trace:
                     trace._set_callee_input_information(func, *args, **kwargs)
                     output = func(*args, **kwargs)

langwatch/types.py

@@ -1,6 +1,6 @@
 """Common types and protocols for LangWatch."""
 
-from typing import Protocol
+from typing import Protocol, Optional, Sequence, List
 from langwatch.domain import (
     BaseAttributes,
     AttributeValue,
@@ -28,11 +28,16 @@ from langwatch.domain import (
     SpanInputOutput,
     SpanTimestamps,
     TraceMetadata,
+    SpanProcessingExcludeRule,
 )
 from .generated.langwatch_rest_api_client import Client as LangWatchRestApiClient
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+
 
 class LangWatchClientProtocol(Protocol):
     """Protocol defining the required interface for LangWatch client instances."""
+
     @property
     def endpoint_url(self) -> str:
         """Get the endpoint URL for the client."""
@@ -79,6 +84,17 @@ class LangWatchClientProtocol(Protocol):
         """Get the REST API client for the client."""
         ...
 
+    @property
+    def skip_open_telemetry_setup(self) -> bool:
+        """Get whether OpenTelemetry setup is skipped."""
+        ...
+
+    # Regular attributes (not properties)
+    base_attributes: BaseAttributes
+    tracer_provider: Optional[TracerProvider]
+    instrumentors: Sequence[BaseInstrumentor]
+    _span_exclude_rules: List[SpanProcessingExcludeRule]
+
 
 __all__ = [
     "BaseAttributes",

langwatch/utils/initialization.py

@@ -11,14 +11,17 @@ from langwatch.state import get_instance, set_instance
 from langwatch.client import Client
 from langwatch.domain import BaseAttributes, SpanProcessingExcludeRule
 
-logger = logging.getLogger(__name__)
+logger: logging.Logger = logging.getLogger(__name__)
+
 
 def _setup_logging(debug: bool = False) -> None:
     """Configure logging for LangWatch."""
     root_logger = logging.getLogger("langwatch")
     if not root_logger.handlers:
         handler = logging.StreamHandler(sys.stdout)
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
         handler.setFormatter(formatter)
         root_logger.addHandler(handler)
 
@@ -27,14 +30,16 @@ def _setup_logging(debug: bool = False) -> None:
     else:
         root_logger.setLevel(logging.INFO)
 
+
 def setup(
     api_key: Optional[str] = None,
     endpoint_url: Optional[str] = None,
     base_attributes: Optional[BaseAttributes] = None,
     tracer_provider: Optional[TracerProvider] = None,
     instrumentors: Optional[Sequence[BaseInstrumentor]] = None,
-    span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = [],
-    debug: bool = False,
+    span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
+    debug: Optional[bool] = None,
+    skip_open_telemetry_setup: Optional[bool] = None,
 ) -> Client:
     """
     Initialize the LangWatch client.
@@ -47,23 +52,30 @@ def setup(
         instrumentors: The instrumentors for the LangWatch client.
         span_exclude_rules: Optional. A list of rules that will be applied to spans processed by the exporter.
         debug: Whether to enable debug logging for the LangWatch client.
-
+        skip_open_telemetry_setup: Whether to skip setting up the OpenTelemetry tracer provider. If this is skipped, instrumentors will be added to the global tracer provider.
     Returns:
         The LangWatch client.
     """
-    _setup_logging(debug)
+    _setup_logging(debug or False)
 
     if debug:
         logger.info("Setting up LangWatch client...")
 
-    # TODO: get rid of this
+    # Get existing client to check if we're changing the API key
+    existing_client = get_instance()
     changed_api_key = False
-    if get_instance() is not None and api_key != get_instance().api_key:
-        logger.warning("LangWatch was already setup before, and now it is being setup with a new API key. This will nuke the previous tracing providers. This is not recommended.")
-        # Set the new API key on the current client to make sure, triggering a nuke of the previous tracing providers too
-        get_instance().api_key = api_key
+
+    if (
+        existing_client is not None
+        and api_key is not None
+        and api_key != existing_client.api_key
+    ):
+        logger.warning(
+            "LangWatch was already setup before, and now it is being setup with a new API key. This will nuke the previous tracing providers. This is not recommended."
+        )
         changed_api_key = True
 
+    # Create or update the client (singleton pattern handles the rest)
     client = Client(
         api_key=api_key,
         endpoint_url=endpoint_url,
@@ -73,14 +85,17 @@ def setup(
         debug=debug,
         span_exclude_rules=span_exclude_rules,
         ignore_global_tracer_provider_override_warning=changed_api_key,
+        skip_open_telemetry_setup=skip_open_telemetry_setup,
     )
 
     if debug:
         logger.info("LangWatch client setup complete")
 
+    # Update the state module to track the instance
     set_instance(client)
     return client
 
+
 def ensure_setup(api_key: Optional[str] = None) -> None:
     """Ensure LangWatch client is setup.
 
@@ -90,13 +105,13 @@ def ensure_setup(api_key: Optional[str] = None) -> None:
     client = get_instance()
     if client is None:
         logger.debug("No LangWatch client found, creating default client")
-        client = setup(debug=True, api_key=api_key)  # Enable debug logging for auto-created clients
+        client = setup(
+            debug=True,
+            api_key=api_key,
+        )  # Enable debug logging for auto-created clients
 
     # Verify we have a valid tracer provider
     tracer_provider = trace.get_tracer_provider()
-    if tracer_provider is None: # type: ignore
-        logger.warning("No tracer provider found, creating new one")
-        client = setup(debug=True, api_key=api_key)
-    elif isinstance(tracer_provider, trace.ProxyTracerProvider):
+    if isinstance(tracer_provider, trace.ProxyTracerProvider):
         logger.debug("Found proxy tracer provider, will be replaced with real provider")
         # This is fine - the client will replace it with a real provider

{langwatch-0.2.16.dist-info → langwatch-0.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch
-Version: 0.2.16
+Version: 0.2.18
 Summary: LangWatch Python SDK, for monitoring your LLMs
 Author-email: Langwatch Engineers <engineering@langwatch.ai>
 License: MIT
@@ -28,6 +28,7 @@ Requires-Dist: opentelemetry-api>=1.32.1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.32.1
 Requires-Dist: opentelemetry-instrumentation-crewai>=0.45.0
 Requires-Dist: opentelemetry-sdk>=1.32.1
+Requires-Dist: pksuid>=1.1.2
 Requires-Dist: pydantic>=2
 Requires-Dist: python-liquid>=2.0.2
 Requires-Dist: retry>=0.9.2

{langwatch-0.2.16.dist-info → langwatch-0.2.18.dist-info}/RECORD

@@ -1,18 +1,18 @@
 langwatch/__init__.py,sha256=OX8vN2-VFNUqRo9mJC8LUjHGMKYSRTwmzUQj_sKAVXQ,4210
-langwatch/__version__.py,sha256=zBSlISkVLNMQm4p_0afBBJuscq6Fwt88EDKwt5vf9_I,65
+langwatch/__version__.py,sha256=HHZMUDcvD8rFyW1uyw1zA9mutRi3pSZ0g7D2KwclJ6A,65
 langwatch/attributes.py,sha256=nXdI_G85wQQCAdAcwjCiLYdEYj3wATmfgCmhlf6dVIk,3910
 langwatch/batch_evaluation.py,sha256=piez7TYqUZPb9NlIShTuTPmSzrZqX-vm2Grz_NGXe04,16078
-langwatch/client.py,sha256=9mLnGOZsVjwQ8AMp0f-J8-nNtg5EPXGkaQ4m8Jck3ew,14197
-langwatch/evaluations.py,sha256=U8zMVbn0FmsUuUGiQ-XfmIejNjKY3oW9V4ymAFS8tDw,16828
+langwatch/client.py,sha256=WTNcYSik7kZ2kH-qGDnhbMTosc8e_Xhab_lZlfh5TC8,25559
+langwatch/evaluations.py,sha256=6JYaChMoG2oVvHRtZEVzn2xNxQIZr1nUFfHffm6Rfp0,16832
 langwatch/guardrails.py,sha256=4d320HyklXPUVszF34aWsDKGzuvPggcDM_f45_eJTnc,1352
 langwatch/langchain.py,sha256=nUuV5puASRs66kSW05i9tCRy09st5m_6uy9FYR672Zg,18658
-langwatch/litellm.py,sha256=iJ11wdMfNN1zeX99VSSpxoExl6dW1fmk3GPKDAtONbQ,12082
+langwatch/litellm.py,sha256=mPcw5cLykt0SQf9bTNSoT7elMx4gj-wZ_K2PC14Bw50,11998
 langwatch/login.py,sha256=Wm8Vs7zxJNeGEPO7s_wSQN2DYObteDg56HcyluhTobw,896
-langwatch/openai.py,sha256=vKlzSQ7vJ2j0jZdWDT8iByUoxgPLlaBdnQaktbohrgg,25534
+langwatch/openai.py,sha256=h_NCIwJ0qs57PS-R7gQZsnf2_EBAahlYQMuqS9-Cj3Q,25139
 langwatch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langwatch/state.py,sha256=qXvPAjO90jdokCU6tPSwjHIac4QU_5N0pSd9dfmc9kY,1204
 langwatch/tracer.py,sha256=t5FOdP1es9H_pPGqGUBLXCyEln0tTi4m4M9b6WxCrPU,975
-langwatch/types.py,sha256=DkZThS7ptUY0_Ao7PNO6ZGBE9Qj0YmJf5auRkq2Cphw,2570
+langwatch/types.py,sha256=h6r3tNTzWqENx-9j_JPmOMZfFoKq9SNpEtxpAACk2G0,3114
 langwatch/dataset/__init__.py,sha256=hZBcbjXuBO2qE5osJtd9wIE9f45F6-jpNTrne5nk4eE,2606
 langwatch/domain/__init__.py,sha256=luuin3-6mmMqDaOJE_1wb7M1ccjhhZL80UN0TBA_TXM,6040
 langwatch/dspy/__init__.py,sha256=E9rqyhOyIO3E-GxJSZlHtsvjapFjKQGF85QRcpKSvKE,34280
@@ -396,18 +396,19 @@ langwatch/prompts/service.py,sha256=CiVuW1y8sYti05jaYSNk40miCg2Q0bA2FSC3iVoM5_o,
 langwatch/prompts/types.py,sha256=0SPb-jfcndvay53PMpuHvtCrIptT-h-eo-9EHM-grl4,654
 langwatch/prompts/decorators/prompt_service_tracing.py,sha256=ELrQ9bd3nPurbUXX2K_CN-2zWE00nqjXObs9Gkp4eVg,2309
 langwatch/prompts/decorators/prompt_tracing.py,sha256=Q3-RM8G-PHkBjVKntSg3c8H2o0P1bpO3UbR3uRgbke0,3182
-langwatch/telemetry/context.py,sha256=ixKvTBZADFuWglFCK95r8bF4-f-iq_WixzC4ydirCE8,3888
+langwatch/telemetry/context.py,sha256=q0hUG9PM3aifIr6ZRuuNNbsGtcAImu9Pv2XTKUp3CGc,4029
 langwatch/telemetry/sampling.py,sha256=XDf6ZoXiwpHaHDYd_dDszSqH8_9-CHFNsGAZWOW1VYk,1327
 langwatch/telemetry/span.py,sha256=g-RGWfQk4Q3b2TpipiHqjEV7rwmidaUHp54q51UxQ6s,32801
-langwatch/telemetry/tracing.py,sha256=uOrJoHScKJcJjV2OqarhmfXMWB8yKK4L16wsQsicL6I,26672
+langwatch/telemetry/tracing.py,sha256=oyCAqW-9sFFRYPWy9epZVN0aNvqToRY4_PGxQAtS-dI,27622
 langwatch/telemetry/types.py,sha256=Q9H7nT3GMK1aluRB7CCX8BR7VFKrQY_vdFdyF4Yc98U,501
+langwatch/telemetry/__tests__/test_tracing.py,sha256=mD_SAO-dD5m81EVQ909AwGROnnofxuL3DXCoaUTrS3M,1710
 langwatch/utils/__init__.py,sha256=3rqQTgzEtmICJW_KSPuLa5q8p5udxt5SRi28Z2vZB10,138
 langwatch/utils/capture.py,sha256=uVKPqHCm-o8CpabsUfhqbNFr5sgUHzcKnBadvL2oIwI,1172
 langwatch/utils/exceptions.py,sha256=J2_0EZ_GMRTJvCQ-ULX4LOG63r1R-0TCbKg9sskgl5A,498
-langwatch/utils/initialization.py,sha256=LOmGCiox7JRiHprnB04AdO8BhUggZtRbWgBPF9mqR5s,4047
+langwatch/utils/initialization.py,sha256=ReDpEtjenCoRfc02YuIBK8KVjAwXx3N8yf9dyPgTOP0,4378
 langwatch/utils/module.py,sha256=KLBNOK3mA9gCSifCcQX_lOtU48BJQDWvFKtF6NMvwVA,688
 langwatch/utils/transformation.py,sha256=5XUnW7Oz8Ck9EMsKeKeoDOrIw3EXpLGMk_fMSeA0Zng,7216
 langwatch/utils/utils.py,sha256=ZCOSie4o9LdJ7odshNfCNjmgwgQ27ojc5ENqt1rXuSs,596
-langwatch-0.2.16.dist-info/METADATA,sha256=OYg6R9Xvlpydm4Zb3GUc7yFFfrLOwBLvgff0b_jzy0c,13095
-langwatch-0.2.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langwatch-0.2.16.dist-info/RECORD,,
+langwatch-0.2.18.dist-info/METADATA,sha256=23XS5hHgnh3_4eEXv3v6rX7Yj6uxfBdfbjm5nLnvpD4,13124
+langwatch-0.2.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langwatch-0.2.18.dist-info/RECORD,,