openlit 1.34.30__py3-none-any.whl → 1.34.31__py3-none-any.whl

openlit/instrumentation/dynamiq/__init__.py

@@ -6,12 +6,11 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.dynamiq.dynamiq import (
-    dynamiq_wrap
-)
+from openlit.instrumentation.dynamiq.dynamiq import dynamiq_wrap
 
 _instruments = ("dynamiq >= 0.4.0",)
 
+
 class DynamiqInstrumentor(BaseInstrumentor):
     """
     An instrumentor for dynamiq's client library.
@@ -33,32 +32,67 @@ class DynamiqInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "dynamiq.nodes.agents.base",
             "Agent.run",
-            dynamiq_wrap("dynamiq.agent_run", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            dynamiq_wrap(
+                "dynamiq.agent_run",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "dynamiq",
             "Workflow.run",
-            dynamiq_wrap("dynamiq.workflow_run", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            dynamiq_wrap(
+                "dynamiq.workflow_run",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "dynamiq.memory",
             "Memory.add",
-            dynamiq_wrap("dynamiq.memory_add", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            dynamiq_wrap(
+                "dynamiq.memory_add",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "dynamiq.memory",
             "Memory.search",
-            dynamiq_wrap("dynamiq.memory_search", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            dynamiq_wrap(
+                "dynamiq.memory_search",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
-
     def _uninstrument(self, **kwargs):
         # Proper uninstrumentation logic to revert patched methods
         pass

openlit/instrumentation/dynamiq/dynamiq.py

@@ -5,7 +5,11 @@ Module for monitoring Dynamiq calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import (
     handle_exception,
 )
@@ -14,8 +18,18 @@ from openlit.semcov import SemanticConvention
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def dynamiq_wrap(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def dynamiq_wrap(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,49 +64,76 @@ def dynamiq_wrap(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_DYNAMIQ)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_DYNAMIQ,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
 
                 if gen_ai_endpoint == "dynamiq.agent_run":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                       getattr(instance, 'id', '') or '')
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                       getattr(instance, 'name', '') or '')
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                       getattr(getattr(instance, 'llm', None), 'model', '') or '')
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TYPE,
-                                        str(getattr(instance, 'type', '')) or '')
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ID,
+                        getattr(instance, "id", "") or "",
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ROLE,
+                        getattr(instance, "name", "") or "",
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL,
+                        getattr(getattr(instance, "llm", None), "model", "") or "",
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TYPE,
+                        str(getattr(instance, "type", "")) or "",
+                    )
 
                 elif gen_ai_endpoint == "dynamiq.workflow_run":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                       getattr(instance, 'id', '') or '')
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                      getattr(getattr(instance.flow, 'nodes', [None])[0], 'model', 'default_model'))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ID,
+                        getattr(instance, "id", "") or "",
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL,
+                        getattr(
+                            getattr(instance.flow, "nodes", [None])[0],
+                            "model",
+                            "default_model",
+                        ),
+                    )
 
                 elif gen_ai_endpoint == "dynamiq.memory_add":
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_ADD)
-                    span.set_attribute(SemanticConvention.DB_METADATA, str(kwargs.get('metadata', '')))
+                    span.set_attribute(
+                        SemanticConvention.DB_OPERATION_NAME,
+                        SemanticConvention.DB_OPERATION_ADD,
+                    )
+                    span.set_attribute(
+                        SemanticConvention.DB_METADATA, str(kwargs.get("metadata", ""))
+                    )
 
                 elif gen_ai_endpoint == "dynamiq.memory_search":
-                    query_value = kwargs.get('query', '') or (args[0] if args else '')
-                    span.set_attribute(SemanticConvention.DB_OPERATION_NAME,
-                                       SemanticConvention.DB_OPERATION_GET)
-                    span.set_attribute(SemanticConvention.DB_FILTER, str(kwargs.get('filters', '')))
+                    query_value = kwargs.get("query", "") or (args[0] if args else "")
+                    span.set_attribute(
+                        SemanticConvention.DB_OPERATION_NAME,
+                        SemanticConvention.DB_OPERATION_GET,
+                    )
+                    span.set_attribute(
+                        SemanticConvention.DB_FILTER, str(kwargs.get("filters", ""))
+                    )
                     span.set_attribute(SemanticConvention.DB_STATEMENT, query_value)
 
                 span.set_status(Status(StatusCode.OK))

openlit/instrumentation/elevenlabs/__init__.py

@@ -10,6 +10,7 @@ from openlit.instrumentation.elevenlabs.async_elevenlabs import async_generate
 
 _instruments = ("elevenlabs >= 1.4.0",)
 
+
 class ElevenLabsInstrumentor(BaseInstrumentor):
     """
     An instrumentor for ElevenLabs client library.
@@ -32,16 +33,34 @@ class ElevenLabsInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "elevenlabs.text_to_speech.client",
             "TextToSpeechClient.convert",
