PyPI - openlit - Versions diffs - 1.14.2__py3-none-any.whl → 1.16.2__py3-none-any.whl - Mend

openlit 1.14.2py3-none-any.whl → 1.16.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

openlit/__init__.py +3 -0
openlit/instrumentation/anthropic/anthropic.py +2 -2
openlit/instrumentation/anthropic/async_anthropic.py +2 -2
openlit/instrumentation/bedrock/__init__.py +3 -3
openlit/instrumentation/bedrock/bedrock.py +69 -307
openlit/instrumentation/cohere/cohere.py +2 -2
openlit/instrumentation/elevenlabs/__init__.py +70 -0
openlit/instrumentation/elevenlabs/async_elevenlabs.py +117 -0
openlit/instrumentation/elevenlabs/elevenlabs.py +123 -0
openlit/instrumentation/groq/async_groq.py +10 -10
openlit/instrumentation/groq/groq.py +10 -10
openlit/instrumentation/mistral/async_mistral.py +4 -4
openlit/instrumentation/mistral/mistral.py +4 -4
openlit/instrumentation/openai/async_azure_openai.py +12 -12
openlit/instrumentation/openai/async_openai.py +10 -10
openlit/instrumentation/openai/azure_openai.py +12 -12
openlit/instrumentation/openai/openai.py +10 -10
openlit/instrumentation/transformers/transformers.py +1 -1
openlit/semcov/__init__.py +5 -3
{openlit-1.14.2.dist-info → openlit-1.16.2.dist-info}/METADATA +16 -16
{openlit-1.14.2.dist-info → openlit-1.16.2.dist-info}/RECORD +23 -20
{openlit-1.14.2.dist-info → openlit-1.16.2.dist-info}/LICENSE +0 -0
{openlit-1.14.2.dist-info → openlit-1.16.2.dist-info}/WHEEL +0 -0

openlit/__init__.py CHANGED Viewed

@@ -31,6 +31,7 @@ from openlit.instrumentation.vertexai import VertexAIInstrumentor
 from openlit.instrumentation.groq import GroqInstrumentor
 from openlit.instrumentation.ollama import OllamaInstrumentor
 from openlit.instrumentation.gpt4all import GPT4AllInstrumentor
+from openlit.instrumentation.elevenlabs import ElevenLabsInstrumentor
 from openlit.instrumentation.langchain import LangChainInstrumentor
 from openlit.instrumentation.llamaindex import LlamaIndexInstrumentor
 from openlit.instrumentation.haystack import HaystackInstrumentor
@@ -192,6 +193,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "groq": "groq",
         "ollama": "ollama",
         "gpt4all": "gpt4all",
+        "elevenlabs": "elevenlabs",
         "langchain": "langchain",
         "llama_index": "llama_index",
         "haystack": "haystack",
@@ -267,6 +269,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "groq": GroqInstrumentor(),
             "ollama": OllamaInstrumentor(),
             "gpt4all": GPT4AllInstrumentor(),
+            "elevenlabs": ElevenLabsInstrumentor(),
             "langchain": LangChainInstrumentor(),
             "llama_index": LlamaIndexInstrumentor(),
             "haystack": HaystackInstrumentor(),

openlit/instrumentation/anthropic/anthropic.py CHANGED Viewed

@@ -120,7 +120,7 @@ def messages(gen_ai_endpoint, version, environment, application_name, tracer,
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
                                             kwargs.get("model", "claude-3-sonnet-20240229"))
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                            kwargs.get("max_tokens", ""))
+                                            kwargs.get("max_tokens", -1))
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                             True)
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
@@ -224,7 +224,7 @@ def messages(gen_ai_endpoint, version, environment, application_name, tracer,
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
                                         kwargs.get("model", "claude-3-sonnet-20240229"))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                        kwargs.get("max_tokens", ""))
+                                        kwargs.get("max_tokens", -1))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                         False)
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,

openlit/instrumentation/anthropic/async_anthropic.py CHANGED Viewed

@@ -120,7 +120,7 @@ def async_messages(gen_ai_endpoint, version, environment, application_name,
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
                                             kwargs.get("model", "claude-3-sonnet-20240229"))
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                            kwargs.get("max_tokens", ""))
+                                            kwargs.get("max_tokens", -1))
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                             True)
                         span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
@@ -224,7 +224,7 @@ def async_messages(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
                                         kwargs.get("model", "claude-3-sonnet-20240229"))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                        kwargs.get("max_tokens", ""))
+                                        kwargs.get("max_tokens", -1))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                         False)
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,

openlit/instrumentation/bedrock/__init__.py CHANGED Viewed

