lmnr 0.4.6__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,15 @@ 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
@@ -96,8 +100,6 @@ 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}"},
@@ -289,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,
@@ -453,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,
+    )

lmnr/traceloop_sdk/decorators/base.py

@@ -0,0 +1,253 @@
+import json
+from functools import wraps
+import os
+import types
+from typing import Any, Optional
+import warnings
+
+from opentelemetry import trace
+from opentelemetry import context as context_api
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+from lmnr.traceloop_sdk.tracing import get_tracer, set_workflow_name
+from lmnr.traceloop_sdk.tracing.tracing import (
+    TracerWrapper,
+    set_entity_path,
+    get_chained_entity_path,
+)
+from lmnr.traceloop_sdk.utils import camel_to_snake
+from lmnr.traceloop_sdk.utils.json_encoder import JSONEncoder
+
+
+class CustomJSONEncoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        try:
+            return super().default(o)
+        except TypeError:
+            return str(o)  # Fallback to string representation for unsupported types
+
+
+def _json_dumps(data: dict) -> str:
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            return json.dumps(data, cls=CustomJSONEncoder)
+    except Exception:
+        # Log the exception and return a placeholder if serialization completely fails
+        # Telemetry().log_exception(e)
+        return "{}"  # Return an empty JSON object as a fallback
+
+
+def entity_method(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    def decorate(fn):
+        @wraps(fn)
+        def wrap(*args, **kwargs):
+            if not TracerWrapper.verify_initialized():
+                return fn(*args, **kwargs)
+
+            entity_name = name or fn.__name__
+            if tlp_span_kind in [
+                TraceloopSpanKindValues.WORKFLOW,
+                TraceloopSpanKindValues.AGENT,
+            ]:
+                set_workflow_name(entity_name)
+            span_name = f"{entity_name}.{tlp_span_kind.value}"
+
+            with get_tracer() as tracer:
+                span = tracer.start_span(span_name)
+                ctx = trace.set_span_in_context(span)
+                ctx_token = context_api.attach(ctx)
+
+                if tlp_span_kind in [
+                    TraceloopSpanKindValues.TASK,
+                    TraceloopSpanKindValues.TOOL,
+                ]:
+                    entity_path = get_chained_entity_path(entity_name)
+                    set_entity_path(entity_path)
+
+                span.set_attribute(
+                    SpanAttributes.TRACELOOP_SPAN_KIND, tlp_span_kind.value
+                )
+                span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, entity_name)
+                if version:
+                    span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_VERSION, version)
+
+                try:
+                    if _should_send_prompts():
+                        span.set_attribute(
+                            SpanAttributes.TRACELOOP_ENTITY_INPUT,
+                            _json_dumps({"args": args, "kwargs": kwargs}),
+                        )
+                except TypeError:
+                    pass
+
+                res = fn(*args, **kwargs)
+
+                # span will be ended in the generator
+                if isinstance(res, types.GeneratorType):
+                    return _handle_generator(span, res)
+
+                try:
+                    if _should_send_prompts():
+                        span.set_attribute(
+                            SpanAttributes.TRACELOOP_ENTITY_OUTPUT,
+                            _json_dumps(res),
+                        )
+                except TypeError:
+                    pass
+
+                span.end()
+                context_api.detach(ctx_token)
+
+                return res
+
+        return wrap
+
+    return decorate
+
+
+def entity_class(
+    name: Optional[str],
+    version: Optional[int],
+    method_name: str,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    def decorator(cls):
+        task_name = name if name else camel_to_snake(cls.__name__)
+        method = getattr(cls, method_name)
+        setattr(
+            cls,
+            method_name,
+            entity_method(name=task_name, version=version, tlp_span_kind=tlp_span_kind)(
+                method
+            ),
+        )
+        return cls
+
+    return decorator
+
+
+# Async Decorators
+
+
+def aentity_method(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    def decorate(fn):
+        @wraps(fn)
+        async def wrap(*args, **kwargs):
+            if not TracerWrapper.verify_initialized():
+                print("Tracer not initialized")
+                return await fn(*args, **kwargs)
+
+            entity_name = name or fn.__name__
+            if tlp_span_kind in [
+                TraceloopSpanKindValues.WORKFLOW,
+                TraceloopSpanKindValues.AGENT,
+            ]:
+                set_workflow_name(entity_name)
+            span_name = f"{entity_name}.{tlp_span_kind.value}"
+
+            with get_tracer() as tracer:
+                span = tracer.start_span(span_name)
+                ctx = trace.set_span_in_context(span)
+                ctx_token = context_api.attach(ctx)
+
+                if tlp_span_kind in [
+                    TraceloopSpanKindValues.TASK,
+                    TraceloopSpanKindValues.TOOL,
+                ]:
+                    entity_path = get_chained_entity_path(entity_name)
+                    set_entity_path(entity_path)
+
+                span.set_attribute(
+                    SpanAttributes.TRACELOOP_SPAN_KIND, tlp_span_kind.value
+                )
+                span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, entity_name)
+                if version:
+                    span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_VERSION, version)
+
+                try:
+                    if _should_send_prompts():
+                        span.set_attribute(
+                            SpanAttributes.TRACELOOP_ENTITY_INPUT,
+                            _json_dumps({"args": args, "kwargs": kwargs}),
+                        )
+                except TypeError:
+                    pass
+
+                res = await fn(*args, **kwargs)
+
+                # span will be ended in the generator
+                if isinstance(res, types.AsyncGeneratorType):
+                    return await _ahandle_generator(span, ctx_token, res)
+
+                try:
+                    if _should_send_prompts():
+                        span.set_attribute(
+                            SpanAttributes.TRACELOOP_ENTITY_OUTPUT, json.dumps(res)
+                        )
+                except TypeError:
+                    pass
+
+                span.end()
+                context_api.detach(ctx_token)
+
+                return res
+
+        return wrap
+
+    return decorate
+
+
+def aentity_class(
+    name: Optional[str],
+    version: Optional[int],
+    method_name: str,
+    tlp_span_kind: Optional[TraceloopSpanKindValues] = TraceloopSpanKindValues.TASK,
+):
+    def decorator(cls):
+        task_name = name if name else camel_to_snake(cls.__name__)
+        method = getattr(cls, method_name)
+        setattr(
+            cls,
+            method_name,
+            aentity_method(
+                name=task_name, version=version, tlp_span_kind=tlp_span_kind
+            )(method),
+        )
+        return cls
+
+    return decorator
+
+
+def _handle_generator(span, res):
+    # for some reason the SPAN_KEY is not being set in the context of the generator, so we re-set it
+    context_api.attach(trace.set_span_in_context(span))
+    yield from res
+
+    span.end()
+
+    # Note: we don't detach the context here as this fails in some situations
+    # https://github.com/open-telemetry/opentelemetry-python/issues/2606
+    # This is not a problem since the context will be detached automatically during garbage collection
+
+
+async def _ahandle_generator(span, ctx_token, res):
+    async for part in res:
+        yield part
+
+    span.end()
+    context_api.detach(ctx_token)
+
+
+def _should_send_prompts():
+    return (
+        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")