openlit 1.34.2__py3-none-any.whl → 1.34.3__py3-none-any.whl

openlit/instrumentation/openai/__init__.py

@@ -5,9 +5,10 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.openai.openai import chat_completions, embedding, responses
+from openlit.instrumentation.openai.openai import chat_completions, embedding, responses, chat_completions_parse
 from openlit.instrumentation.openai.openai import image_generate, image_variatons, audio_create
-from openlit.instrumentation.openai.async_openai import async_chat_completions, async_embedding
+from openlit.instrumentation.openai.async_openai import (async_chat_completions, async_embedding,
+                                                         async_chat_completions_parse)
 from openlit.instrumentation.openai.async_openai import async_image_generate, async_image_variatons
 from openlit.instrumentation.openai.async_openai import async_audio_create, async_responses
 
@@ -127,6 +128,20 @@ class OpenAIInstrumentor(BaseInstrumentor):
                                metrics, disable_metrics),
         )
 
+        wrap_function_wrapper(
+            "openai.resources.beta.chat.completions",
+            "Completions.parse",
+            chat_completions_parse(version, environment, application_name, tracer, pricing_info,
+                                   capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "openai.resources.beta.chat.completions",
+            "AsyncCompletions.parse",
+            async_chat_completions_parse(version, environment, application_name, tracer, pricing_info,
+                                         capture_message_content, metrics, disable_metrics),
+        )
+
     @staticmethod
     def _uninstrument(self, **kwargs):
         pass

openlit/instrumentation/openai/async_openai.py

@@ -882,6 +882,167 @@ def async_chat_completions(version, environment, application_name,
 
     return wrapper
 
+def async_chat_completions_parse(version, environment, application_name, tracer, pricing_info, capture_message_content,
+                                 metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat completions parse to collect metrics.
+
+    Args:
+        version: Version of the monitoring package.
+        environment: Deployment environment (e.g., production, staging).
+        application_name: Name of the application using the OpenAI API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of OpenAI usage.
+        capture_message_content: Flag indicating whether to trace the actual content.
+
+    Returns:
+        A function that wraps the chat completions parse method to add telemetry.
+    """
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat.completions.parse' API call to add telemetry.
+
+        This collects metrics such as execution time, cost, and token usage, and handles errors
+        gracefully, adding details to the trace for observability.
+
+        Args:
+            wrapped: The original 'chat.completions' method to be wrapped.
+            instance: The instance of the class where the original method is defined.
+            args: Positional arguments for the 'chat.completions' method.
+            kwargs: Keyword arguments for the 'chat.completions' method.
+
+        Returns:
+            The response from the original 'chat.completions.parse' method.
+        """
+        server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)
+        request_model = kwargs.get("model", "gpt-4o")
+        span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            try:
+                # Execute the original 'parse' method
+                response = await wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = response_as_dict(response)
+
+                # Format 'messages' from kwargs to calculate input tokens
+                message_prompt = kwargs.get("messages", "")
+                formatted_messages = []
+                for message in message_prompt:
+                    role = message.get("role")
+                    content = message.get("content")
+                    if content:
+                        formatted_messages.append(f"{role}: {content}")
+                prompt = "\n".join(formatted_messages)
+
+                input_tokens = response_dict.get('usage').get('prompt_tokens')
+                output_tokens = response_dict.get('usage').get('completion_tokens')
+
+                # Calculate cost
+                cost = get_chat_model_cost(request_model,
+                                           pricing_info, input_tokens,
+                                           output_tokens)
+
+                # Set base span attribues (OTel Semconv)
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)
+                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_OPENAI)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, str(kwargs.get("seed", "")))
+                span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                   str(kwargs.get("frequency_penalty", 0.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, str(kwargs.get("max_tokens", -1)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                   str(kwargs.get("presence_penalty", 0.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, str(kwargs.get("stop", [])))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, str(kwargs.get("temperature", 1.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, str(kwargs.get("top_p", 1.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, response_dict.get("id"))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, response_dict.get('model'))
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+                span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER,
+                                   str(kwargs.get("service_tier", "auto")))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SERVICE_TIER,
+                                   response_dict.get('service_tier', 'auto'))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT,
+                                   str(response_dict.get('system_fingerprint', '')))
+
+                # Set base span attribues (Extras)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, kwargs.get("user", ""))
+                span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, False)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, input_tokens + output_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
+                span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, end_time - start_time)
+
+                if capture_message_content:
+                    span.add_event(
+                        name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt},
+                    )
+
+                for i in range(kwargs.get('n', 1)):
+                    span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,
+                                       [response_dict.get('choices')[i].get('finish_reason')])
+                    if capture_message_content:
+                        span.add_event(
+                            name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                # pylint: disable=line-too-long
+                                SemanticConvention.GEN_AI_CONTENT_COMPLETION: str(
+                                    response_dict.get('choices')[i].get('message').get('content')),
+                            },
+                        )
+                    if kwargs.get('tools'):
+                        span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALLS,
+                                           str(response_dict.get('choices')[i].get('message').get('tool_calls')))
+
+                    if isinstance(response_dict.get('choices')[i].get('message').get('content'), str):
+                        span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE,
+                                           "text")
+                    elif response_dict.get('choices')[i].get('message').get('content') is not None:
+                        span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE,
+                                           "json")
+
+                span.set_status(Status(StatusCode.OK))
+
+                if not disable_metrics:
+                    attributes = create_metrics_attributes(
+                        service_name=application_name,
+                        deployment_environment=environment,
+                        operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+                        system=SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+                        request_model=request_model,
+                        server_address=server_address,
+                        server_port=server_port,
+                        response_model=response_dict.get('model'),
+                    )
+                    metrics["genai_client_usage_tokens"].record(input_tokens + output_tokens, attributes)
+                    metrics["genai_client_operation_duration"].record(end_time - start_time, attributes)
+                    metrics["genai_server_ttft"].record( end_time - start_time, attributes)
+                    metrics["genai_requests"].add(1, 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
+
+            except Exception as e:
+                handle_exception(span, e)
+                logger.error("Error in 'parse' trace creation: %s", e)
+                # Re-raise the exception to not interfere with the application flow
+                raise
+
+    return wrapper
+
 def async_embedding(version, environment, application_name,
               tracer, pricing_info, capture_message_content, metrics, disable_metrics):
     """

openlit/instrumentation/openai/openai.py

@@ -882,6 +882,167 @@ def chat_completions(version, environment, application_name,
 
     return wrapper
 
+def chat_completions_parse(version, environment, application_name, tracer, pricing_info, capture_message_content,
+                           metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat completions parse to collect metrics.
+
+    Args:
+        version: Version of the monitoring package.
+        environment: Deployment environment (e.g., production, staging).
+        application_name: Name of the application using the OpenAI API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of OpenAI usage.
+        capture_message_content: Flag indicating whether to trace the actual content.
+
+    Returns:
+        A function that wraps the chat completions parse method to add telemetry.
+    """
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat.completions.parse' API call to add telemetry.
+
+        This collects metrics such as execution time, cost, and token usage, and handles errors
+        gracefully, adding details to the trace for observability.
+
+        Args:
+            wrapped: The original 'chat.completions' method to be wrapped.
+            instance: The instance of the class where the original method is defined.
+            args: Positional arguments for the 'chat.completions' method.
+            kwargs: Keyword arguments for the 'chat.completions' method.
+
+        Returns:
+            The response from the original 'chat.completions.parse' method.
+        """
+        server_address, server_port = set_server_address_and_port(instance, "api.openai.com", 443)
+        request_model = kwargs.get("model", "gpt-4o")
+        span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            try:
+                # Execute the original 'parse' method
+                response = wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = response_as_dict(response)
+
+                # Format 'messages' from kwargs to calculate input tokens
+                message_prompt = kwargs.get("messages", "")
+                formatted_messages = []
+                for message in message_prompt:
+                    role = message.get("role")
+                    content = message.get("content")
+                    if content:
+                        formatted_messages.append(f"{role}: {content}")
+                prompt = "\n".join(formatted_messages)
+
+                input_tokens = response_dict.get('usage').get('prompt_tokens')
+                output_tokens = response_dict.get('usage').get('completion_tokens')
+
+                # Calculate cost
+                cost = get_chat_model_cost(request_model,
+                                           pricing_info, input_tokens,
+                                           output_tokens)
+
+                # Set base span attribues (OTel Semconv)
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)
+                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_OPENAI)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, str(kwargs.get("seed", "")))
+                span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                   str(kwargs.get("frequency_penalty", 0.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, str(kwargs.get("max_tokens", -1)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                   str(kwargs.get("presence_penalty", 0.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, str(kwargs.get("stop", [])))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, str(kwargs.get("temperature", 1.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, str(kwargs.get("top_p", 1.0)))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, response_dict.get("id"))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, response_dict.get('model'))
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+                span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER,
+                                   str(kwargs.get("service_tier", "auto")))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SERVICE_TIER,
+                                   response_dict.get('service_tier', 'auto'))
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT,
+                                   str(response_dict.get('system_fingerprint', '')))
+
+                # Set base span attribues (Extras)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, kwargs.get("user", ""))
+                span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
+                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, False)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, input_tokens + output_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
+                span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, end_time - start_time)
+
+                if capture_message_content:
+                    span.add_event(
+                        name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt},
+                    )
+
+                for i in range(kwargs.get('n', 1)):
+                    span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,
+                                       [response_dict.get('choices')[i].get('finish_reason')])
+                    if capture_message_content:
+                        span.add_event(
+                            name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                # pylint: disable=line-too-long
+                                SemanticConvention.GEN_AI_CONTENT_COMPLETION: str(
+                                    response_dict.get('choices')[i].get('message').get('content')),
+                            },
+                        )
+                    if kwargs.get('tools'):
+                        span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALLS,
+                                           str(response_dict.get('choices')[i].get('message').get('tool_calls')))
+
+                    if isinstance(response_dict.get('choices')[i].get('message').get('content'), str):
+                        span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE,
+                                           "text")
+                    elif response_dict.get('choices')[i].get('message').get('content') is not None:
+                        span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE,
+                                           "json")
+
+                span.set_status(Status(StatusCode.OK))
+
+                if not disable_metrics:
+                    attributes = create_metrics_attributes(
+                        service_name=application_name,
+                        deployment_environment=environment,
+                        operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+                        system=SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+                        request_model=request_model,
+                        server_address=server_address,
+                        server_port=server_port,
+                        response_model=response_dict.get('model'),
+                    )
+                    metrics["genai_client_usage_tokens"].record(input_tokens + output_tokens, attributes)
+                    metrics["genai_client_operation_duration"].record(end_time - start_time, attributes)
+                    metrics["genai_server_ttft"].record( end_time - start_time, attributes)
+                    metrics["genai_requests"].add(1, 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
+
+            except Exception as e:
+                handle_exception(span, e)
+                logger.error("Error in 'parse' trace creation: %s", e)
+                # Re-raise the exception to not interfere with the application flow
+                raise
+
+    return wrapper
+
 def embedding(version, environment, application_name,
               tracer, pricing_info, capture_message_content, metrics, disable_metrics):
     """

{openlit-1.34.2.dist-info → openlit-1.34.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openlit
-Version: 1.34.2
+Version: 1.34.3
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects
 License: Apache-2.0
 Keywords: OpenTelemetry,otel,otlp,llm,tracing,openai,anthropic,claude,cohere,llm monitoring,observability,monitoring,gpt,Generative AI,chatGPT,gpu

{openlit-1.34.2.dist-info → openlit-1.34.3.dist-info}/RECORD

@@ -95,9 +95,9 @@ openlit/instrumentation/ollama/__init__.py,sha256=v7VhVxHw_c6QtMznxe6a7z6QrYHZsH
 openlit/instrumentation/ollama/async_ollama.py,sha256=zJPDr2ROh1nvFGoxgdTbe04Zr1KhmgJUYFPeuRLQGLk,6667
 openlit/instrumentation/ollama/ollama.py,sha256=MNUltiP9XVT4azmO_-E2vjhFaoHQyJ0Z6c-HnB0_jCE,6563
 openlit/instrumentation/ollama/utils.py,sha256=41uvYaYkGwWfRyHYqhOOwrFy6cMzBlG1urJYUat9Q24,14819
-openlit/instrumentation/openai/__init__.py,sha256=FiL4OHDhs957spa3k9sNC_VLt0-txtwbnujQwnevQ5I,5564
-openlit/instrumentation/openai/async_openai.py,sha256=gxA9Fs_b0hsOlJh8F55zi0TqgarJUlZA6eK1-ghvy90,71945
-openlit/instrumentation/openai/openai.py,sha256=Gky-NPUhjXhGOG4nWKkuKGTEKWJSgebzHb5dmqJp7fU,71754
+openlit/instrumentation/openai/__init__.py,sha256=y9Ox5aYWTb2nAa_d0ic3Mkv4wEKmUGqslW9nHKg6NnY,6320
+openlit/instrumentation/openai/async_openai.py,sha256=JkpVcyOhGvPzhqxzeP01MwwfaYhddNsSUQqgfF8hU8I,81390
+openlit/instrumentation/openai/openai.py,sha256=5fgRyK5dUN2zUdrN0vBSZFnSEAXf2dKS0qnq_85-mQE,81175
 openlit/instrumentation/openai_agents/__init__.py,sha256=tRTSIrUtkXc_lfQnVanXmQLd2Sy9RqBNTHF5FhhZx7o,1530
 openlit/instrumentation/openai_agents/openai_agents.py,sha256=kRWPgjofcOviMi3w7CsRvJO3SCjqPmuq-PM800vIM7g,2678
 openlit/instrumentation/phidata/__init__.py,sha256=tqls5-UI6FzbjxYgq_qqAfALhWJm8dHn2NtgqiQA4f8,1557
@@ -131,7 +131,7 @@ openlit/otel/events.py,sha256=VrMjTpvnLtYRBHCiFwJojTQqqNpRCxoD4yJYeQrtPsk,3560
 openlit/otel/metrics.py,sha256=GM2PDloBGRhBTkHHkYaqmOwIAQkY124ZhW4sEqW1Fgk,7086
 openlit/otel/tracing.py,sha256=tjV2bEbEDPUB1Z46gE-UsJsb04sRdFrfbhIDkxViZc0,3103
 openlit/semcov/__init__.py,sha256=ptyo37PY-FHDx_PShEvbdns71cD4YvvXw15bCRXKCKM,13461
-openlit-1.34.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.34.2.dist-info/METADATA,sha256=WpHx9DGPjkfepoQxJVxsc6LtuwK9gzJNqFijGAs-JAc,23469
-openlit-1.34.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-openlit-1.34.2.dist-info/RECORD,,
+openlit-1.34.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.34.3.dist-info/METADATA,sha256=8_jDnUBC1cxAr2DNwkg5IXbNQX2qru-_nC7OpwC6Jh8,23469
+openlit-1.34.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+openlit-1.34.3.dist-info/RECORD,,