openlit 1.29.4__py3-none-any.whl → 1.30.0__py3-none-any.whl

openlit/__init__.py

@@ -46,6 +46,8 @@ from openlit.instrumentation.pinecone import PineconeInstrumentor
 from openlit.instrumentation.qdrant import QdrantInstrumentor
 from openlit.instrumentation.milvus import MilvusInstrumentor
 from openlit.instrumentation.transformers import TransformersInstrumentor
+from openlit.instrumentation.litellm import LiteLLMInstrumentor
+from openlit.instrumentation.crewai import CrewAIInstrumentor
 from openlit.instrumentation.gpu import GPUInstrumentor
 import openlit.guard
 import openlit.evals
@@ -228,6 +230,8 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "qdrant": "qdrant_client",
         "milvus": "pymilvus",
         "transformers": "transformers",
+        "litellm": "litellm",
+        "crewai": "crewai",
     }
 
     invalid_instrumentors = [
@@ -305,6 +309,8 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "qdrant": QdrantInstrumentor(),
             "milvus": MilvusInstrumentor(),
             "transformers": TransformersInstrumentor(),
+            "litellm": LiteLLMInstrumentor(),
+            "crewai": CrewAIInstrumentor(),
         }
 
         # Initialize and instrument only the enabled instrumentors

openlit/instrumentation/crewai/__init__.py

