PyPI - openlit - Versions diffs - 1.18.2__py3-none-any.whl → 1.20.0__py3-none-any.whl - Mend

openlit 1.18.2py3-none-any.whl → 1.20.0py3-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 (11) hide show

openlit/__init__.py CHANGED Viewed

@@ -33,6 +33,7 @@ from openlit.instrumentation.ollama import OllamaInstrumentor
 from openlit.instrumentation.gpt4all import GPT4AllInstrumentor
 from openlit.instrumentation.elevenlabs import ElevenLabsInstrumentor
 from openlit.instrumentation.vllm import VLLMInstrumentor
+from openlit.instrumentation.google_ai_studio import GoogleAIStudioInstrumentor
 from openlit.instrumentation.langchain import LangChainInstrumentor
 from openlit.instrumentation.llamaindex import LlamaIndexInstrumentor
 from openlit.instrumentation.haystack import HaystackInstrumentor
@@ -196,6 +197,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "gpt4all": "gpt4all",
         "elevenlabs": "elevenlabs",
         "vllm": "vllm",
+        "google-ai-studio": "google.generativeai",
         "langchain": "langchain",
         "llama_index": "llama_index",
         "haystack": "haystack",
@@ -273,6 +275,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "gpt4all": GPT4AllInstrumentor(),
             "elevenlabs": ElevenLabsInstrumentor(),
             "vllm": VLLMInstrumentor(),
+            "google-ai-studio": GoogleAIStudioInstrumentor(),
             "langchain": LangChainInstrumentor(),
             "llama_index": LlamaIndexInstrumentor(),
             "haystack": HaystackInstrumentor(),

openlit/instrumentation/google_ai_studio/__init__.py ADDED Viewed

