lmnr 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

lmnr/sdk/decorators.py

@@ -1,9 +1,9 @@
-from traceloop.sdk.decorators.base import (
+from lmnr.traceloop_sdk.decorators.base import (
     entity_method,
     aentity_method,
 )
 from opentelemetry.trace import INVALID_SPAN, get_current_span
-from traceloop.sdk import Traceloop
+from lmnr.traceloop_sdk import Traceloop
 
 from typing import Callable, Optional, ParamSpec, TypeVar, cast
 
@@ -42,11 +42,6 @@ def observe(
     """
 
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
-        if not L.is_initialized():
-            raise Exception(
-                "Laminar is not initialized. Please "
-                + "call Laminar.initialize() first."
-            )
         current_span = get_current_span()
         if current_span != INVALID_SPAN:
             if session_id is not None:

lmnr/sdk/laminar.py

@@ -4,11 +4,16 @@ from opentelemetry.trace import (
     get_current_span,
     set_span_in_context,
     Span,
+    SpanKind,
 )
 from opentelemetry.semconv_ai import SpanAttributes
 from opentelemetry.util.types import AttributeValue
-from traceloop.sdk import Traceloop
-from traceloop.sdk.tracing import get_tracer
+from opentelemetry.context.context import Context
+from opentelemetry.util import types
+from lmnr.traceloop_sdk import Traceloop
+from lmnr.traceloop_sdk.tracing import get_tracer
+from contextlib import contextmanager
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 
 from pydantic.alias_generators import to_snake
 from typing import Any, Optional, Union
@@ -35,7 +40,7 @@ from .types import (
 
 
 class Laminar:
-    __base_url: str = "https://api.lmnr.ai"
+    __base_url: str = "https://api.lmnr.ai:8443"
     __project_api_key: Optional[str] = None
     __env: dict[str, str] = {}
     __initialized: bool = False
@@ -67,9 +72,9 @@ class Laminar:
             base_url (Optional[str], optional): Url of Laminar endpoint,
                             or the  customopen telemetry ingester.
                             If not specified, defaults to
-                            https://api.lmnr.ai.
+                            https://api.lmnr.ai:8443.
                             For locally hosted Laminar, default setting
-                            must be http://localhost:8000
+                            must be http://localhost:8001
                             Defaults to None.
 
         Raises:
@@ -95,8 +100,10 @@ class Laminar:
         cls.__initialized = True
         cls._initialize_logger()
         Traceloop.init(
-            api_endpoint=cls.__base_url,
-            api_key=cls.__project_api_key,
+            exporter=OTLPSpanExporter(
+                endpoint=cls.__base_url,
+                headers={"authorization": f"Bearer {cls.__project_api_key}"},
+            ),
         )
 
     @classmethod
@@ -247,7 +254,7 @@ class Laminar:
         name: str,
         evaluator: str,
         data: dict[str, AttributeValue],
-        env: Optional[dict[str, str]] = {},
+        env: Optional[dict[str, str]] = None,
         timestamp: Optional[Union[datetime.datetime, int]] = None,
     ):
         """Send an event for evaluation to the Laminar backend
@@ -284,6 +291,68 @@ class Laminar:
 
         current_span.add_event(name, event)
 
+    @classmethod
+    @contextmanager
+    def start_as_current_span(
+        cls,
+        name: str,
+        input: Any = None,
+        context: Optional[Context] = None,
+        kind: SpanKind = SpanKind.INTERNAL,
+        attributes: types.Attributes = None,
+        links=None,
+        start_time: Optional[int] = None,
+        record_exception: bool = True,
+        set_status_on_exception: bool = True,
+        end_on_exit: bool = True,
+    ):
+        """Start a new span as the current span. Useful for manual instrumentation.
+        This is the preferred and more stable way to use manual instrumentation.
+
+        Usage example:
+        ```python
+        with Laminar.start_as_current_span("my_span", input="my_input"):
+            await my_async_function()
+        ```
+
+        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.
+            context (Optional[Context], optional): context to start the span in.
+                Defaults to None.
+            kind (SpanKind, optional): kind of the span. Defaults to SpanKind.INTERNAL.
+            attributes (types.Attributes, optional): attributes to set on the span.
+                Defaults to None.
+            links ([type], optional): links to set on the span. Defaults to None.
+            start_time (Optional[int], optional): start time of the span.
+                Defaults to None.
+            record_exception (bool, optional): whether to record exceptions.
+                Defaults to True.
+            set_status_on_exception (bool, optional): whether to set status on exception.
+                Defaults to True.
+            end_on_exit (bool, optional): whether to end the span on exit.
+                Defaults to True.
+        """
+        with get_tracer() as tracer:
+            with tracer.start_as_current_span(
+                name,
+                context=context,
+                kind=kind,
+                attributes=attributes,
+                links=links,
+                start_time=start_time,
+                record_exception=record_exception,
+                set_status_on_exception=set_status_on_exception,
+                end_on_exit=end_on_exit,
+            ) as span:
+                if input is not None:
+                    span.set_attribute(
+                        SpanAttributes.TRACELOOP_ENTITY_INPUT,
+                        json.dumps({"input": input}),
+                    )
+                yield span
+
     @classmethod
     def start_span(
         cls,
@@ -330,7 +399,7 @@ class Laminar:
         """
         if output is not None:
             span.set_attribute(
-                SpanAttributes.TRACELOOP_ENTITY_OUTPUT, json.dumps({output})
+                SpanAttributes.TRACELOOP_ENTITY_OUTPUT, json.dumps(output)
             )
 
     @classmethod
@@ -448,6 +517,7 @@ class Laminar:
 
     @classmethod
     def _headers(cls):
+        assert cls.__project_api_key is not None, "Project API key is not set"
         return {
             "Authorization": "Bearer " + cls.__project_api_key,
             "Content-Type": "application/json",

lmnr/traceloop_sdk/.flake8

@@ -0,0 +1,12 @@
+[flake8]
+exclude =
+	.git,
+	__pycache__,
+	build,
+	dist,
+	.tox,
+	venv,
+	.venv,
+	.pytest_cache
+max-line-length = 120
+per-file-ignores = __init__.py:F401

lmnr/traceloop_sdk/.python-version

@@ -0,0 +1 @@
+3.9.5

lmnr/traceloop_sdk/README.md

@@ -0,0 +1,16 @@
+# traceloop-sdk
+
+Traceloop’s Python SDK allows you to easily start monitoring and debugging your LLM execution. Tracing is done in a non-intrusive way, built on top of OpenTelemetry. You can choose to export the traces to Traceloop, or to your existing observability stack.
+
+```python
+Traceloop.init(app_name="joke_generation_service")
+
+@workflow(name="joke_creation")
+def create_joke():
+    completion = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": "Tell me a joke about opentelemetry"}],
+    )
+
+    return completion.choices[0].message.content
+```

lmnr/traceloop_sdk/__init__.py

@@ -0,0 +1,138 @@
+import os
+import sys
+from pathlib import Path
+
+from typing import Optional, Set
+from colorama import Fore
+from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+from opentelemetry.sdk.metrics.export import MetricExporter
+from opentelemetry.sdk.resources import SERVICE_NAME
+from opentelemetry.propagators.textmap import TextMapPropagator
+from opentelemetry.util.re import parse_env_headers
+
+from lmnr.traceloop_sdk.metrics.metrics import MetricsWrapper
+from lmnr.traceloop_sdk.instruments import Instruments
+from lmnr.traceloop_sdk.config import (
+    is_content_tracing_enabled,
+    is_tracing_enabled,
+    is_metrics_enabled,
+)
+from lmnr.traceloop_sdk.tracing.tracing import (
+    TracerWrapper,
+    set_association_properties,
+    set_external_prompt_tracing_context,
+)
+from typing import Dict
+
+
+class Traceloop:
+    AUTO_CREATED_KEY_PATH = str(
+        Path.home() / ".cache" / "traceloop" / "auto_created_key"
+    )
+    AUTO_CREATED_URL = str(Path.home() / ".cache" / "traceloop" / "auto_created_url")
+
+    __tracer_wrapper: TracerWrapper
+
+    @staticmethod
+    def init(
+        app_name: Optional[str] = sys.argv[0],
+        api_endpoint: str = "https://api.lmnr.ai",
+        api_key: str = None,
+        headers: Dict[str, str] = {},
+        disable_batch=False,
+        exporter: SpanExporter = None,
+        metrics_exporter: MetricExporter = None,
+        metrics_headers: Dict[str, str] = None,
+        processor: SpanProcessor = None,
+        propagator: TextMapPropagator = None,
+        should_enrich_metrics: bool = True,
+        resource_attributes: dict = {},
+        instruments: Optional[Set[Instruments]] = None,
+    ) -> None:
+        api_endpoint = os.getenv("TRACELOOP_BASE_URL") or api_endpoint
+        api_key = os.getenv("TRACELOOP_API_KEY") or api_key
+
+        if not is_tracing_enabled():
+            print(Fore.YELLOW + "Tracing is disabled" + Fore.RESET)
+            return
+
+        enable_content_tracing = is_content_tracing_enabled()
+
+        if exporter or processor:
+            print(Fore.GREEN + "Laminar exporting traces to a custom exporter")
+
+        headers = os.getenv("TRACELOOP_HEADERS") or headers
+
+        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(
+                Fore.RED
+                + "Error: Missing API key,"
+                + " go to project settings to create one"
+            )
+            print("Set the LMNR_PROJECT_API_KEY environment variable to the key")
+            print(Fore.RESET)
+            return
+
+        if not exporter and not processor and headers:
+            print(
+                Fore.GREEN
+                + f"Laminar exporting traces to {api_endpoint}, authenticating with custom headers"
+            )
+
+        if api_key and not exporter and not processor and not headers:
+            print(
+                Fore.GREEN
+                + f"Laminar exporting traces to {api_endpoint} authenticating with bearer token"
+            )
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+            }
+
+        print(Fore.RESET)
+
+        # Tracer init
+        resource_attributes.update({SERVICE_NAME: app_name})
+        TracerWrapper.set_static_params(
+            resource_attributes, enable_content_tracing, api_endpoint, headers
+        )
+        Traceloop.__tracer_wrapper = TracerWrapper(
+            disable_batch=disable_batch,
+            processor=processor,
+            propagator=propagator,
+            exporter=exporter,
+            should_enrich_metrics=should_enrich_metrics,
+            instruments=instruments,
+        )
+
+        if not metrics_exporter and exporter:
+            return
+
+        metrics_endpoint = os.getenv("TRACELOOP_METRICS_ENDPOINT") or api_endpoint
+        metrics_headers = (
+            os.getenv("TRACELOOP_METRICS_HEADERS") or metrics_headers or headers
+        )
+
+        if not is_metrics_enabled() or not metrics_exporter and exporter:
+            print(Fore.YELLOW + "Metrics are disabled" + Fore.RESET)
+            return
+
+        MetricsWrapper.set_static_params(
+            resource_attributes, metrics_endpoint, metrics_headers
+        )
+
+        Traceloop.__metrics_wrapper = MetricsWrapper(exporter=metrics_exporter)
+
+    def set_association_properties(properties: dict) -> None:
+        set_association_properties(properties)
+
+    def set_prompt(template: str, variables: dict, version: int):
+        set_external_prompt_tracing_context(template, variables, version)

lmnr/traceloop_sdk/config/__init__.py

@@ -0,0 +1,13 @@
+import os
+
+
+def is_tracing_enabled() -> bool:
+    return (os.getenv("TRACELOOP_TRACING_ENABLED") or "true").lower() == "true"
+
+
+def is_content_tracing_enabled() -> bool:
+    return (os.getenv("TRACELOOP_TRACE_CONTENT") or "true").lower() == "true"
+
+
+def is_metrics_enabled() -> bool:
+    return (os.getenv("TRACELOOP_METRICS_ENABLED") or "true").lower() == "true"

lmnr/traceloop_sdk/decorators/__init__.py

@@ -0,0 +1,131 @@
+from typing import Optional
+
+from opentelemetry.semconv_ai import TraceloopSpanKindValues
+
+from lmnr.traceloop_sdk.decorators.base import (
+    aentity_class,
+    aentity_method,
+    entity_class,
+    entity_method,
+)
+
+
+def task(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def workflow(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.WORKFLOW,
+):
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def agent(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return workflow(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=TraceloopSpanKindValues.AGENT,
+    )
+
+
+def tool(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return task(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=TraceloopSpanKindValues.TOOL,
+    )
+
+
+# Async Decorators
+def atask(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    if method_name is None:
+        return aentity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return aentity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def aworkflow(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.WORKFLOW,
+):
+    if method_name is None:
+        return aentity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return aentity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def aagent(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return atask(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=TraceloopSpanKindValues.AGENT,
+    )
+
+
+def atool(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return atask(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=TraceloopSpanKindValues.TOOL,
+    )