@@ -0,0 +1,50 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of CrewAI Functions"""
+
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from openlit.instrumentation.crewai.crewai import (
+    crew_wrap
+)
+
+_instruments = ("crewai >= 0.80.0",)
+
+class CrewAIInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for CrewAI'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("crewai")
+
+        wrap_function_wrapper(
+            "crewai.agent",
+            "Agent.execute_task",
+            crew_wrap("crewai.agent_execute_task", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "crewai.task",
+            "Task._execute_core",
+            crew_wrap("crewai.task_execute_core", 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/crewai/crewai.py

@@ -0,0 +1,149 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, too-many-branches
+"""
+Module for monitoring LiteLLM calls.
+"""
+
+import logging
+import json
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import (
+    handle_exception,
+)
+from openlit.semcov import SemanticConvetion
+
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+
+def _parse_tools(tools):
+    result = []
+    for tool in tools:
+        res = {}
+        if hasattr(tool, "name") and tool.name is not None:
+            res["name"] = tool.name
+        if hasattr(tool, "description") and tool.description is not None:
+            res["description"] = tool.description
+        if res:
+            result.append(res)
+    return json.dumps(result)
+
+def crew_wrap(gen_ai_endpoint, version, environment, application_name,
+                     tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat completions 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 OpenAI API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of OpenAI usage.
+        trace_content: Flag indicating whether to trace the actual content.
+
+    Returns:
+        A function that wraps the chat completions method to add telemetry.
+    """
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat.completions' 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' method.
+        """
+
+        # pylint: disable=line-too-long
+        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+            response = wrapped(*args, **kwargs)
+
+            try:
+                # Set base span attribues
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_OPENAI)
+                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                    SemanticConvetion.GEN_AI_TYPE_CHAT)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                    gen_ai_endpoint)
+
+                instance_class = instance.__class__.__name__
+
+                if instance_class == "Task":
+                    task = {}
+                    for key, value in instance.__dict__.items():
+                        if value is None:
+                            continue
+                        if key == "tools":
+                            value = _parse_tools(value)
+                            task[key] = value
+                        elif key == "agent":
+                            task[key] = value.role
+                        else:
+                            task[key] = str(value)
+
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_TASK_ID,
+                                        task.get('id', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_TASK,
+                                        task.get('description', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_EXPECTED_OUTPUT,
+                                        task.get('expected_output', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ACTUAL_OUTPUT,
+                                        task.get('output', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_HUMAN_INPUT,
+                                        task.get('human_input', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_TASK_ASSOCIATION,
+                                       str(task.get('processed_by_agents', '')))
+
+                elif instance_class == "Agent":
+                    agent = {}
+                    for key, value in instance.__dict__.items():
+                        if key == "tools":
+                            value = _parse_tools(value)
+                        if value is None:
+                            continue
+                        agent[key] = str(value)
+
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ID,
+                                        agent.get('id', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ROLE,
+                                        agent.get('role', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_GOAL,
+                                        agent.get('goal', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_CONTEXT,
+                                        agent.get('backstory', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ENABLE_CACHE,
+                                        agent.get('cache', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ALLOW_DELEGATION,
+                                        agent.get('allow_delegation', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ALLOW_CODE_EXECUTION,
+                                        agent.get('allow_code_execution', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_MAX_RETRY_LIMIT,
+                                        agent.get('max_retry_limit', ''))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_TOOLS,
+                                        str(agent.get('tools', '')))
+                    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_TOOL_RESULTS,
+                                        str(agent.get('tools_results', '')))
+
+                span.set_status(Status(StatusCode.OK))
+
+                # 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/litellm/__init__.py

@@ -0,0 +1,54 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of LiteLLM Functions"""
+
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from openlit.instrumentation.litellm.litellm import (
+    completion
+)
+from openlit.instrumentation.litellm.async_litellm import (
+   acompletion
+)
+
+_instruments = ("litellm >= 1.52.6",)
+
+class LiteLLMInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for LiteLLM'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("litellm")
+
+        # completion
+        wrap_function_wrapper(
+            "litellm",
+            "completion",
+            completion("litellm.completion", version, environment, application_name,
+                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "litellm",
+            "acompletion",
+            acompletion("litellm.completion", 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/litellm/async_litellm.py

@@ -0,0 +1,407 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, too-many-branches
+"""
+Module for monitoring LiteLLM calls.
+"""
+
+import logging
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import (
+    get_chat_model_cost,
+    openai_tokens,
+    handle_exception,
+    response_as_dict,
+)
+from openlit.semcov import SemanticConvetion
+
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+
+def acompletion(gen_ai_endpoint, version, environment, application_name,
+                           tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat completions 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 OpenAI API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of OpenAI usage.
+        trace_content: Flag indicating whether to trace the actual content.
+
+    Returns:
+        A function that wraps the chat completions method to add telemetry.
+    """
+
+    class TracedAsyncStream:
+        """
+        Wrapper for streaming responses to collect metrics and trace data.
+        Wraps the 'openai.AsyncStream' response to collect message IDs and aggregated response.
+
+        This class implements the '__aiter__' and '__anext__' methods that
+        handle asynchronous streaming responses.
+
+        This class also implements '__aenter__' and '__aexit__' methods that
+        handle asynchronous context management protocol.
+        """
+        def __init__(
+                self,
+                wrapped,
+                span,
+                kwargs,
+                **args,
+            ):
+            self.__wrapped__ = wrapped
+            self._span = span
+            # Placeholder for aggregating streaming response
+            self._llmresponse = ""
+            self._response_id = ""
+
+            self._args = args
+            self._kwargs = kwargs
+
+        async def __aenter__(self):
+            await self.__wrapped__.__aenter__()
+            return self
+
+        async def __aexit__(self, exc_type, exc_value, traceback):
+            await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
+
+        def __aiter__(self):
+            return self
+
+        async def __getattr__(self, name):
+            """Delegate attribute access to the wrapped object."""
+            return getattr(await self.__wrapped__, name)
+
+        async def __anext__(self):
+            try:
+                chunk = await self.__wrapped__.__anext__()
+                chunked = response_as_dict(chunk)
+                # Collect message IDs and aggregated response from events
+                if (len(chunked.get('choices')) > 0 and ('delta' in chunked.get('choices')[0] and
+                    'content' in chunked.get('choices')[0].get('delta'))):
+
+                    content = chunked.get('choices')[0].get('delta').get('content')
+                    if content:
+                        self._llmresponse += content
+                self._response_id = chunked.get('id')
+                return chunk
+            except StopAsyncIteration:
+                # Handling exception ensure observability without disrupting operation
+                try:
+                    # Format 'messages' into a single string
+                    message_prompt = self._kwargs.get("messages", "")
+                    formatted_messages = []
+                    for message in message_prompt:
+                        role = message["role"]
+                        content = message["content"]
+
+                        if isinstance(content, list):
+                            content_str = ", ".join(
+                                # pylint: disable=line-too-long
+                                f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                                if "type" in item else f'text: {item["text"]}'
+                                for item in content
+                            )
+                            formatted_messages.append(f"{role}: {content_str}")
+                        else:
+                            formatted_messages.append(f"{role}: {content}")
+                    prompt = "\n".join(formatted_messages)
+
+                    # Calculate tokens using input prompt and aggregated response
+                    prompt_tokens = openai_tokens(prompt,
+                                                    self._kwargs.get("model", "gpt-3.5-turbo"))
+                    completion_tokens = openai_tokens(self._llmresponse,
+                                                        self._kwargs.get("model", "gpt-3.5-turbo"))
+
+                    # Calculate cost of the operation
+                    cost = get_chat_model_cost(self._kwargs.get("model", "gpt-3.5-turbo"),
+                                                pricing_info, prompt_tokens,
+                                                completion_tokens)
+
+                    # Set Span attributes
+                    self._span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_OPENAI)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                        gen_ai_endpoint)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_ID,
+                                        self._response_id)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                        environment)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                        application_name)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                        self._kwargs.get("model", "gpt-3.5-turbo"))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
+                                        self._kwargs.get("user", ""))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                        self._kwargs.get("top_p", 1.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
+                                        self._kwargs.get("max_tokens", -1))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                        self._kwargs.get("temperature", 1.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                        self._kwargs.get("presence_penalty", 0.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                        self._kwargs.get("frequency_penalty", 0.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
+                                        self._kwargs.get("seed", ""))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                        True)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                        prompt_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                        completion_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                        prompt_tokens + completion_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                        cost)
+                    if trace_content:
+                        self._span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                            },
+                        )
+                        self._span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: self._llmresponse,
+                            },
+                        )
+
+                    self._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_OPENAI,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                self._kwargs.get("model", "gpt-3.5-turbo")
+                        }
+
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(
+                            prompt_tokens + completion_tokens, attributes
+                        )
+                        metrics["genai_completion_tokens"].add(completion_tokens, attributes)
+                        metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                        metrics["genai_cost"].record(cost, attributes)
+
+                except Exception as e:
+                    handle_exception(self._span, e)
+                    logger.error("Error in trace creation: %s", e)
+                finally:
+                    self._span.end()
+                raise
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat.completions' 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' method.
+        """
+
+        # Check if streaming is enabled for the API call
+        streaming = kwargs.get("stream", False)
+
+        # pylint: disable=no-else-return
+        if streaming:
+            # Special handling for streaming response to accommodate the nature of data flow
+            awaited_wrapped = await wrapped(*args, **kwargs)
+            span = tracer.start_span(gen_ai_endpoint, kind=SpanKind.CLIENT)
+
+            return TracedAsyncStream(awaited_wrapped, span, kwargs)
+
+        # Handling for non-streaming responses
+        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)
+
+                response_dict = response_as_dict(response)
+
+                try:
+                    # Format 'messages' into a single string
+                    message_prompt = kwargs.get("messages", "")
+                    formatted_messages = []
+                    for message in message_prompt:
+                        role = message["role"]
+                        content = message["content"]
+
+                        if isinstance(content, list):
+                            content_str = ", ".join(
+                                # pylint: disable=line-too-long
+                                f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                                if "type" in item else f'text: {item["text"]}'
+                                for item in content
+                            )
+                            formatted_messages.append(f"{role}: {content_str}")
+                        else:
+                            formatted_messages.append(f"{role}: {content}")
+                    prompt = "\n".join(formatted_messages)
+
+                    # Set base span attribues
+                    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_OPENAI)
+                    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_RESPONSE_ID,
+                                        response_dict.get("id"))
+                    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,
+                                        kwargs.get("model", "gpt-3.5-turbo"))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                        kwargs.get("top_p", 1.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
+                                        kwargs.get("max_tokens", -1))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
+                                        kwargs.get("user", ""))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                        kwargs.get("temperature", 1.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                        kwargs.get("presence_penalty", 0.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                        kwargs.get("frequency_penalty", 0.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
+                                        kwargs.get("seed", ""))
+                    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,
+                            },
+                        )
+
+                    # Set span attributes when tools is not passed to the function call
+                    if "tools" not in kwargs:
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, response_dict.get('usage', {}).get('prompt_tokens', None),
+                                                    response_dict.get('usage', {}).get('completion_tokens', None))
+
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                           response_dict.get('usage', {}).get('prompt_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                           response_dict.get('usage', {}).get('completion_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                           response_dict.get('usage', {}).get('total_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                           [response_dict.get('choices', [])[0].get('finish_reason', None)])
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                            cost)
+
+                        # Set span attributes for when n = 1 (default)
+                        if "n" not in kwargs or kwargs["n"] == 1:
+                            if trace_content:
+                                span.add_event(
+                                    name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                                    attributes={
+                                        SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response_dict.get('choices', [])[0].get("message").get("content"),
+                                    },
+                                )
+
+                        # Set span attributes for when n > 0
+                        else:
+                            i = 0
+                            while i < kwargs["n"] and trace_content is True:
+                                attribute_name = f"gen_ai.content.completion.{i}"
+                                span.add_event(
+                                    name=attribute_name,
+                                    attributes={
+                                        SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response_dict.get('choices')[i].get("message").get("content"),
+                                    },
+                                )
+                                i += 1
+
+                            # Return original response
+                            return response
+
+                    # Set span attributes when tools is passed to the function call
+                    elif "tools" in kwargs:
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, response_dict.get('usage').get('prompt_tokens'),
+                                                    response_dict.get('usage').get('completion_tokens'))
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: "Function called with tools",
+                            },
+                        )
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                            response_dict.get('usage').get('prompt_tokens'))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                            response_dict.get('usage').get('completion_tokens'))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                            response_dict.get('usage').get('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_OPENAI,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                kwargs.get("model", "gpt-3.5-turbo")
+                        }
+
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(response_dict.get('usage').get('total_tokens'), attributes)
+                        metrics["genai_completion_tokens"].add(response_dict.get('usage').get('completion_tokens'), attributes)
+                        metrics["genai_prompt_tokens"].add(response_dict.get('usage').get('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/litellm/litellm.py

@@ -0,0 +1,407 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, too-many-branches
+"""
+Module for monitoring LiteLLM calls.
+"""
+
+import logging
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
+from openlit.__helpers import (
+    get_chat_model_cost,
+    openai_tokens,
+    handle_exception,
+    response_as_dict,
+)
+from openlit.semcov import SemanticConvetion
+
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+
+def completion(gen_ai_endpoint, version, environment, application_name,
+                     tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for chat completions 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 OpenAI API.
+        tracer: OpenTelemetry tracer for creating spans.
+        pricing_info: Information used for calculating the cost of OpenAI usage.
+        trace_content: Flag indicating whether to trace the actual content.
+
+    Returns:
+        A function that wraps the chat completions method to add telemetry.
+    """
+
+    class TracedSyncStream:
+        """
+        Wrapper for streaming responses to collect metrics and trace data.
+        Wraps the 'openai.AsyncStream' response to collect message IDs and aggregated response.
+
+        This class implements the '__aiter__' and '__anext__' methods that
+        handle asynchronous streaming responses.
+
+        This class also implements '__aenter__' and '__aexit__' methods that
+        handle asynchronous context management protocol.
+        """
+        def __init__(
+                self,
+                wrapped,
+                span,
+                kwargs,
+                **args,
+            ):
+            self.__wrapped__ = wrapped
+            self._span = span
+            # Placeholder for aggregating streaming response
+            self._llmresponse = ""
+            self._response_id = ""
+
+            self._args = args
+            self._kwargs = kwargs
+
+        def __enter__(self):
+            self.__wrapped__.__enter__()
+            return self
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            self.__wrapped__.__exit__(exc_type, exc_value, traceback)
+
+        def __iter__(self):
+            return self
+
+        def __getattr__(self, name):
+            """Delegate attribute access to the wrapped object."""
+            return getattr(self.__wrapped__, name)
+
+        def __next__(self):
+            try:
+                chunk = self.__wrapped__.__next__()
+                chunked = response_as_dict(chunk)
+                # Collect message IDs and aggregated response from events
+                if (len(chunked.get('choices')) > 0 and ('delta' in chunked.get('choices')[0] and
+                    'content' in chunked.get('choices')[0].get('delta'))):
+
+                    content = chunked.get('choices')[0].get('delta').get('content')
+                    if content:
+                        self._llmresponse += content
+                self._response_id = chunked.get('id')
+                return chunk
+            except StopIteration:
+                # Handling exception ensure observability without disrupting operation
+                try:
+                    # Format 'messages' into a single string
+                    message_prompt = self._kwargs.get("messages", "")
+                    formatted_messages = []
+                    for message in message_prompt:
+                        role = message["role"]
+                        content = message["content"]
+
+                        if isinstance(content, list):
+                            content_str = ", ".join(
+                                # pylint: disable=line-too-long
+                                f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                                if "type" in item else f'text: {item["text"]}'
+                                for item in content
+                            )
+                            formatted_messages.append(f"{role}: {content_str}")
+                        else:
+                            formatted_messages.append(f"{role}: {content}")
+                    prompt = "\n".join(formatted_messages)
+
+                    # Calculate tokens using input prompt and aggregated response
+                    prompt_tokens = openai_tokens(prompt,
+                                                    self._kwargs.get("model", "gpt-3.5-turbo"))
+                    completion_tokens = openai_tokens(self._llmresponse,
+                                                        self._kwargs.get("model", "gpt-3.5-turbo"))
+
+                    # Calculate cost of the operation
+                    cost = get_chat_model_cost(self._kwargs.get("model", "gpt-3.5-turbo"),
+                                                pricing_info, prompt_tokens,
+                                                completion_tokens)
+
+                    # Set Span attributes
+                    self._span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_OPENAI)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                        SemanticConvetion.GEN_AI_TYPE_CHAT)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                        gen_ai_endpoint)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_ID,
+                                        self._response_id)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                        environment)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                        application_name)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+                                        self._kwargs.get("model", "gpt-3.5-turbo"))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
+                                        self._kwargs.get("user", ""))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                        self._kwargs.get("top_p", 1.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
+                                        self._kwargs.get("max_tokens", -1))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                        self._kwargs.get("temperature", 1.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                        self._kwargs.get("presence_penalty", 0.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                        self._kwargs.get("frequency_penalty", 0.0))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
+                                        self._kwargs.get("seed", ""))
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
+                                        True)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                        prompt_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                        completion_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                        prompt_tokens + completion_tokens)
+                    self._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                        cost)
+                    if trace_content:
+                        self._span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                            },
+                        )
+                        self._span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: self._llmresponse,
+                            },
+                        )
+
+                    self._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_OPENAI,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                self._kwargs.get("model", "gpt-3.5-turbo")
+                        }
+
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(
+                            prompt_tokens + completion_tokens, attributes
+                        )
+                        metrics["genai_completion_tokens"].add(completion_tokens, attributes)
+                        metrics["genai_prompt_tokens"].add(prompt_tokens, attributes)
+                        metrics["genai_cost"].record(cost, attributes)
+
+                except Exception as e:
+                    handle_exception(self._span, e)
+                    logger.error("Error in trace creation: %s", e)
+                finally:
+                    self._span.end()
+                raise
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the 'chat.completions' 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' method.
+        """
+
+        # Check if streaming is enabled for the API call
+        streaming = kwargs.get("stream", False)
+
+        # pylint: disable=no-else-return
+        if streaming:
+            # Special handling for streaming response to accommodate the nature of data flow
+            awaited_wrapped = wrapped(*args, **kwargs)
+            span = tracer.start_span(gen_ai_endpoint, kind=SpanKind.CLIENT)
+
+            return TracedSyncStream(awaited_wrapped, span, kwargs)
+
+        # Handling for non-streaming responses
+        else:
+            # pylint: disable=line-too-long
+            with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+                response = wrapped(*args, **kwargs)
+
+                response_dict = response_as_dict(response)
+
+                try:
+                    # Format 'messages' into a single string
+                    message_prompt = kwargs.get("messages", "")
+                    formatted_messages = []
+                    for message in message_prompt:
+                        role = message["role"]
+                        content = message["content"]
+
+                        if isinstance(content, list):
+                            content_str = ", ".join(
+                                # pylint: disable=line-too-long
+                                f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                                if "type" in item else f'text: {item["text"]}'
+                                for item in content
+                            )
+                            formatted_messages.append(f"{role}: {content_str}")
+                        else:
+                            formatted_messages.append(f"{role}: {content}")
+                    prompt = "\n".join(formatted_messages)
+
+                    # Set base span attribues
+                    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                        SemanticConvetion.GEN_AI_SYSTEM_OPENAI)
+                    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_RESPONSE_ID,
+                                        response_dict.get("id"))
+                    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,
+                                        kwargs.get("model", "gpt-3.5-turbo"))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
+                                        kwargs.get("top_p", 1.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS,
+                                        kwargs.get("max_tokens", -1))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
+                                        kwargs.get("user", ""))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
+                                        kwargs.get("temperature", 1.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_PRESENCE_PENALTY,
+                                        kwargs.get("presence_penalty", 0.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY,
+                                        kwargs.get("frequency_penalty", 0.0))
+                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED,
+                                        kwargs.get("seed", ""))
+                    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,
+                            },
+                        )
+
+                    # Set span attributes when tools is not passed to the function call
+                    if "tools" not in kwargs:
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, response_dict.get('usage', {}).get('prompt_tokens', None),
+                                                    response_dict.get('usage', {}).get('completion_tokens', None))
+
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                           response_dict.get('usage', {}).get('prompt_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                           response_dict.get('usage', {}).get('completion_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                           response_dict.get('usage', {}).get('total_tokens', None))
+                        span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
+                                           [response_dict.get('choices', [])[0].get('finish_reason', None)])
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+                                            cost)
+
+                        # Set span attributes for when n = 1 (default)
+                        if "n" not in kwargs or kwargs["n"] == 1:
+                            if trace_content:
+                                span.add_event(
+                                    name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                                    attributes={
+                                        SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response_dict.get('choices', [])[0].get("message").get("content"),
+                                    },
+                                )
+
+                        # Set span attributes for when n > 0
+                        else:
+                            i = 0
+                            while i < kwargs["n"] and trace_content is True:
+                                attribute_name = f"gen_ai.content.completion.{i}"
+                                span.add_event(
+                                    name=attribute_name,
+                                    attributes={
+                                        SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response_dict.get('choices')[i].get("message").get("content"),
+                                    },
+                                )
+                                i += 1
+
+                            # Return original response
+                            return response
+
+                    # Set span attributes when tools is passed to the function call
+                    elif "tools" in kwargs:
+                        # Calculate cost of the operation
+                        cost = get_chat_model_cost(kwargs.get("model", "gpt-3.5-turbo"),
+                                                    pricing_info, response_dict.get('usage').get('prompt_tokens'),
+                                                    response_dict.get('usage').get('completion_tokens'))
+                        span.add_event(
+                            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+                            attributes={
+                                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: "Function called with tools",
+                            },
+                        )
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
+                                            response_dict.get('usage').get('prompt_tokens'))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
+                                            response_dict.get('usage').get('completion_tokens'))
+                        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS,
+                                            response_dict.get('usage').get('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_OPENAI,
+                            SemanticConvetion.GEN_AI_ENVIRONMENT:
+                                environment,
+                            SemanticConvetion.GEN_AI_TYPE:
+                                SemanticConvetion.GEN_AI_TYPE_CHAT,
+                            SemanticConvetion.GEN_AI_REQUEST_MODEL:
+                                kwargs.get("model", "gpt-3.5-turbo")
+                        }
+
+                        metrics["genai_requests"].add(1, attributes)
+                        metrics["genai_total_tokens"].add(response_dict.get('usage').get('total_tokens'), attributes)
+                        metrics["genai_completion_tokens"].add(response_dict.get('usage').get('completion_tokens'), attributes)
+                        metrics["genai_prompt_tokens"].add(response_dict.get('usage').get('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/openai/async_openai.py

@@ -468,8 +468,8 @@ def async_embedding(gen_ai_endpoint, version, environment, application_name,
                                     kwargs.get("model", "text-embedding-ada-002"))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_FORMAT,
                                     kwargs.get("encoding_format", "float"))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_DIMENSION,
-                                    kwargs.get("dimensions", ""))
+                # span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_DIMENSION,
+                #                     kwargs.get("dimensions", "null"))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
                                     kwargs.get("user", ""))
                 span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,

