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

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")

lmnr/traceloop_sdk/instruments.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+
+class Instruments(Enum):
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    COHERE = "cohere"
+    PINECONE = "pinecone"
+    CHROMA = "chroma"
+    GOOGLE_GENERATIVEAI = "google_generativeai"
+    LANGCHAIN = "langchain"
+    MISTRAL = "mistral"
+    OLLAMA = "ollama"
+    LLAMA_INDEX = "llama_index"
+    MILVUS = "milvus"
+    TRANSFORMERS = "transformers"
+    TOGETHER = "together"
+    REDIS = "redis"
+    REQUESTS = "requests"
+    URLLIB3 = "urllib3"
+    PYMYSQL = "pymysql"
+    BEDROCK = "bedrock"
+    REPLICATE = "replicate"
+    VERTEXAI = "vertexai"
+    WATSONX = "watsonx"
+    WEAVIATE = "weaviate"
+    ALEPHALPHA = "alephalpha"
+    MARQO = "marqo"
+    LANCEDB = "lancedb"

lmnr/traceloop_sdk/metrics/metrics.py

@@ -0,0 +1,176 @@
+from collections.abc import Sequence
+from typing import Dict
+
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import (
+    OTLPMetricExporter as GRPCExporter,
+)
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
+    OTLPMetricExporter as HTTPExporter,
+)
+from opentelemetry.semconv_ai import Meters
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import (
+    PeriodicExportingMetricReader,
+    MetricExporter,
+)
+from opentelemetry.sdk.metrics.view import View, ExplicitBucketHistogramAggregation
+from opentelemetry.sdk.resources import Resource
+
+from opentelemetry import metrics
+
+
+class MetricsWrapper(object):
+    resource_attributes: dict = {}
+    endpoint: str = None
+    # if it needs headers?
+    headers: Dict[str, str] = {}
+    __metrics_exporter: MetricExporter = None
+    __metrics_provider: MeterProvider = None
+
+    def __new__(cls, exporter: MetricExporter = None) -> "MetricsWrapper":
+        if not hasattr(cls, "instance"):
+            obj = cls.instance = super(MetricsWrapper, cls).__new__(cls)
+            if not MetricsWrapper.endpoint:
+                return obj
+
+            obj.__metrics_exporter = (
+                exporter
+                if exporter
+                else init_metrics_exporter(
+                    MetricsWrapper.endpoint, MetricsWrapper.headers
+                )
+            )
+
+            obj.__metrics_provider = init_metrics_provider(
+                obj.__metrics_exporter, MetricsWrapper.resource_attributes
+            )
+
+        return cls.instance
+
+    @staticmethod
+    def set_static_params(
+        resource_attributes: dict,
+        endpoint: str,
+        headers: Dict[str, str],
+    ) -> None:
+        MetricsWrapper.resource_attributes = resource_attributes
+        MetricsWrapper.endpoint = endpoint
+        MetricsWrapper.headers = headers
+
+
+def init_metrics_exporter(endpoint: str, headers: Dict[str, str]) -> MetricExporter:
+    if "http" in endpoint.lower() or "https" in endpoint.lower():
+        return HTTPExporter(endpoint=f"{endpoint}/v1/metrics", headers=headers)
+    else:
+        return GRPCExporter(endpoint=endpoint, headers=headers)
+
+
+def init_metrics_provider(
+    exporter: MetricExporter, resource_attributes: dict = None
+) -> MeterProvider:
+    resource = (
+        Resource.create(resource_attributes)
+        if resource_attributes
+        else Resource.create()
+    )
+    reader = PeriodicExportingMetricReader(exporter)
+    provider = MeterProvider(
+        metric_readers=[reader],
+        resource=resource,
+        views=metric_views(),
+    )
+
+    metrics.set_meter_provider(provider)
+    return provider
+
+
+def metric_views() -> Sequence[View]:
+    return [
+        View(
+            instrument_name=Meters.LLM_TOKEN_USAGE,
+            aggregation=ExplicitBucketHistogramAggregation(
+                [
+                    0.01,
+                    0.02,
+                    0.04,
+                    0.08,
+                    0.16,
+                    0.32,
+                    0.64,
+                    1.28,
+                    2.56,
+                    5.12,
+                    10.24,
+                    20.48,
+                    40.96,
+                    81.92,
+                ]
+            ),
+        ),
+        View(
+            instrument_name=Meters.LLM_OPERATION_DURATION,
+            aggregation=ExplicitBucketHistogramAggregation(
+                [
+                    1,
+                    4,
+                    16,
+                    64,
+                    256,
+                    1024,
+                    4096,
+                    16384,
+                    65536,
+                    262144,
+                    1048576,
+                    4194304,
+                    16777216,
+                    67108864,
+                ]
+            ),
+        ),
+        View(
+            instrument_name=Meters.PINECONE_DB_QUERY_DURATION,
+            aggregation=ExplicitBucketHistogramAggregation(
+                [
+                    0.01,
+                    0.02,
+                    0.04,
+                    0.08,
+                    0.16,
+                    0.32,
+                    0.64,
+                    1.28,
+                    2.56,
+                    5.12,
+                    10.24,
+                    20.48,
+                    40.96,
+                    81.92,
+                ]
+            ),
+        ),
+        View(
+            instrument_name=Meters.PINECONE_DB_QUERY_SCORES,
+            aggregation=ExplicitBucketHistogramAggregation(
+                [
+                    -1,
+                    -0.875,
+                    -0.75,
+                    -0.625,
+                    -0.5,
+                    -0.375,
+                    -0.25,
+                    -0.125,
+                    0,
+                    0.125,
+                    0.25,
+                    0.375,
+                    0.5,
+                    0.625,
+                    0.75,
+                    0.875,
+                    1,
+                ]
+            ),
+        ),
+    ]

