lmnr 0.4.65__py3-none-any.whl → 0.5.0__py3-none-any.whl

lmnr/__init__.py

@@ -1,12 +1,18 @@
+from .sdk.client.synchronous.sync_client import LaminarClient
+from .sdk.client.asynchronous.async_client import AsyncLaminarClient
 from .sdk.datasets import EvaluationDataset, LaminarDataset
 from .sdk.evaluations import evaluate
 from .sdk.laminar import Laminar
 from .sdk.types import (
+    AgentOutput,
+    FinalOutputChunkContent,
     ChatMessage,
     HumanEvaluator,
     NodeInput,
     PipelineRunError,
     PipelineRunResponse,
+    RunAgentResponseChunk,
+    StepChunkContent,
     TracingLevel,
 )
 from .sdk.decorators import observe
@@ -14,3 +20,27 @@ from .sdk.types import LaminarSpanContext
 from .openllmetry_sdk import Instruments
 from .openllmetry_sdk.tracing.attributes import Attributes
 from opentelemetry.trace import use_span
+
+__all__ = [
+    "AgentOutput",
+    "AsyncLaminarClient",
+    "Attributes",
+    "ChatMessage",
+    "EvaluationDataset",
+    "FinalOutputChunkContent",
+    "HumanEvaluator",
+    "Instruments",
+    "Laminar",
+    "LaminarClient",
+    "LaminarDataset",
+    "LaminarSpanContext",
+    "NodeInput",
+    "PipelineRunError",
+    "PipelineRunResponse",
+    "RunAgentResponseChunk",
+    "StepChunkContent",
+    "TracingLevel",
+    "evaluate",
+    "observe",
+    "use_span",
+]

lmnr/openllmetry_sdk/__init__.py

@@ -16,7 +16,7 @@ from lmnr.openllmetry_sdk.tracing.tracing import TracerWrapper
 from typing import Dict
 
 
-class Traceloop:
+class TracerManager:
     __tracer_wrapper: TracerWrapper
 
     @staticmethod
@@ -44,17 +44,6 @@ class Traceloop:
         if isinstance(headers, str):
             headers = parse_env_headers(headers)
 