openlit/instrumentation/openai/openai.py

@@ -468,8 +468,8 @@ def embedding(gen_ai_endpoint, version, environment, application_name,
                                     kwargs.get("model", "text-embedding-ada-002"))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_FORMAT,
                                     kwargs.get("encoding_format", "float"))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_DIMENSION,
-                                    kwargs.get("dimensions", ""))
+                # span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_EMBEDDING_DIMENSION,
+                #                     kwargs.get("dimensions", "null"))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_USER,
                                     kwargs.get("user", ""))
                 span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,

openlit/semcov/__init__.py

@@ -154,6 +154,24 @@ class SemanticConvetion:
     DB_SYSTEM_QDRANT = "qdrant"
     DB_SYSTEM_MILVUS = "milvus"
 
+    # Agents
+    GEN_AI_AGENT_ID = "gen_ai.agent.id"
+    GEN_AI_AGENT_TASK_ID = "gen_ai.agent.task.id"
+    GEN_AI_AGENT_ROLE = "gen_ai.agent.role"
+    GEN_AI_AGENT_GOAL = "gen_ai.agent.goal"
+    GEN_AI_AGENT_CONTEXT = "gen_ai.agent.context"
+    GEN_AI_AGENT_ENABLE_CACHE = "gen_ai.agent.enable_cache"
+    GEN_AI_AGENT_ALLOW_DELEGATION = "gen_ai.agent.allow_delegation"
+    GEN_AI_AGENT_ALLOW_CODE_EXECUTION = "gen_ai.agent.allow_code_execution"
+    GEN_AI_AGENT_MAX_RETRY_LIMIT = "gen_ai.agent.max_retry_limit"
+    GEN_AI_AGENT_TOOLS = "gen_ai.agent.tools"
+    GEN_AI_AGENT_TOOL_RESULTS = "gen_ai.agent.tool_results"
+    GEN_AI_AGENT_TASK = "gen_ai.agent.task"
+    GEN_AI_AGENT_EXPECTED_OUTPUT = "gen_ai.agent.expected_output"
+    GEN_AI_AGENT_ACTUAL_OUTPUT = "gen_ai.agent.actual_output"
+    GEN_AI_AGENT_HUMAN_INPUT = "gen_ai.agent.human_input"
+    GEN_AI_AGENT_TASK_ASSOCIATION = "gen_ai.agent.task_associations"
+
     # GPU
     GPU_INDEX = "gpu.index"
     GPU_UUID = "gpu.uuid"