lmnr/traceloop_sdk/tests/__init__.py

@@ -0,0 +1 @@
+"""unit tests."""

lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_and_external_association_properties.yaml

@@ -0,0 +1,101 @@
+interactions:
+- request:
+    body: '{"messages": [{"content": "You are helpful assistant", "role": "system"},
+      {"content": "tell me a short joke", "role": "user"}], "model": "gpt-3.5-turbo",
+      "logprobs": false, "n": 1, "stream": false, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '217'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.35.15
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.35.15
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.9.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1SRS0/DMBCE7/kVW1+4tKgJCo9eEHABhHooLyGEKtfdJgbHa7wbaFX1v6OEtIWL
+        D/PtrGbW6wRA2bkagTKlFlMFN7jIbiaP44fF59Pt5Pj65epu6Zbf44un69MxLVW/cdDsHY1sXYeG
+        quBQLPlfbCJqwWZrepLlaTo8S7MWVDRH19iKIIOjw3wgdZzRYJhmeecsyRpkNYLXBABg3b5NRj/H
+        pRrBsL9VKmTWBarRbghARXKNojSzZdFeVH8PDXlB38a+ryP24LlcwZz8gQAbi14sC4PEmgW0UMXn
+        cIlG14wgJa6g0h8IdQD8wriS0vqi93d9xEXNuqnna+c6fbPL66gIkWbc8Z2+sN5yOY2omXyTjYWC
+        aukmAXhr71L/q6pCpCrIVOgDfbMw686i9j+xh2neQSHRbq8f5UmXT/GKBavpwvoCY4i2PVLbYpP8
+        AAAA//8DAFwYnEsjAgAA
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8bbd5d409b62b0bd-ATL
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Sat, 31 Aug 2024 13:28:32 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=3B.f5aMPKiXVHyNDAIAPma3ZGvDnGViQrDAMvyT4n_8-1725110912-1.0.1.1-.elzfgXAenLSaVeAmcRwzq2OROEZMEvOpxSRlQ7PPZ8n6nkbc2NfZXBU1bijPQNxQ28MLNRJFyh4B4Mq4G3PPA;
+        path=/; expires=Sat, 31-Aug-24 13:58:32 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=LakflcrbwsF6x0qpc03TIL8jU8c3IjMCt5dua3l4dVA-1725110912530-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - traceloop
+      openai-processing-ms:
+      - '233'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15552000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '5000'
+      x-ratelimit-limit-tokens:
+      - '4000000'
+      x-ratelimit-remaining-requests:
+      - '4999'
+      x-ratelimit-remaining-tokens:
+      - '3999970'
+      x-ratelimit-reset-requests:
+      - 12ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_459694e3c39fd24575ad9deb5b65a831
+    status:
+      code: 200
+      message: OK
+version: 1

lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_association_properties.yaml

@@ -0,0 +1,99 @@
+interactions:
+- request:
+    body: '{"messages": [{"content": "You are helpful assistant", "role": "system"},
+      {"content": "tell me a short joke", "role": "user"}], "model": "gpt-3.5-turbo",
+      "logprobs": false, "n": 1, "stream": false, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '217'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.35.15
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.35.15
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.9.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1SRzU7DMBCE73mKxRcuLYLSFsgFgbhwBCSQ+FHlONvE4Hgt71olQn135BBauPgw
+        s7P6dvxVAChbqxKUabWYLrjphdwk01VXzb1teXOX6pquzp9vKSwfFzdqkhNUvaOR39SRoS44FEv+
+        xzYRtWDeenI2m13Mzxfz5WB0VKPLsSbI9PRoMZUUK5oen8wWY7Ila5BVCS8FAMDX8GZGX+OnKuF4
+        8qt0yKwbVOVuCEBFcllRmtmyaC9qsjcNeUE/YD+kiBNoMSJYBg3cUhR4pw+ENUXoKZWv/tU/tT0Y
+        Sq72hwLSIlTW9MYh5N01pABVD1YY3foSrtHoxAhWYKMZZEMgNmJ9oEaE7Y7dURMiVflOn5zb6Wvr
+        LberiJrJZ04WCj/xbQHwNnSU/p2tQqQuyEroA31eOBsrUvtf+WMuR1NItNvr82Ux8inuWbBbra1v
+        MIZoh8IyZbEtvgEAAP//AwAFMxvRLwIAAA==
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8aef251d0f8609c9-HFA
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 06 Aug 2024 12:49:06 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=SWNMVXkujzFcfmlIKZqekPtNke27ztV8lzplh5iUMes-1722948546-1.0.1.1-oRP4d5x5PiBOFu.G77C4XWWMxrsKragvFMrFNCIRwudZ7Z2NMrKgMa_A7eqXOME9rU2sqUIpS9c8T9SBEAR7Fg;
+        path=/; expires=Tue, 06-Aug-24 13:19:06 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=VuBkx.e0oap2GPCBPG260hGbmwEpoHckoHEm5vALKZs-1722948546860-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - traceloop
+      openai-processing-ms:
+      - '400'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15552000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '5000'
+      x-ratelimit-limit-tokens:
+      - '4000000'
+      x-ratelimit-remaining-requests:
+      - '4999'
+      x-ratelimit-remaining-tokens:
+      - '3999970'
+      x-ratelimit-reset-requests:
+      - 12ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_bf54266d3b5b08c26a6dc51f55dd208c
+    status:
+      code: 200
+      message: OK
+version: 1