@@ -0,0 +1,56 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of Google AI Studio Functions"""
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+from openlit.instrumentation.google_ai_studio.google_ai_studio import (
+    generate
+)
+from openlit.instrumentation.google_ai_studio.async_google_ai_studio import (
+    async_generate
+)
+_instruments = ("google-generativeai >= 0.2.0",)
+class GoogleAIStudioInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for google-generativeai's client library.
+    """
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+    def _instrument(self, **kwargs):
+        application_name = kwargs.get("application_name", "default_application")
+        environment = kwargs.get("environment", "default_environment")
+        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("ollama")
+        # sync generate
+        wrap_function_wrapper(
+            "google.generativeai.generative_models",
+            "GenerativeModel.generate_content",
+            generate("google_ai_studio.generate_content", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        # async generate
+        wrap_function_wrapper(
+            "google.generativeai.generative_models",
+            "GenerativeModel.generate_content_async",
+            async_generate("google_ai_studio.generate_content", 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/instrumentation/google_ai_studio/async_google_ai_studio.py ADDED Viewed

@@ -0,0 +1,259 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, protected-access
+"""
+Module for monitoring Ollama API calls.
+"""
+import logging
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import (
+    handle_exception,
+    get_chat_model_cost,
+)
+from openlit.semcov import SemanticConvetion
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+def async_generate(gen_ai_endpoint, version, environment, application_name,
+                     tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat to collect metrics.
+    Args:
+        gen_ai_endpoint: Endpoint identifier for logging and tracing.
+        version: Version of the monitoring package.
+        environment: Deployment environment (e.g., production, staging).
+        application_name: Name of the application using the Ollama API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of Ollama usage.
+        trace_content: Flag indicating whether to trace the actual content.
+    Returns:
+        A function that wraps the chat method to add telemetry.
+    """
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat' 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' method to be wrapped.
+            instance: The instance of the class where the original method is defined.
+            args: Positional arguments for the 'chat' method.
+            kwargs: Keyword arguments for the 'chat' method.
+        Returns:
+            The response from the original 'chat' method.
+        """
+        # pylint: disable=no-else-return
+        if kwargs.get('stream', False) is True:
+            # Special handling for streaming response to accommodate the nature of data flow
+            async def stream_generator():
+                with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+                    # Placeholder for aggregating streaming response
+                    llmresponse = ""
+                    # Loop through streaming events capturing relevant details
+                    async for chunk in await wrapped(*args, **kwargs):
+                        # Collect message IDs and aggregated response from events
+                        content = chunk.text
+                        if content:
+                            llmresponse += content
+                        input_tokens = chunk.usage_metadata.prompt_token_count
+                        output_tokens = chunk.usage_metadata.candidates_token_count
+                        yield chunk
+                    # Handling exception ensure observability without disrupting operation
+                    try:
+                        prompt = ""
+                        for arg in args:
+                            if isinstance(arg, str):
+                                prompt = f"{prompt}{arg}\n"
+                            elif isinstance(arg, list):
+                                for subarg in arg:
+                                    prompt = f"{prompt}{subarg}\n"
+                        if hasattr(instance, "_model_id"):
+                            model = instance._model_id
+                        if hasattr(instance, "_model_name"):
+                            model = instance._model_name.replace("publishers/google/models/", "")
+                        total_tokens = input_tokens + output_tokens
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, input_tokens,
+                                                    output_tokens)
+                        # Set Span attributes
+                        span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                        span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                            SemanticConvetion.GEN_AI_SYSTEM_GOOGLE_AI_STUDIO)
+                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                            SemanticConvetion.GEN_AI_TYPE_CHAT)
+                        span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                            gen_ai_endpoint)
+                        span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                            environment)
+                        span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                            application_name)
+                        span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                            model)
+                        span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                            True)
+                        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,
+                                            total_tokens)
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                            cost)
+                        if trace_content:
+                            span.add_event(
+                                name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                                attributes={
+                                    SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                                },
+                            )
+                            span.add_event(
+                                name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                                attributes={
+                                    SemanticConvetion.GEN_AI_CONTENT_COMPLETION: llmresponse,
+                                },
+                            )
+                        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_GOOGLE_AI_STUDIO,
+                                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(
+                                total_tokens, attributes
+                            )
+                            metrics["genai_completion_tokens"].add(output_tokens, attributes)
+                            metrics["genai_prompt_tokens"].add(input_tokens, attributes)
+                            metrics["genai_cost"].record(cost, attributes)
+                    except Exception as e:
+                        handle_exception(span, e)
+                        logger.error("Error in trace creation: %s", e)
+            return stream_generator()
+        else:
+            # pylint: disable=line-too-long
+            with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+                response = await wrapped(*args, **kwargs)
+                try:
+                    prompt = ""
+                    for arg in args:
+                        if isinstance(arg, str):
+                            prompt = f"{prompt}{arg}\n"
+                        elif isinstance(arg, list):
+                            for subarg in arg:
+                                prompt = f"{prompt}{subarg}\n"
+                    if hasattr(instance, "_model_id"):
+                        model = instance._model_id
+                    if hasattr(instance, "_model_name"):
+                        model = instance._model_name.replace("publishers/google/models/", "")
+                    # Set base span attribues
+                    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_GOOGLE_AI_STUDIO)
+                    span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                        gen_ai_endpoint)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                        environment)
+                    span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                        application_name)
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                        model)
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                        False)
+                    if trace_content:
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                            },
+                        )
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response.text,
+                            },
+                        )
+                    prompt_tokens = response.usage_metadata.prompt_token_count
+                    completion_tokens = response.usage_metadata.candidates_token_count
+                    total_tokens = response.usage_metadata.total_token_count
+                    # Calculate cost of the operation
+                    cost = get_chat_model_cost(kwargs.get("model", "llama3"),
+                                                pricing_info, prompt_tokens, completion_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,
+                                        total_tokens)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                        cost)
+                    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_OLLAMA,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                kwargs.get("model", "llama3")
+                        }
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(total_tokens, attributes)
+                        metrics["genai_completion_tokens"].add(completion_tokens, attributes)
+                        metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                        metrics["genai_cost"].record(cost, attributes)
+                    # Return original response
+                    return response
+                except Exception as e:
+                    handle_exception(span, e)
+                    logger.error("Error in trace creation: %s", e)
+                    # Return original response
+                    return response
+    return wrapper

openlit/instrumentation/google_ai_studio/google_ai_studio.py ADDED Viewed