{openlit-1.29.4.dist-info → openlit-1.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 1.29.4
+Version: 1.30.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
@@ -63,16 +63,16 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi
 
 ## Auto Instrumentation Capabilities
 
-| LLMs                                                                      | Vector DBs                                   | Frameworks                                   | GPUs          |
-|--------------------------------------------------------------------------|----------------------------------------------|----------------------------------------------|---------------|
-| [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)                      | [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)       | [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)     | [✅ NVIDIA](https://docs.openlit.io/latest/integrations/nvidia-gpu) |
-| [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)                      | [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)       | [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)         | [✅ AMD](#)                   |
-| [✅ 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)                    |                                                                          | [✅ Guardrails](https://docs.openlit.io/latest/integrations/guardrails)   |               |
-| [✅ Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai)          |                                                                          |                                       |               |
-| [✅ Azure AI Inference](https://docs.openlit.io/latest/integrations/azure-ai-inference) |                                                                          |                                       |               |
+| LLMs                                                                      | Vector DBs                                   | Frameworks                                      | GPUs          |
+|--------------------------------------------------------------------------|----------------------------------------------|-------------------------------------------------|---------------|
+| [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)                      | [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)       | [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)      | [✅ NVIDIA](https://docs.openlit.io/latest/integrations/nvidia-gpu) |
+| [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)                      | [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)       | [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)          | [✅ AMD](#)                   |
+| [✅ 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)                    |                                                                          | [✅ Guardrails](https://docs.openlit.io/latest/integrations/guardrails)    |               |
+| [✅ Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai)          |                                                                          | [✅ CrewAI](https://docs.openlit.io/latest/integrations/crewai)            |               |
+| [✅ Azure AI Inference](https://docs.openlit.io/latest/integrations/azure-ai-inference) |                                                                          |                                         
 | [✅ GitHub AI Models](https://docs.openlit.io/latest/integrations/github-models)  |                                                                          |                                       |               |
 | [✅ HuggingFace Transformers](https://docs.openlit.io/latest/integrations/huggingface) |                                                                          |                                       |               |
 | [✅ Amazon Bedrock](https://docs.openlit.io/latest/integrations/bedrock)             |                                                                          |                                       |               |

{openlit-1.29.4.dist-info → openlit-1.30.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 openlit/__helpers.py,sha256=2OkGKOdsd9Hc011WxR70OqDlO6c4mZcu6McGuW1uAdA,6316
-openlit/__init__.py,sha256=2tsUq6WYudGEYaEOKpRv4absxS-4ElTbbvV_J7QyFKg,19380
+openlit/__init__.py,sha256=cUWwxNAwJvklVpE1LV929JWipsng0KLukcY0BUGFhJM,19654
 openlit/evals/__init__.py,sha256=nJe99nuLo1b5rf7pt9U9BCdSDedzbVi2Fj96cgl7msM,380
 openlit/evals/all.py,sha256=oWrue3PotE-rB5WePG3MRYSA-ro6WivkclSHjYlAqGs,7154
 openlit/evals/bias_detection.py,sha256=mCdsfK7x1vX7S3psC3g641IMlZ-7df3h-V6eiICj5N8,8154
@@ -24,6 +24,8 @@ openlit/instrumentation/chroma/__init__.py,sha256=61lFpHlUEQUobsUJZHXdvOViKwsOH8
 openlit/instrumentation/chroma/chroma.py,sha256=E80j_41UeZi8RzTsHbpvi1izOA_n-0-3_VdrA68AJPA,10531
 openlit/instrumentation/cohere/__init__.py,sha256=PC5T1qIg9pwLNocBP_WjG5B_6p_z019s8quk_fNLAMs,1920
 openlit/instrumentation/cohere/cohere.py,sha256=62-P2K39v6pIJme6vTVViLJ9PP8q_UWkTv2l3Wa2gHA,21217
+openlit/instrumentation/crewai/__init__.py,sha256=cETkkwnKYEMAKlMrHbZ9-RvcRUPYaSNqNIhy2-vCDK8,1794
+openlit/instrumentation/crewai/crewai.py,sha256=xiyWqYv2euyIhjuw4kM_jacH4MuVTlac6lCqzjnAbmM,6914
 openlit/instrumentation/elevenlabs/__init__.py,sha256=BZjAe-kzFJpKxT0tKksXVfZgirvgEp8qM3SfegWU5co,2631
 openlit/instrumentation/elevenlabs/async_elevenlabs.py,sha256=yMYACh95SFr5EYklKnXw2DrPFa3iIgM4qQMWjO1itMU,5690
 openlit/instrumentation/elevenlabs/elevenlabs.py,sha256=mFnD7sgT47OxaXJz0Vc1nrNjXEpcGQDj5run3gA48Lw,6089
@@ -42,6 +44,9 @@ openlit/instrumentation/haystack/__init__.py,sha256=QK6XxxZUHX8vMv2Crk7rNBOc64iO
 openlit/instrumentation/haystack/haystack.py,sha256=oQIZiDhdp3gnJnhYQ1OouJMc9YT0pQ-_31cmNuopa68,3891
 openlit/instrumentation/langchain/__init__.py,sha256=0AI2Dnqw81IcJw3jM--gGkv_HRh2GtosOGJjvOpw7Zk,3431
 openlit/instrumentation/langchain/langchain.py,sha256=g3HDKPq498KitHuQxxfQzvRq9MKAZaR0jStQYTLx_-M,35592
+openlit/instrumentation/litellm/__init__.py,sha256=XV3PxqhlZYoJ3FbVr9MiWPogrE3_HOAv-BvOObylU4M,1866
+openlit/instrumentation/litellm/async_litellm.py,sha256=wsi9GLfp4h4gu2128YMmkgBlnPqPvG5GUdHVddZfPkI,21919
+openlit/instrumentation/litellm/litellm.py,sha256=ayKFyxX8hu9P-FdA-Nn4cf-ewXJD1FCygv3ota35Xe4,21832
 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
@@ -54,9 +59,9 @@ openlit/instrumentation/ollama/async_ollama.py,sha256=7lbikD-I9k8VL63idqj3VMEfiE
 openlit/instrumentation/ollama/ollama.py,sha256=lBt1d3rFnF1tFbfdOccwjEafHnmTAUGsiOKSHku6Fkw,31277
 openlit/instrumentation/openai/__init__.py,sha256=AZ2cPr3TMKkgGdMl_yXMeSi7bWhtmMqOW1iHdzHHGHA,16265
 openlit/instrumentation/openai/async_azure_openai.py,sha256=XbST1UE_zXzNL6RX2XwCsK_a6IhG9PHVTMKBjGrUcB0,48961
-openlit/instrumentation/openai/async_openai.py,sha256=fsLW4K3OW6meM2cQN-6ClmWUGBG_hIsLR8tmP9yv7tQ,49977
+openlit/instrumentation/openai/async_openai.py,sha256=IYJAHXxG7O7jxDL3OYNpT4ybmjUoMXTKXjjg1ns-HMg,49985
 openlit/instrumentation/openai/azure_openai.py,sha256=dZUc5MtCwg_sZJWiruG6exYGhPAm-339sqs3sKZNRPU,48761
-openlit/instrumentation/openai/openai.py,sha256=XoQPiHiTpfIaTqKupZ99iXf9Y7OUM-9KXUy-dwJymwg,49806
+openlit/instrumentation/openai/openai.py,sha256=iJA8xaqlydfltHogoTsClIVZDJxO-yGRMSRppNYJ8iM,49814
 openlit/instrumentation/pinecone/__init__.py,sha256=Mv9bElqNs07_JQkYyNnO0wOM3hdbprmw7sttdMeKC7g,2526
 openlit/instrumentation/pinecone/pinecone.py,sha256=0EhLmtOuvwWVvAKh3e56wyd8wzQq1oaLOmF15SVHxVE,8765
 openlit/instrumentation/qdrant/__init__.py,sha256=GMlZgRBKoQMgrL4cFbAKwytfdTHLzJEIuTQMxp0uZO0,8940
@@ -71,8 +76,8 @@ openlit/instrumentation/vllm/__init__.py,sha256=OVWalQ1dXvip1DUsjUGaHX4J-2FrSp-T
 openlit/instrumentation/vllm/vllm.py,sha256=lDzM7F5pgxvh8nKL0dcKB4TD0Mc9wXOWeXOsOGN7Wd8,6527
 openlit/otel/metrics.py,sha256=FYAk4eBAmNtFKUIp4hbRbpdq4LME6MapyCQOIeuhmEg,4337
 openlit/otel/tracing.py,sha256=2kSj7n7uXSkRegcGFDC8IbnDOxqWTA8dGODs__Yn_yA,3719
-openlit/semcov/__init__.py,sha256=xPsw1aPonDSGYVuga-ZdoGt4yyA16wNFi5AEc7_xIrQ,8114
-openlit-1.29.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.29.4.dist-info/METADATA,sha256=2sTJQzyPiNcouwBuTVsrX-Bu1aeWUd23c7mg33Gscvg,20806
-openlit-1.29.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-openlit-1.29.4.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=FhaEFY7nStofZsdwHPtZbnNDCAs3i0NMvp80R_HEBAc,9031
+openlit-1.30.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.30.0.dist-info/METADATA,sha256=9jdPX05oWaVYZ5lMtfkR4Yyzbt4zYC_ZUZza_MBxseA,20841
+openlit-1.30.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+openlit-1.30.0.dist-info/RECORD,,