@@ -6,9 +6,9 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
-from openlit.instrumentation.bedrock.bedrock import chat
+from openlit.instrumentation.bedrock.bedrock import converse
-_instruments = ("boto3 >= 1.34.93",)
+_instruments = ("boto3 >= 1.34.138",)
 class BedrockInstrumentor(BaseInstrumentor):
     """
@@ -32,7 +32,7 @@ class BedrockInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "botocore.client",
             "ClientCreator.create_client",
-            chat("bedrock.invoke_model", version, environment, application_name,
+            converse("bedrock.converse", version, environment, application_name,
                      tracer, pricing_info, trace_content, metrics, disable_metrics),
         )

openlit/instrumentation/bedrock/bedrock.py CHANGED Viewed

@@ -4,15 +4,14 @@ Module for monitoring Amazon Bedrock API calls.
 """
 import logging
-import json
 from botocore.response import StreamingBody
 from botocore.exceptions import ReadTimeoutError, ResponseStreamingError
 from urllib3.exceptions import ProtocolError as URLLib3ProtocolError
 from urllib3.exceptions import ReadTimeoutError as URLLib3ReadTimeoutError
 from opentelemetry.trace import SpanKind, Status, StatusCode
 from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
-from openlit.__helpers import get_chat_model_cost, get_embed_model_cost, get_image_model_cost
-from openlit.__helpers import handle_exception, general_tokens
+from openlit.__helpers import get_chat_model_cost
+from openlit.__helpers import handle_exception
 from openlit.semcov import SemanticConvetion
 # Initialize logger for logging potential issues and operations
@@ -49,7 +48,7 @@ class CustomStreamWrapper(StreamingBody):
         return data_chunk
-def chat(gen_ai_endpoint, version, environment, application_name, tracer,
+def converse(gen_ai_endpoint, version, environment, application_name, tracer,
          pricing_info, trace_content, metrics, disable_metrics):
     """
     Generates a telemetry wrapper for messages to collect metrics.
@@ -80,166 +79,24 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
         Returns:
             Response from the original method.
         """
-        def handle_image(span, model, request_body, response_body):
-            cost = 0
-            if "amazon" in model:
-                # pylint: disable=line-too-long
-                size =  str(request_body.get("imageGenerationConfig", {}).get("width", 1024)) + "x" + str(request_body.get("imageGenerationConfig", {}).get("height", 1024))
-                quality = request_body.get("imageGenerationConfig", {}).get("quality", "standard")
-                n = request_body.get("imageGenerationConfig", {}).get("numberOfImages", 1)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IMAGE_SIZE,
-                                   size)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IMAGE_QUALITY,
-                                   quality)
-                # Calculate cost of the operation
-                cost = n * get_image_model_cost(model,
-                                        pricing_info, size, quality)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                        request_body.get("textToImageParams")["text"])
-            span.set_status(Status(StatusCode.OK))
-            if disable_metrics is False:
-                attributes = {
-                    TELEMETRY_SDK_NAME:
-                        "openlit",
-                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                        application_name,
-                    SemanticConvetion.GEN_AI_SYSTEM:
-                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
-                    SemanticConvetion.GEN_AI_ENVIRONMENT:
-                        environment,
-                    SemanticConvetion.GEN_AI_TYPE:
-                        SemanticConvetion.GEN_AI_TYPE_IMAGE,
-                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                        model
-                }
-                metrics["genai_requests"].add(1, attributes)
-                metrics["genai_cost"].record(cost, attributes)
-        def handle_embed(span, model, request_body, response_body):
-            prompt_tokens, cost = 0, 0
-            if "amazon" in model:
-                prompt_tokens = response_body["inputTextTokenCount"]
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                   prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                   prompt_tokens)
-                # Calculate cost of the operation
-                cost = get_embed_model_cost(model,
-                                        pricing_info, prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                        request_body["inputText"])
-            span.set_status(Status(StatusCode.OK))
-            if disable_metrics is False:
-                attributes = {
-                    TELEMETRY_SDK_NAME:
-                        "openlit",
-                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                        application_name,
-                    SemanticConvetion.GEN_AI_SYSTEM:
-                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
-                    SemanticConvetion.GEN_AI_ENVIRONMENT:
-                        environment,
-                    SemanticConvetion.GEN_AI_TYPE:
-                        SemanticConvetion.GEN_AI_TYPE_EMBEDDING,
-                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                        model
-                }
-                metrics["genai_requests"].add(1, attributes)
-                metrics["genai_total_tokens"].add(
-                    prompt_tokens, attributes
-                )
-                metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
-                metrics["genai_cost"].record(cost, attributes)
-        def handle_chat(span, model, request_body, response_body):
-            prompt_tokens, completion_tokens, cost = 0, 0, 0
-            if "amazon" in model:
-                prompt_tokens = response_body["inputTextTokenCount"]
-                completion_tokens = response_body["results"][0]["tokenCount"]
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                    completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                    completion_tokens +
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["results"][0]["completionReason"])
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    request_body["inputText"])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["results"][0]["outputText"])
-            elif "mistral" in model:
-                prompt_tokens = general_tokens(request_body["prompt"])
-                completion_tokens = general_tokens(response_body["outputs"][0]["text"])
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                prompt_tokens + completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["outputs"][0]["stop_reason"])
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    request_body["prompt"])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["outputs"][0]["text"])
-            elif "anthropic" in model:
-                prompt_tokens = response_body["usage"]["input_tokens"]
-                completion_tokens = response_body["usage"]["output_tokens"]
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                    completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                    completion_tokens +
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["stop_reason"])
+        def converse_wrapper(original_method, *method_args, **method_kwargs):
+            """
+            Adds instrumentation to the invoke model call.
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
+            Args:
+                original_method: The original invoke model method.
+                *method_args: Positional arguments for the method.
+                **method_kwargs: Keyword arguments for the method.
+            Returns:
+                The modified response with telemetry.
+            """
+            with tracer.start_as_current_span(gen_ai_endpoint, kind=SpanKind.CLIENT) as span:
+                response = original_method(*method_args, **method_kwargs)
-                if trace_content:
-                    # Format 'messages' into a single string
-                    message_prompt = request_body["messages"]
+                try:
+                    message_prompt = method_kwargs.get("messages", "")
+                    print(message_prompt)
                     formatted_messages = []
                     for message in message_prompt:
                         role = message["role"]