@@ -0,0 +1,261 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, protected-access
+"""
+Module for monitoring Ollama API calls.
+"""
+import logging
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import (
+    handle_exception,
+    get_chat_model_cost,
+)
+from openlit.semcov import SemanticConvetion
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+def generate(gen_ai_endpoint, version, environment, application_name,
+                     tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat to collect metrics.
+    Args:
+        gen_ai_endpoint: Endpoint identifier for logging and tracing.
+        version: Version of the monitoring package.
+        environment: Deployment environment (e.g., production, staging).
+        application_name: Name of the application using the Ollama API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of Ollama usage.
+        trace_content: Flag indicating whether to trace the actual content.
+    Returns:
+        A function that wraps the chat method to add telemetry.
+    """
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat' 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' method to be wrapped.
+            instance: The instance of the class where the original method is defined.
+            args: Positional arguments for the 'chat' method.
+            kwargs: Keyword arguments for the 'chat' method.
+        Returns:
+            The response from the original 'chat' method.
+        """
+        # pylint: disable=no-else-return
+        if kwargs.get("stream", False) is True:
+            # Special handling for streaming response to accommodate the nature of data flow
+            def stream_generator():
+                with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+                    # Placeholder for aggregating streaming response
+                    llmresponse = ""
+                    # Loop through streaming events capturing relevant details
+                    for chunk in wrapped(*args, **kwargs):
+                        # Collect message IDs and aggregated response from events
+                        content = chunk.text
+                        if content:
+                            llmresponse += content
+                        input_tokens = chunk.usage_metadata.prompt_token_count
+                        output_tokens = chunk.usage_metadata.candidates_token_count
+                        yield chunk
+                    # Handling exception ensure observability without disrupting operation
+                    try:
+                        prompt = ""
+                        for arg in args:
+                            if isinstance(arg, str):
+                                prompt = f"{prompt}{arg}\n"
+                            elif isinstance(arg, list):
+                                for subarg in arg:
+                                    prompt = f"{prompt}{subarg}\n"
+                        if hasattr(instance, "_model_id"):
+                            model = instance._model_id
+                        if hasattr(instance, "_model_name"):
+                            model = instance._model_name.replace("publishers/google/models/", "")
+                        total_tokens = input_tokens + output_tokens
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, input_tokens,
+                                                    output_tokens)
+                        # Set Span attributes
+                        span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                        span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                            SemanticConvetion.GEN_AI_SYSTEM_GOOGLE_AI_STUDIO)
+                        span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                            SemanticConvetion.GEN_AI_TYPE_CHAT)
+                        span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                            gen_ai_endpoint)
+                        span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                            environment)
+                        span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                            application_name)
+                        span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                            model)
+                        span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                            True)
+                        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,
+                                            total_tokens)
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                            cost)
+                        if trace_content:
+                            span.add_event(
+                                name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                                attributes={
+                                    SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                                },
+                            )
+                            span.add_event(
+                                name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                                attributes={
+                                    SemanticConvetion.GEN_AI_CONTENT_COMPLETION: llmresponse,
+                                },
+                            )
+                        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_GOOGLE_AI_STUDIO,
+                                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(
+                                total_tokens, attributes
+                            )
+                            metrics["genai_completion_tokens"].add(output_tokens, attributes)
+                            metrics["genai_prompt_tokens"].add(input_tokens, attributes)
+                            metrics["genai_cost"].record(cost, attributes)
+                    except Exception as e:
+                        handle_exception(span, e)
+                        logger.error("Error in trace creation: %s", e)
+            return stream_generator()
+        else:
+            # pylint: disable=line-too-long
+            with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+                response = wrapped(*args, **kwargs)
+                # print(instance._system_instruction.__dict__["_pb"].parts[0].text)
+                try:
+                    prompt = ""
+                    for arg in args:
+                        if isinstance(arg, str):
+                            prompt = f"{prompt}{arg}\n"
+                        elif isinstance(arg, list):
+                            for subarg in arg:
+                                prompt = f"{prompt}{subarg}\n"
+                    if hasattr(instance, "_model_id"):
+                        model = instance._model_id
+                    if hasattr(instance, "_model_name"):
+                        model = instance._model_name.replace("publishers/google/models/", "")
+                    # Set base span attribues
+                    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_GOOGLE_AI_STUDIO)
+                    span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                        gen_ai_endpoint)
+                    span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                        environment)
+                    span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                        application_name)
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                        model)
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                        False)
+                    if trace_content:
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                            },
+                        )
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response.text,
+                            },
+                        )
+                    prompt_tokens = response.usage_metadata.prompt_token_count
+                    completion_tokens = response.usage_metadata.candidates_token_count
+                    total_tokens = response.usage_metadata.total_token_count
+                    # Calculate cost of the operation
+                    cost = get_chat_model_cost(kwargs.get("model", "llama3"),
+                                                pricing_info, prompt_tokens, completion_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,
+                                        total_tokens)
+                    span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                        cost)
+                    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_OLLAMA,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                kwargs.get("model", "llama3")
+                        }
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(total_tokens, attributes)
+                        metrics["genai_completion_tokens"].add(completion_tokens, attributes)
+                        metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                        metrics["genai_cost"].record(cost, attributes)
+                    # Return original response
+                    return response
+                except Exception as e:
+                    handle_exception(span, e)
+                    logger.error("Error in trace creation: %s", e)
+                    # Return original response
+                    return response
+    return wrapper