-            generate("elevenlabs.text_to_speech", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            generate(
+                "elevenlabs.text_to_speech",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # async text_to_speech.convert
         wrap_function_wrapper(
             "elevenlabs.text_to_speech.client",
             "AsyncTextToSpeechClient.convert",
-            async_generate("elevenlabs.text_to_speech", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            async_generate(
+                "elevenlabs.text_to_speech",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/elevenlabs/async_elevenlabs.py

@@ -8,8 +8,18 @@ from openlit.__helpers import handle_exception
 from openlit.instrumentation.elevenlabs.utils import process_audio_response
 from openlit.semcov import SemanticConvention
 
-def async_generate(gen_ai_endpoint, version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_generate(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -20,7 +30,9 @@ def async_generate(gen_ai_endpoint, version, environment, application_name,
         """
 
         server_address, server_port = "api.elevenlabs.io", 443
-        request_model = kwargs.get("model", kwargs.get("model_id", "eleven_multilingual_v2"))
+        request_model = kwargs.get(
+            "model", kwargs.get("model_id", "eleven_multilingual_v2")
+        )
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO} {request_model}"
 
@@ -44,7 +56,7 @@ def async_generate(gen_ai_endpoint, version, environment, application_name,
                     kwargs=kwargs,
                     capture_message_content=capture_message_content,
                     disable_metrics=disable_metrics,
-                    version=version
+                    version=version,
                 )
 
             except Exception as e:

openlit/instrumentation/elevenlabs/elevenlabs.py

@@ -8,8 +8,18 @@ from openlit.__helpers import handle_exception
 from openlit.instrumentation.elevenlabs.utils import process_audio_response
 from openlit.semcov import SemanticConvention
 
-def generate(gen_ai_endpoint, version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def generate(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -20,7 +30,9 @@ def generate(gen_ai_endpoint, version, environment, application_name,
         """
 
         server_address, server_port = "api.elevenlabs.io", 443
-        request_model = kwargs.get("model", kwargs.get("model_id", "eleven_multilingual_v2"))
+        request_model = kwargs.get(
+            "model", kwargs.get("model_id", "eleven_multilingual_v2")
+        )
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO} {request_model}"
 
@@ -44,7 +56,7 @@ def generate(gen_ai_endpoint, version, environment, application_name,
                     kwargs=kwargs,
                     capture_message_content=capture_message_content,
                     disable_metrics=disable_metrics,
-                    version=version
+                    version=version,
                 )
 
             except Exception as e:

openlit/instrumentation/elevenlabs/utils.py

@@ -1,9 +1,14 @@
 """
 ElevenLabs OpenTelemetry instrumentation utility functions
 """
+
 import time
 
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from opentelemetry.trace import Status, StatusCode
 
 from openlit.__helpers import (
@@ -12,14 +17,29 @@ from openlit.__helpers import (
 )
 from openlit.semcov import SemanticConvention
 
+
 def format_content(text):
     """
     Process text input to extract content.
     """
     return str(text) if text else ""
 
-def common_span_attributes(scope, gen_ai_operation, gen_ai_system, server_address, server_port,
-    request_model, response_model, environment, application_name, is_stream, tbt, ttft, version):
+
+def common_span_attributes(
+    scope,
+    gen_ai_operation,
+    gen_ai_system,
+    server_address,
+    server_port,
+    request_model,
+    response_model,
+    environment,
+    application_name,
+    is_stream,
+    tbt,
+    ttft,
+    version,
+):
     """
     Set common span attributes for both chat and RAG operations.
     """
@@ -30,7 +50,9 @@ def common_span_attributes(scope, gen_ai_operation, gen_ai_system, server_addres
     scope._span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
     scope._span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
     scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, scope._response_model)
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_RESPONSE_MODEL, scope._response_model
+    )
     scope._span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
     scope._span.set_attribute(SERVICE_NAME, application_name)
     scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, is_stream)
@@ -38,8 +60,21 @@ def common_span_attributes(scope, gen_ai_operation, gen_ai_system, server_addres
     scope._span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, scope._ttft)
     scope._span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
 
-def record_audio_metrics(metrics, gen_ai_operation, gen_ai_system, server_address, server_port,
-    request_model, response_model, environment, application_name, start_time, end_time, cost):
+
+def record_audio_metrics(
+    metrics,
+    gen_ai_operation,
+    gen_ai_system,
+    server_address,
+    server_port,
+    request_model,
+    response_model,
+    environment,
+    application_name,
+    start_time,
+    end_time,
+    cost,
+):
     """
     Record audio generation metrics for the operation.
     """
@@ -58,33 +93,64 @@ def record_audio_metrics(metrics, gen_ai_operation, gen_ai_system, server_addres
     metrics["genai_requests"].add(1, attributes)
     metrics["genai_cost"].record(cost, attributes)
 
-def common_audio_logic(scope, gen_ai_endpoint, pricing_info, environment, application_name,
-    metrics, capture_message_content, disable_metrics, version):
+
+def common_audio_logic(
+    scope,
+    gen_ai_endpoint,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+):
     """
     Process audio generation request and generate Telemetry
     """
 
     text = format_content(scope._kwargs.get("text", ""))
-    request_model = scope._kwargs.get("model", scope._kwargs.get("model_id", "eleven_multilingual_v2"))
+    request_model = scope._kwargs.get(
+        "model", scope._kwargs.get("model_id", "eleven_multilingual_v2")
+    )
     is_stream = False  # ElevenLabs audio generation is not streaming
 
     cost = get_audio_model_cost(request_model, pricing_info, text)
 
     # Common Span Attributes
-    common_span_attributes(scope,
-        SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO, SemanticConvention.GEN_AI_SYSTEM_ELEVENLABS,
-        scope._server_address, scope._server_port, request_model, request_model,
-        environment, application_name, is_stream, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,
+        SemanticConvention.GEN_AI_SYSTEM_ELEVENLABS,
+        scope._server_address,
+        scope._server_port,
+        request_model,
+        request_model,
+        environment,
+        application_name,
+        is_stream,
+        scope._tbt,
+        scope._ttft,
+        version,
+    )
 
     # Span Attributes for Cost and Tokens
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
 
     # Span Attributes for Response parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, scope._kwargs.get("output_format", "mp3_44100_128"))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_OUTPUT_TYPE,
+        scope._kwargs.get("output_format", "mp3_44100_128"),
+    )
 
     # Audio-specific span attributes
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE, scope._kwargs.get("voice_id", ""))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_AUDIO_SETTINGS, str(scope._kwargs.get("voice_settings", "")))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE, scope._kwargs.get("voice_id", "")
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_AUDIO_SETTINGS,
+        str(scope._kwargs.get("voice_settings", "")),
+    )
 
     # Span Attributes for Content
     if capture_message_content:
@@ -102,13 +168,39 @@ def common_audio_logic(scope, gen_ai_endpoint, pricing_info, environment, applic
 
     # Metrics
     if not disable_metrics:
-        record_audio_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO, SemanticConvention.GEN_AI_SYSTEM_ELEVENLABS,
-            scope._server_address, scope._server_port, request_model, request_model, environment,
-            application_name, scope._start_time, scope._end_time, cost)
+        record_audio_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,
+            SemanticConvention.GEN_AI_SYSTEM_ELEVENLABS,
+            scope._server_address,
+            scope._server_port,
+            request_model,
+            request_model,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+            cost,
+        )
+
 
-def process_audio_response(response, gen_ai_endpoint, pricing_info, server_port, server_address,
-    environment, application_name, metrics, start_time, span, args, kwargs, capture_message_content=False,
-    disable_metrics=False, version="1.0.0"):
+def process_audio_response(
+    response,
+    gen_ai_endpoint,
+    pricing_info,
+    server_port,
+    server_address,
+    environment,
+    application_name,
+    metrics,
+    start_time,
+    span,
+    args,
+    kwargs,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="1.0.0",
+):
     """
     Process audio generation request and generate Telemetry
     """
@@ -123,11 +215,22 @@ def process_audio_response(response, gen_ai_endpoint, pricing_info, server_port,
     scope._args = args
 
     # Initialize streaming and timing values for ElevenLabs audio generation
-    scope._response_model = kwargs.get("model", kwargs.get("model_id", "eleven_multilingual_v2"))
+    scope._response_model = kwargs.get(
+        "model", kwargs.get("model_id", "eleven_multilingual_v2")
+    )
     scope._tbt = 0.0
     scope._ttft = scope._end_time - scope._start_time
 
-    common_audio_logic(scope, gen_ai_endpoint, pricing_info, environment, application_name,
-        metrics, capture_message_content, disable_metrics, version)
+    common_audio_logic(
+        scope,
+        gen_ai_endpoint,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+    )
 
     return response

openlit/instrumentation/embedchain/__init__.py

@@ -1,5 +1,6 @@
 # pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
 """Initializer of Auto Instrumentation of EmbedChain Functions"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
@@ -24,6 +25,7 @@ WRAPPED_METHODS = [
     },
 ]
 
+
 class EmbedChainInstrumentor(BaseInstrumentor):
     """An instrumentor for EmbedChain's client library."""
 
@@ -46,8 +48,15 @@ class EmbedChainInstrumentor(BaseInstrumentor):
             wrap_function_wrapper(
                 wrap_package,
                 wrap_object,
-                wrapper(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content),
+                wrapper(
+                    gen_ai_endpoint,
+                    version,
+                    environment,
+                    application_name,
+                    tracer,
+                    pricing_info,
+                    capture_message_content,
+                ),
             )
 
     @staticmethod