@@ -256,145 +113,10 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
                         else:
                             formatted_messages.append(f"{role}: {content}")
                     prompt = "\n".join(formatted_messages)
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    prompt)
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["content"][0]["text"])
-            elif "meta" in model:
-                prompt_tokens = response_body["prompt_token_count"]
-                completion_tokens = response_body["generation_token_count"]
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                    completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                    completion_tokens +
-                                    prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["stop_reason"])
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    request_body["prompt"])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["generation"])
-            elif "cohere" in model and "command-r" not in model:
-                prompt_tokens = general_tokens(request_body["prompt"])
-                completion_tokens = general_tokens(response_body["generations"][0]["text"])
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                prompt_tokens + completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["generations"][0]["finish_reason"])
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    request_body["prompt"])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["generations"][0]["text"])
-            elif "ai21" in model:
-                prompt_tokens = general_tokens(request_body["prompt"])
-                completion_tokens = general_tokens(response_body["completions"][0]["data"]["text"])
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
-                                prompt_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
-                                completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
-                                prompt_tokens + completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response_body["completions"][0]["finishReason"]["reason"])
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(model,
-                                        pricing_info, prompt_tokens,
-                                        completion_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                            cost)
-                if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                    request_body["prompt"])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                    response_body["completions"][0]["data"]["text"])
-            span.set_status(Status(StatusCode.OK))
-            if disable_metrics is False:
-                attributes = {
-                    TELEMETRY_SDK_NAME:
-                        "openlit",
-                    SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                        application_name,
-                    SemanticConvetion.GEN_AI_SYSTEM:
-                        SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
-                    SemanticConvetion.GEN_AI_ENVIRONMENT:
-                        environment,
-                    SemanticConvetion.GEN_AI_TYPE:
-                        SemanticConvetion.GEN_AI_TYPE_CHAT,
-                    SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                        model
-                }
-                metrics["genai_requests"].add(1, attributes)
-                metrics["genai_total_tokens"].add(
-                    prompt_tokens + completion_tokens, attributes
-                )
-                metrics["genai_completion_tokens"].add(completion_tokens, attributes)
-                metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
-                metrics["genai_cost"].record(cost, attributes)
-        def add_instrumentation(original_method, *method_args, **method_kwargs):
-            """
-            Adds instrumentation to the invoke model call.
-            Args:
-                original_method: The original invoke model method.
-                *method_args: Positional arguments for the method.
-                **method_kwargs: Keyword arguments for the method.
-            Returns:
-                The modified response with telemetry.
-            """
-            with tracer.start_as_current_span(gen_ai_endpoint, kind=SpanKind.CLIENT) as span:
-                response = original_method(*method_args, **method_kwargs)
-                try:
-                    # Modify the response body to be reusable
-                    response["body"] = CustomStreamWrapper(
-                        response["body"]._raw_stream, response["body"]._content_length
-                    )
-                    request_body = json.loads(method_kwargs.get("body"))
-                    response_body = json.loads(response.get("body").read())
                     model = method_kwargs.get("modelId", "amazon.titan-text-express-v1")
-                    if ("stability" in model or "image" in model) and "embed-image" not in model:
-                        generation = "image"
-                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
-                                        SemanticConvetion.GEN_AI_TYPE_IMAGE)
-                    elif "embed" in model and "embed-image" not in model:
-                        generation = "embeddings"
-                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
-                                        SemanticConvetion.GEN_AI_TYPE_EMBEDDING)
-                    else:
-                        generation = "chat"
-                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
-                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+                    input_tokens = response["usage"]["inputTokens"]
+                    output_tokens = response["usage"]["outputTokens"]
                     span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
                     span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