-        if (
-            not exporter
-            and not processor
-            and api_endpoint == "https://api.lmnr.ai"
-            and not api_key
-        ):
-            print(
-                "Set the LMNR_PROJECT_API_KEY environment variable to your project API key"
-            )
-            return
-
         if api_key and not exporter and not processor and not headers:
             headers = {
                 "Authorization": f"Bearer {api_key}",
@@ -65,7 +54,7 @@ class Traceloop:
         TracerWrapper.set_static_params(
             resource_attributes, enable_content_tracing, api_endpoint, headers
         )
-        Traceloop.__tracer_wrapper = TracerWrapper(
+        TracerManager.__tracer_wrapper = TracerWrapper(
             disable_batch=disable_batch,
             processor=processor,
             propagator=propagator,
@@ -79,5 +68,5 @@ class Traceloop:
 
     @staticmethod
     def flush():
-        if Traceloop.__tracer_wrapper:
-            Traceloop.__tracer_wrapper.flush()
+        if getattr(TracerManager, "__tracer_wrapper", None):
+            TracerManager.__tracer_wrapper.flush()

lmnr/openllmetry_sdk/tracing/attributes.py

@@ -9,7 +9,6 @@ SPAN_IDS_PATH = "lmnr.span.ids_path"
 SPAN_INSTRUMENTATION_SOURCE = "lmnr.span.instrumentation_source"
 SPAN_SDK_VERSION = "lmnr.span.sdk_version"
 SPAN_LANGUAGE_VERSION = "lmnr.span.language_version"
-OVERRIDE_PARENT_SPAN = "lmnr.internal.override_parent_span"
 
 ASSOCIATION_PROPERTIES = "lmnr.association.properties"
 SESSION_ID = "session_id"

lmnr/openllmetry_sdk/tracing/tracing.py

@@ -4,6 +4,8 @@ import logging
 import uuid
 
 from contextvars import Context
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.openllmetry_sdk.instruments import Instruments
 from lmnr.openllmetry_sdk.tracing.attributes import (
@@ -41,7 +43,7 @@ from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 
 from typing import Dict, Optional, Set
 
-from lmnr.version import SDK_VERSION, PYTHON_VERSION
+from lmnr.version import __version__, PYTHON_VERSION
 
 module_logger = logging.getLogger(__name__)
 console_log_handler = logging.StreamHandler()
@@ -80,6 +82,8 @@ class TracerWrapper(object):
     __logger: logging.Logger = None
     __span_id_to_path: dict[int, list[str]] = {}
     __span_id_lists: dict[int, list[str]] = {}
+    __client: LaminarClient = None
+    __async_client: AsyncLaminarClient = None
 
     def __new__(
         cls,
@@ -99,6 +103,15 @@ class TracerWrapper(object):
             if not TracerWrapper.endpoint:
                 return obj
 
+            obj.__client = LaminarClient(
+                base_url=base_http_url,
+                project_api_key=project_api_key,
+            )
+            obj.__async_client = AsyncLaminarClient(
+                base_url=base_http_url,
+                project_api_key=project_api_key,
+            )
+
             obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
             obj.__tracer_provider = init_tracer_provider(resource=obj.__resource)
             if processor:
@@ -135,8 +148,8 @@ class TracerWrapper(object):
             instrument_set = init_instrumentations(
                 should_enrich_metrics,
                 instruments,
-                base_http_url=base_http_url,
-                project_api_key=project_api_key,
+                client=obj.__client,
+                async_client=obj.__async_client,
             )
 
             if not instrument_set:
@@ -184,7 +197,7 @@ class TracerWrapper(object):
         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, SDK_VERSION)
+        span.set_attribute(SPAN_SDK_VERSION, __version__)
         span.set_attribute(SPAN_LANGUAGE_VERSION, f"python@{PYTHON_VERSION}")
 
         association_properties = get_value("association_properties")
@@ -320,8 +333,8 @@ def init_instrumentations(
     should_enrich_metrics: bool,
     instruments: Optional[Set[Instruments]] = None,
     block_instruments: Optional[Set[Instruments]] = None,
-    base_http_url: Optional[str] = None,
-    project_api_key: Optional[str] = None,
+    client: Optional[LaminarClient] = None,
+    async_client: Optional[AsyncLaminarClient] = None,
 ):
     block_instruments = block_instruments or set()
     # These libraries are not instrumented by default,
@@ -434,7 +447,7 @@ def init_instrumentations(
             if init_weaviate_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.PLAYWRIGHT:
-            if init_playwright_instrumentor():
+            if init_playwright_instrumentor(client, async_client):
                 instrument_set = True
         elif instrument == Instruments.BROWSER_USE:
             if init_browser_use_instrumentor():
@@ -465,12 +478,14 @@ def init_browser_use_instrumentor():
         return False
 
 
-def init_playwright_instrumentor():
+def init_playwright_instrumentor(
+    client: LaminarClient, async_client: AsyncLaminarClient
+):
     try:
         if is_package_installed("playwright"):
             from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
 
-            instrumentor = PlaywrightInstrumentor()
+            instrumentor = PlaywrightInstrumentor(client, async_client)
             instrumentor.instrument()
         return True
     except Exception as e:

lmnr/sdk/browser/browser_use_otel.py

@@ -1,7 +1,7 @@
 from lmnr.openllmetry_sdk.decorators.base import json_dumps
-from lmnr.sdk.browser.utils import _with_tracer_wrapper
+from lmnr.sdk.browser.utils import with_tracer_wrapper
 from lmnr.sdk.utils import get_input_from_func_args
-from lmnr.version import SDK_VERSION
+from lmnr.version import __version__
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import unwrap
@@ -35,7 +35,7 @@ WRAPPED_METHODS = [
         "object": "Controller",
         "method": "act",
         "span_name": "controller.act",
-        "ignore_input": False,
+        "ignore_input": True,
         "ignore_output": False,
         "span_type": "DEFAULT",
     },
@@ -50,7 +50,7 @@ WRAPPED_METHODS = [
 ]
 
 
-@_with_tracer_wrapper
+@with_tracer_wrapper
 async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
     span_name = to_wrap.get("span_name")
     attributes = {
@@ -58,13 +58,12 @@ async def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
     }
     if to_wrap.get("method") == "execute_action":
         span_name = args[0] if len(args) > 0 else kwargs.get("action_name", "action")
-    elif to_wrap.get("method") == "execute_action":
-        attributes["lmnr.span.input"] = {
-            "action": span_name,
-            "params": json_dumps(
-                args[1] if len(args) > 1 else kwargs.get("params", {})
-            ),
-        }
+        attributes["lmnr.span.input"] = json_dumps(
+            {
+                "action": span_name,
+                "params": args[1] if len(args) > 1 else kwargs.get("params", {}),
+            }
+        )
     else:
         if not to_wrap.get("ignore_input"):
             attributes["lmnr.span.input"] = json_dumps(
@@ -87,7 +86,7 @@ class BrowserUseInstrumentor(BaseInstrumentor):
 
     def _instrument(self, **kwargs):
         tracer_provider = kwargs.get("tracer_provider")
-        tracer = get_tracer(__name__, SDK_VERSION, tracer_provider)
+        tracer = get_tracer(__name__, __version__, tracer_provider)
 
         for wrapped_method in WRAPPED_METHODS:
             wrap_package = wrapped_method.get("package")