openlit/instrumentation/langchain/__init__.py CHANGED Viewed

@@ -5,7 +5,14 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
-from openlit.instrumentation.langchain.langchain import general_wrap, hub, llm, allm
+from openlit.instrumentation.langchain.langchain import (
+    general_wrap,
+    hub,
+    llm,
+    allm,
+    chat,
+    achat
+)
 _instruments = ("langchain >= 0.1.20",)
@@ -52,6 +59,18 @@ WRAPPED_METHODS = [
         "endpoint": "langchain.llm",
         "wrapper": allm,
     },
+    {
+        "package": "langchain_core.language_models.chat_models",
+        "object": "BaseChatModel.invoke",
+        "endpoint": "langchain.chat_models",
+        "wrapper": chat,
+    },
+    {
+        "package": "langchain_core.language_models.chat_models",
+        "object": "BaseChatModel.ainvoke",
+        "endpoint": "langchain.chat_models",
+        "wrapper": achat,
+    },
 ]
 class LangChainInstrumentor(BaseInstrumentor):
@@ -66,6 +85,8 @@ class LangChainInstrumentor(BaseInstrumentor):
         tracer = kwargs.get("tracer")
         pricing_info = kwargs.get("pricing_info")
         trace_content = kwargs.get("trace_content")
+        metrics = kwargs.get("metrics_dict")
+        disable_metrics = kwargs.get("disable_metrics")
         version = importlib.metadata.version("langchain")
         for wrapped_method in WRAPPED_METHODS:
@@ -77,7 +98,7 @@ class LangChainInstrumentor(BaseInstrumentor):
                 wrap_package,
                 wrap_object,
                 wrapper(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content),
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
             )
     @staticmethod

openlit/instrumentation/langchain/langchain.py CHANGED Viewed

@@ -1,4 +1,4 @@
-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, unused-import
 """
 Module for monitoring Langchain applications.
 """
@@ -6,14 +6,14 @@ Module for monitoring Langchain applications.
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
 from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