@@ -407,12 +129,51 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
                                         application_name)
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
                                         model)
-                    if generation == "chat":
-                        handle_chat(span, model, request_body, response_body)
-                    elif generation == "embeddings":
-                        handle_embed(span, model, request_body, response_body)
-                    elif generation == "image":
-                        handle_image(span, model, request_body, response_body)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                        input_tokens)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                        output_tokens)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                        input_tokens + output_tokens)
+                    # Calculate cost of the operation
+                    cost = get_chat_model_cost(model,
+                                            pricing_info, input_tokens,
+                                            output_tokens)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                cost)
+                    if trace_content:
+                        span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
+                                        prompt)
+                        span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
+                                        response["output"]["message"]["content"][0]["text"])
+                    span.set_status(Status(StatusCode.OK))
+                    if disable_metrics is False:
+                        attributes = {
+                            TELEMETRY_SDK_NAME:
+                                "openlit",
+                            SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                                application_name,
+                            SemanticConvetion.GEN_AI_SYSTEM:
+                                SemanticConvetion.GEN_AI_SYSTEM_BEDROCK,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                model
+                        }
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(
+                            input_tokens + output_tokens, attributes
+                        )
+                        metrics["genai_completion_tokens"].add(output_tokens, attributes)
+                        metrics["genai_prompt_tokens"].add(input_tokens, attributes)
+                        metrics["genai_cost"].record(cost, attributes)
                     return response
@@ -427,9 +188,10 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
         client = wrapped(*args, **kwargs)
         # Replace the original method with the instrumented one
-        original_invoke_model = client.invoke_model
-        client.invoke_model = lambda *args, **kwargs: add_instrumentation(original_invoke_model,
-                                                                          *args, **kwargs)
+        if kwargs.get("service_name") == "bedrock-runtime":
+            original_invoke_model = client.converse
+            client.converse = lambda *args, **kwargs: converse_wrapper(original_invoke_model,
+                                                                            *args, **kwargs)
         return client

openlit/instrumentation/cohere/cohere.py CHANGED Viewed

@@ -193,7 +193,7 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
                                     kwargs.get("temperature", 0.3))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                    kwargs.get("max_tokens", ""))
+                                    kwargs.get("max_tokens", -1))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
                                     kwargs.get("seed", ""))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,
@@ -336,7 +336,7 @@ def chat_stream(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
                                         kwargs.get("temperature", 0.3))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
-                                        kwargs.get("max_tokens", ""))
+                                        kwargs.get("max_tokens", -1))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
                                         kwargs.get("seed", ""))
                     span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,

openlit/instrumentation/elevenlabs/__init__.py ADDED Viewed

@@ -0,0 +1,70 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of ElevenLabs Functions"""
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+from openlit.instrumentation.elevenlabs.elevenlabs import (
+    generate
+)
+from openlit.instrumentation.elevenlabs.async_elevenlabs import (
+    async_generate
+)
+_instruments = ("elevenlabs >= 1.4.0",)
+class ElevenLabsInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for ElevenLabs's client library.
+    """
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+    def _instrument(self, **kwargs):
+        application_name = kwargs.get("application_name", "default")
+        environment = kwargs.get("environment", "default")
+        tracer = kwargs.get("tracer")
+        metrics = kwargs.get("metrics_dict")
+        pricing_info = kwargs.get("pricing_info", {})
+        trace_content = kwargs.get("trace_content", False)
+        disable_metrics = kwargs.get("disable_metrics")
+        version = importlib.metadata.version("elevenlabs")
+        # sync generate
+        wrap_function_wrapper(
+            "elevenlabs.client",
+            "ElevenLabs.generate",
+            generate("elevenlabs.generate", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        # sync text_to_speech.convert
+        wrap_function_wrapper(
+            "elevenlabs.text_to_speech.client",
+            "TextToSpeechClient.convert",
+            generate("elevenlabs.text_to_speech", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        # async generate
+        wrap_function_wrapper(
+            "elevenlabs.client",
+            "AsyncElevenLabs.generate",
+            async_generate("elevenlabs.generate", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        # sync text_to_speech.convert
+        wrap_function_wrapper(
+            "elevenlabs.text_to_speech.client",
+            "AsyncTextToSpeechClient.convert",
+            generate("elevenlabs.text_to_speech", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+    def _uninstrument(self, **kwargs):
+        # Proper uninstrumentation logic to revert patched methods
+        pass

openlit 1.14.2__py3-none-any.whl → 1.16.2__py3-none-any.whl

openlit 1.14.2py3-none-any.whl → 1.16.2py3-none-any.whl