-from openlit.__helpers import handle_exception
+from openlit.__helpers import handle_exception, get_chat_model_cost, general_tokens
 from openlit.semcov import SemanticConvetion
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 def general_wrap(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content):
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
@@ -86,7 +86,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
     return wrapper
 def hub(gen_ai_endpoint, version, environment, application_name, tracer,
-        pricing_info, trace_content):
+        pricing_info, trace_content, metrics, disable_metrics):
     """
     Creates a wrapper around Langchain hub operations for tracing and logging.
@@ -162,7 +162,7 @@ def hub(gen_ai_endpoint, version, environment, application_name, tracer,
 def allm(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content):
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
@@ -207,6 +207,16 @@ def allm(gen_ai_endpoint, version, environment, application_name,
             response = await wrapped(*args, **kwargs)
             try:
+                prompt = args[0] or ""
+                # input_tokens = general_tokens(prompt)
+                # output_tokens = general_tokens(response)
+                # # Calculate cost of the operation
+                # cost = get_chat_model_cost(
+                #     str(getattr(instance, 'model')),
+                #     pricing_info, input_tokens, output_tokens
+                # )
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
                 span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
                                     SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
@@ -226,13 +236,56 @@ def allm(gen_ai_endpoint, version, environment, application_name,
                                     str(getattr(instance, 'top_k')))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
                                     str(getattr(instance, 'top_p')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                    False)
+                # 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)
+                # span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                #                     cost)
                 if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                        args[0])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                        response)
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                        },
+                    )
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response,
+                        },
+                    )
                 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_LANGCHAIN,
+                #         SemanticConvetion.GEN_AI_ENVIRONMENT:
+                #             environment,
+                #         SemanticConvetion.GEN_AI_TYPE:
+                #             SemanticConvetion.GEN_AI_TYPE_CHAT,
+                #         SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                #             str(getattr(instance, '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 original response
                 return response
@@ -246,7 +299,7 @@ def allm(gen_ai_endpoint, version, environment, application_name,
     return wrapper
 def llm(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content):
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
@@ -291,6 +344,16 @@ def llm(gen_ai_endpoint, version, environment, application_name,
             response = wrapped(*args, **kwargs)
             try:
+                prompt = args[0] or ""
+                # input_tokens = general_tokens(prompt)
+                # output_tokens = general_tokens(response)
+                # # Calculate cost of the operation
+                # cost = get_chat_model_cost(
+                #     str(getattr(instance, 'model')),
+                #     pricing_info, input_tokens, output_tokens
+                # )
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
                 span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
                                     SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
@@ -310,13 +373,332 @@ def llm(gen_ai_endpoint, version, environment, application_name,
                                     str(getattr(instance, 'top_k')))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
                                     str(getattr(instance, 'top_p')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                    False)
+                # 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)
+                # span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                #                     cost)
+                if trace_content:
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                        },
+                    )
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response,
+                        },
+                    )
+                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_LANGCHAIN,
+                #         SemanticConvetion.GEN_AI_ENVIRONMENT:
+                #             environment,
+                #         SemanticConvetion.GEN_AI_TYPE:
+                #             SemanticConvetion.GEN_AI_TYPE_CHAT,
+                #         SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                #             str(getattr(instance, '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 original response
+                return response
+            except Exception as e:
+                handle_exception(span, e)
+                logger.error("Error in trace creation: %s", e)
+                # Return original response
+                return response
+    return wrapper
+def chat(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Creates a wrapper around a function call to trace and log its execution metrics.
+    This function wraps any given function to measure its execution time,
+    log its operation, and trace its execution using OpenTelemetry.
+    Parameters:
+    - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.
+    - version (str): The version of the Langchain application.
+    - environment (str): The deployment environment (e.g., 'production', 'development').
+    - application_name (str): Name of the Langchain application.
+    - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.
+    - pricing_info (dict): Information about the pricing for internal metrics (currently not used).
+    - trace_content (bool): Flag indicating whether to trace the content of the response.
+    Returns:
+    - function: A higher-order function that takes a function 'wrapped' and returns
+                a new function that wraps 'wrapped' with additional tracing and logging.
+    """
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        An inner wrapper function that executes the wrapped function, measures execution
+        time, and records trace data using OpenTelemetry.
+        Parameters:
+        - wrapped (Callable): The original function that this wrapper will execute.
+        - instance (object): The instance to which the wrapped function belongs. This
+                             is used for instance methods. For static and classmethods,
+                             this may be None.
+        - args (tuple): Positional arguments passed to the wrapped function.
+        - kwargs (dict): Keyword arguments passed to the wrapped function.
+        Returns:
+        - The result of the wrapped function call.
+        The wrapper initiates a span with the provided tracer, sets various attributes
+        on the span based on the function's execution and response, and ensures
+        errors are handled and logged appropriately.
+        """
+        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+            response = wrapped(*args, **kwargs)
+            try:
+                input_tokens = response.response_metadata["prompt_eval_count"] or 0
+                output_tokens = response.response_metadata["eval_count"] or 0
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(
+                    str(getattr(instance, 'model')),
+                    pricing_info, input_tokens, output_tokens
+                )
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                    gen_ai_endpoint)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                    environment)
+                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                    SemanticConvetion.GEN_AI_TYPE_CHAT)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                    application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                    str(getattr(instance, 'model')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                    str(getattr(instance, 'temperature')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
+                                    str(getattr(instance, 'top_k')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                    str(getattr(instance, 'top_p')))
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    [response.response_metadata["done_reason"]])
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                    False)
+                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)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                    cost)
                 if trace_content:
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_PROMPT,
-                                        args[0])
-                    span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION,
-                                        response)
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: args[0],
+                        },
+                    )
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response.content,
+                        },
+                    )
                 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_LANGCHAIN,
+                        SemanticConvetion.GEN_AI_ENVIRONMENT:
+                            environment,
+                        SemanticConvetion.GEN_AI_TYPE:
+                            SemanticConvetion.GEN_AI_TYPE_CHAT,
+                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                            str(getattr(instance, '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 original response
+                return response
+            except Exception as e:
+                handle_exception(span, e)
+                logger.error("Error in trace creation: %s", e)
+                # Return original response
+                return response
+    return wrapper
+def achat(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Creates a wrapper around a function call to trace and log its execution metrics.
+    This function wraps any given function to measure its execution time,
+    log its operation, and trace its execution using OpenTelemetry.
+    Parameters:
+    - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.
+    - version (str): The version of the Langchain application.
+    - environment (str): The deployment environment (e.g., 'production', 'development').
+    - application_name (str): Name of the Langchain application.
+    - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.
+    - pricing_info (dict): Information about the pricing for internal metrics (currently not used).
+    - trace_content (bool): Flag indicating whether to trace the content of the response.
+    Returns:
+    - function: A higher-order function that takes a function 'wrapped' and returns
+                a new function that wraps 'wrapped' with additional tracing and logging.
+    """
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        An inner wrapper function that executes the wrapped function, measures execution
+        time, and records trace data using OpenTelemetry.
+        Parameters:
+        - wrapped (Callable): The original function that this wrapper will execute.
+        - instance (object): The instance to which the wrapped function belongs. This
+                             is used for instance methods. For static and classmethods,
+                             this may be None.
+        - args (tuple): Positional arguments passed to the wrapped function.
+        - kwargs (dict): Keyword arguments passed to the wrapped function.
+        Returns:
+        - The result of the wrapped function call.
+        The wrapper initiates a span with the provided tracer, sets various attributes
+        on the span based on the function's execution and response, and ensures
+        errors are handled and logged appropriately.
+        """
+        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+            response = await wrapped(*args, **kwargs)
+            try:
+                input_tokens = response.response_metadata["prompt_eval_count"] or 0
+                output_tokens = response.response_metadata["eval_count"] or 0
+                # Calculate cost of the operation
+                cost = get_chat_model_cost(
+                    str(getattr(instance, 'model')),
+                    pricing_info, input_tokens, output_tokens
+                )
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                    gen_ai_endpoint)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                    environment)
+                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                    SemanticConvetion.GEN_AI_TYPE_CHAT)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                    application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                    str(getattr(instance, 'model')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                    str(getattr(instance, 'temperature')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
+                                    str(getattr(instance, 'top_k')))
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                    str(getattr(instance, 'top_p')))
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                    [response.response_metadata["done_reason"]])
+                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                    False)
+                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)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                    cost)
+                if trace_content:
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: args[0],
+                        },
+                    )
+                    span.add_event(
+                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                        attributes={
+                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response.content,
+                        },
+                    )
+                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_LANGCHAIN,
+                        SemanticConvetion.GEN_AI_ENVIRONMENT:
+                            environment,
+                        SemanticConvetion.GEN_AI_TYPE:
+                            SemanticConvetion.GEN_AI_TYPE_CHAT,
+                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                            str(getattr(instance, '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 original response
                 return response

openlit/semcov/__init__.py CHANGED Viewed

@@ -102,6 +102,7 @@ class SemanticConvetion:
     GEN_AI_SYSTEM_GPT4ALL = "gpt4all"
     GEN_AI_SYSTEM_ELEVENLABS = "elevenlabs"
     GEN_AI_SYSTEM_VLLM = "vLLM"
+    GEN_AI_SYSTEM_GOOGLE_AI_STUDIO = "google-ai-studio"
     GEN_AI_SYSTEM_LANGCHAIN = "langchain"
     GEN_AI_SYSTEM_LLAMAINDEX = "llama_index"
     GEN_AI_SYSTEM_HAYSTACK = "haystack"

{openlit-1.18.2.dist-info → openlit-1.20.0.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 1.18.2
+Version: 1.20.0
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects
 Home-page: https://github.com/openlit/openlit/tree/main/openlit/python
 Keywords: OpenTelemetry,otel,otlp,llm,tracing,openai,anthropic,claude,cohere,llm monitoring,observability,monitoring,gpt,Generative AI,chatGPT,gpu
@@ -60,15 +60,17 @@ This project adheres to the [Semantic Conventions](https://github.com/open-telem
 | [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)              | [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)       | [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)         |               |
 | [✅ Anthropic](https://docs.openlit.io/latest/integrations/anthropic)        | [✅ Qdrant](https://docs.openlit.io/latest/integrations/qdrant)           | [✅ LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index)  |               |
 | [✅ GPT4All](https://docs.openlit.io/latest/integrations/gpt4all)            | [✅ Milvus](https://docs.openlit.io/latest/integrations/milvus)           | [✅ Haystack](https://docs.openlit.io/latest/integrations/haystack)       |               |
-| [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)              |                                                                          | [✅ EmbedChain](https://docs.openlit.io/latest/integrations/embedchain)   |               |
-| [✅ Mistral](https://docs.openlit.io/latest/integrations/mistral)            |                                                                          |                                       |               |
-| [✅ Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai)  |                                                                          |                                        |               |
-| [✅ HuggingFace Transformers](https://docs.openlit.io/latest/integrations/huggingface) |                                                                          |                                       |               |
-| [✅ Amazon Bedrock](https://docs.openlit.io/latest/integrations/bedrock)     |                                                                          |                                        |               |
+| [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)              |                                          | [✅ EmbedChain](https://docs.openlit.io/latest/integrations/embedchain)   |               |
+| [✅ Mistral](https://docs.openlit.io/latest/integrations/mistral)            |                                                                          | [✅ Guardrails](https://docs.openlit.io/latest/integrations/guardrails)   |               |
+| [✅ Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai)  |                                                                          |                                       |               |
+| [✅ HuggingFace Transformers](https://docs.openlit.io/latest/integrations/huggingface) |                                                                          |                                        |               |
+| [✅ Amazon Bedrock](https://docs.openlit.io/latest/integrations/bedrock)     |                                                                          |                                       |               |
 | [✅ Vertex AI](https://docs.openlit.io/latest/integrations/vertexai)         |                                                                          |                                       |               |
 | [✅ Groq](https://docs.openlit.io/latest/integrations/groq)                  |                                                                          |                                       |               |
 | [✅ ElevenLabs](https://docs.openlit.io/latest/integrations/elevenlabs)      |                                                                          |                                       |               |
 | [✅ vLLM](https://docs.openlit.io/latest/integrations/vllm)                  |                                                                          |                                       |               |
+| [✅ OLA Krutrim](https://docs.openlit.io/latest/integrations/krutrim)                  |                                                                          |                                       |               |
+| [✅ Google AI Studio](https://docs.openlit.io/latest/integrations/google-ai-studio) |                                                                          |                                       |               |
 ## Supported Destinations
 - [✅ OpenTelemetry Collector](https://docs.openlit.io/latest/connections/otelcol)
@@ -77,8 +79,10 @@ This project adheres to the [Semantic Conventions](https://github.com/open-telem
 - [✅ Grafana Cloud](https://docs.openlit.io/latest/connections/grafanacloud)
 - [✅ New Relic](https://docs.openlit.io/latest/connections/new-relic)
 - [✅ Elastic](https://docs.openlit.io/latest/connections/elastic)
+- [✅ HyperDX](https://docs.openlit.io/latest/connections/hyperdx)
 - [✅ DataDog](https://docs.openlit.io/latest/connections/datadog)
 - [✅ SigNoz](https://docs.openlit.io/latest/connections/signoz)
+- [✅ OneUptime](https://docs.openlit.io/latest/connections/oneuptime)
 - [✅ Dynatrace](https://docs.openlit.io/latest/connections/dynatrace)
 - [✅ OpenObserve](https://docs.openlit.io/latest/connections/openobserve)
 - [✅ Highlight.io](https://docs.openlit.io/latest/connections/highlight)

{openlit-1.18.2.dist-info → openlit-1.20.0.dist-info}/RECORD RENAMED Viewed

@@ -1,5 +1,5 @@
 openlit/__helpers.py,sha256=lrn4PBs9owDudiCY2NBoVbAi7AU_HtUpyOj0oqPBsPY,5545
-openlit/__init__.py,sha256=LfU5w-D62u5pY70DdNbv5_DGtqeL1Yb0TlY-l0NAn8I,15103
+openlit/__init__.py,sha256=fqeMFg76VYEX4VdxTn76Fh-0kbrN5_Sk8ahlm7Xlp9k,15296
 openlit/instrumentation/anthropic/__init__.py,sha256=oaU53BOPyfUKbEzYvLr1DPymDluurSnwo4Hernf2XdU,1955
 openlit/instrumentation/anthropic/anthropic.py,sha256=y7CEGhKOGHWt8G_5Phr4qPJTfPGRJIAr9Yk6nM3CcvM,16775
 openlit/instrumentation/anthropic/async_anthropic.py,sha256=Zz1KRKIG9wGn0quOoLvjORC-49IvHQpJ6GBdB-4PfCQ,16816
@@ -14,6 +14,9 @@ openlit/instrumentation/elevenlabs/async_elevenlabs.py,sha256=yMYACh95SFr5EYklKn
 openlit/instrumentation/elevenlabs/elevenlabs.py,sha256=mFnD7sgT47OxaXJz0Vc1nrNjXEpcGQDj5run3gA48Lw,6089
 openlit/instrumentation/embedchain/__init__.py,sha256=8TYk1OEbz46yF19dr-gB_x80VZMagU3kJ8-QihPXTeA,1929
 openlit/instrumentation/embedchain/embedchain.py,sha256=SLlr7qieT3kp4M6OYSRy8FaVCXQ2t3oPyIiE99ioNE4,7892
+openlit/instrumentation/google_ai_studio/__init__.py,sha256=vG4WzaavOiiwI3r5stDMotM5TSBxdcxQhC3W4XjJIG8,2146
+openlit/instrumentation/google_ai_studio/async_google_ai_studio.py,sha256=cEy5FNu92gvdmsKKVDrUcY5LpY4hHzWwJl9yezxN-Zo,13404
+openlit/instrumentation/google_ai_studio/google_ai_studio.py,sha256=mLABvD756GEgVfAjiYsfLYWATT1AxPuWDuElwpX4voo,13453
 openlit/instrumentation/gpt4all/__init__.py,sha256=-59CP2B3-HGZJ_vC-fI9Dt-0BuQXRhSCWCjnaGeU15Q,1802
 openlit/instrumentation/gpt4all/gpt4all.py,sha256=dbxqZeuTrv_y6wyDOIEmC8-Dc4iCGgLpj3l5JiodLMI,18787
 openlit/instrumentation/gpu/__init__.py,sha256=Dj2MLar0DB20-t6W3pfR-3jfR_mwg4SYwhzIrH_n9sU,5596
@@ -22,8 +25,8 @@ openlit/instrumentation/groq/async_groq.py,sha256=myob-d9V66YiNmkFd9rtmMaXjlLiSM
 openlit/instrumentation/groq/groq.py,sha256=m4gFPbYzjUUIgjXZ0Alu2Zy1HcO5takCFA2XFnkcGVo,19975
 openlit/instrumentation/haystack/__init__.py,sha256=QK6XxxZUHX8vMv2Crk7rNBOc64iOOBLhJGL_lPlAZ8s,1758
 openlit/instrumentation/haystack/haystack.py,sha256=oQIZiDhdp3gnJnhYQ1OouJMc9YT0pQ-_31cmNuopa68,3891
-openlit/instrumentation/langchain/__init__.py,sha256=19C7YGSF-6u5VlvKkThNS4zZqvxw-fQfRsKufZ9onfk,2881
-openlit/instrumentation/langchain/langchain.py,sha256=xGiRb3Z_fY1PU09hfSBFt6ipfYJIQrwFFm5HEDaawOY,16243
+openlit/instrumentation/langchain/__init__.py,sha256=0AI2Dnqw81IcJw3jM--gGkv_HRh2GtosOGJjvOpw7Zk,3431
+openlit/instrumentation/langchain/langchain.py,sha256=7K-m35sS3yTu9IklRo6n9LCcymeg6OyIYKrMzMG_uDQ,35730
 openlit/instrumentation/llamaindex/__init__.py,sha256=vPtK65G6b-TwJERowVRUVl7f_nBSlFdwPBtpg8dOGos,1977
 openlit/instrumentation/llamaindex/llamaindex.py,sha256=uiIigbwhonSbJWA7LpgOVI1R4kxxPODS1K5wyHIQ4hM,4048
 openlit/instrumentation/milvus/__init__.py,sha256=qi1yfmMrvkDtnrN_6toW8qC9BRL78bq7ayWpObJ8Bq4,2961
@@ -52,8 +55,8 @@ openlit/instrumentation/vllm/__init__.py,sha256=OVWalQ1dXvip1DUsjUGaHX4J-2FrSp-T
 openlit/instrumentation/vllm/vllm.py,sha256=lDzM7F5pgxvh8nKL0dcKB4TD0Mc9wXOWeXOsOGN7Wd8,6527
 openlit/otel/metrics.py,sha256=O7NoaDz0bY19mqpE4-0PcKwEe-B-iJFRgOCaanAuZAc,4291
 openlit/otel/tracing.py,sha256=vL1ifMbARPBpqK--yXYsCM6y5dSu5LFIKqkhZXtYmUc,3712
-openlit/semcov/__init__.py,sha256=EvoNOKtc7UKwLZ3Gp0-B1zwmeTcAIbx8O7wvAw8wXP4,7498
-openlit-1.18.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.18.2.dist-info/METADATA,sha256=eD-PsH7RbUA7EOICMoUHzO_f1g_Sa0b6UcNvHnBwY-8,14347
-openlit-1.18.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-openlit-1.18.2.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=56daxsJtWFqp87TTT3R5OxSeMH7eOZqb4k-7AELirTI,7554
+openlit-1.20.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.20.0.dist-info/METADATA,sha256=DvK9Dt8ZvBBvdPc_Fdbi7HxkCu9Kp-Z4IkzCOuynkg4,14934
+openlit-1.20.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+openlit-1.20.0.dist-info/RECORD,,

{openlit-1.18.2.dist-info → openlit-1.20.0.dist-info}/LICENSE RENAMED Viewed

File without changes

{openlit-1.18.2.dist-info → openlit-1.20.0.dist-info}/WHEEL RENAMED Viewed

File without changes

openlit 1.18.2__py3-none-any.whl → 1.20.0__py3-none-any.whl

openlit 1.18.2py3-none-any.whl → 1.20.0py3-none-any.whl