openlit 1.8.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

openlit/__init__.py

@@ -24,6 +24,7 @@ from openlit.instrumentation.ollama import OllamaInstrumentor
 from openlit.instrumentation.langchain import LangChainInstrumentor
 from openlit.instrumentation.llamaindex import LlamaIndexInstrumentor
 from openlit.instrumentation.haystack import HaystackInstrumentor
+from openlit.instrumentation.embedchain import EmbedChainInstrumentor
 from openlit.instrumentation.chroma import ChromaInstrumentor
 from openlit.instrumentation.pinecone import PineconeInstrumentor
 from openlit.instrumentation.qdrant import QdrantInstrumentor
@@ -163,6 +164,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "langchain": "langchain",
         "llama_index": "llama_index",
         "haystack": "haystack",
+        "embedchain": "embedchain",
         "chroma": "chromadb",
         "pinecone": "pinecone",
         "qdrant": "qdrant_client",
@@ -217,6 +219,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "langchain": LangChainInstrumentor(),
             "llama_index": LlamaIndexInstrumentor(),
             "haystack": HaystackInstrumentor(),
+            "embedchain": EmbedChainInstrumentor(),
             "chroma": ChromaInstrumentor(),
             "pinecone": PineconeInstrumentor(),
             "qdrant": QdrantInstrumentor(),

openlit/instrumentation/chroma/chroma.py

@@ -16,11 +16,13 @@ def object_count(obj):
     """
     Counts Length of object if it exists, Else returns None
     """
+    try:
+        cnt = len(obj)
+    # pylint: disable=bare-except
+    except:
+        cnt = 0
 
-    if obj:
-        return len(obj)
-
-    return None
+    return cnt
 
 def general_wrap(gen_ai_endpoint, version, environment, application_name,
                  tracer, pricing_info, trace_content, metrics, disable_metrics):
@@ -87,24 +89,24 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_ADD)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
-                                       object_count(kwargs.get("ids")))
+                                       object_count(kwargs.get("ids", [])))
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("embeddings")))
+                                       object_count(kwargs.get("embeddings", [])))
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("metadatas")))
+                                       object_count(kwargs.get("metadatas", [])))
                     span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
-                                       object_count(kwargs.get("documents")))
+                                       object_count(kwargs.get("documents", [])))
 
                 elif gen_ai_endpoint == "chroma.get":
                     db_operation = SemanticConvetion.DB_OPERATION_GET
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_GET)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
-                                       object_count(kwargs.get("ids")))
+                                       object_count(kwargs.get("ids", [])))
                     span.set_attribute(SemanticConvetion.DB_QUERY_LIMIT,
-                                       kwargs.get("limit"))
+                                       kwargs.get("limit", ""))
                     span.set_attribute(SemanticConvetion.DB_OFFSET,
-                                       kwargs.get("offset"))
+                                       kwargs.get("offset", ""))
                     span.set_attribute(SemanticConvetion.DB_WHERE_DOCUMENT,
                                        str(kwargs.get("where_document", "")))
 
@@ -113,7 +115,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_QUERY)
                     span.set_attribute(SemanticConvetion.DB_STATEMENT,
-                                       str(kwargs.get("query_texts")))
+                                       str(kwargs.get("query_texts", "")))
                     span.set_attribute(SemanticConvetion.DB_N_RESULTS,
                                        kwargs.get("n_results", ""))
                     span.set_attribute(SemanticConvetion.DB_FILTER,
@@ -126,33 +128,33 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_UPDATE)
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("embeddings")))
+                                       object_count(kwargs.get("embeddings", [])))
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("metadatas")))
+                                       object_count(kwargs.get("metadatas", [])))
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
-                                       object_count(kwargs.get("ids")))
+                                       object_count(kwargs.get("ids", [])))
                     span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
-                                       object_count(kwargs.get("documents")))
+                                       object_count(kwargs.get("documents", [])))
 
                 elif gen_ai_endpoint == "chroma.upsert":
                     db_operation = SemanticConvetion.DB_OPERATION_UPSERT
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_UPSERT)
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("embeddings")))
+                                       object_count(kwargs.get("embeddings", [])))
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("metadatas")))
+                                       object_count(kwargs.get("metadatas", [])))
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
-                                       object_count(kwargs.get("ids")))
+                                       object_count(kwargs.get("ids", [])))
                     span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
-                                       object_count(kwargs.get("documents")))
+                                       object_count(kwargs.get("documents", [])))
 
                 elif gen_ai_endpoint == "chroma.delete":
                     db_operation = SemanticConvetion.DB_OPERATION_DELETE
                     span.set_attribute(SemanticConvetion.DB_OPERATION,
                                        SemanticConvetion.DB_OPERATION_DELETE)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
-                                       object_count(kwargs.get("ids")))
+                                       object_count(kwargs.get("ids", [])))
                     span.set_attribute(SemanticConvetion.DB_FILTER,
                                        str(kwargs.get("where", "")))
                     span.set_attribute(SemanticConvetion.DB_DELETE_ALL,

openlit/instrumentation/cohere/cohere.py

@@ -203,9 +203,9 @@ def chat(gen_ai_endpoint, version, environment, application_name, tracer,
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                     False)
                 span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_ID,
-                                    response.response_id)
+                                    response.generation_id)
                 span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON,
-                                    response.response_id)
+                                    response.finish_reason)
                 span.set_attribute(SemanticConvetion.GEN_AI_USAGE_PROMPT_TOKENS,
                                     response.meta.billed_units.input_tokens)
                 span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COMPLETION_TOKENS,
@@ -306,10 +306,11 @@ def chat_stream(gen_ai_endpoint, version, environment, application_name,
                     # Collect message IDs and aggregated response from events
                     if event.event_type == "stream-end":
                         llmresponse = event.response.text
-                        response_id = event.response.response_id
                         prompt_tokens = event.response.meta.billed_units.input_tokens
                         completion_tokens = event.response.meta.billed_units.output_tokens
                         finish_reason = event.finish_reason
+                    if event.event_type == "stream-start":
+                        response_id = event.generation_id
                     yield event
 
                 # Handling exception ensure observability without disrupting operation

openlit/instrumentation/embedchain/__init__.py

@@ -0,0 +1,55 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of EmbedChain Functions"""
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from openlit.instrumentation.embedchain.embedchain import evaluate, get_data_sources
+
+_instruments = ("embedchain >= 0.1.104",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "embedchain",
+        "object": "App.evaluate",
+        "endpoint": "embedchain.evaluate",
+        "wrapper": evaluate,
+    },
+    {
+        "package": "embedchain",
+        "object": "App.get_data_sources",
+        "endpoint": "embedchain.get_data_sources",
+        "wrapper": get_data_sources,
+    },
+]
+
+class EmbedChainInstrumentor(BaseInstrumentor):
+    """An instrumentor for EmbedChain's client library."""
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        application_name = kwargs.get("application_name")
+        environment = kwargs.get("environment")
+        tracer = kwargs.get("tracer")
+        pricing_info = kwargs.get("pricing_info")
+        trace_content = kwargs.get("trace_content")
+        version = importlib.metadata.version("embedchain")
+
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            gen_ai_endpoint = wrapped_method.get("endpoint")
+            wrapper = wrapped_method.get("wrapper")
+            wrap_function_wrapper(
+                wrap_package,
+                wrap_object,
+                wrapper(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content),
+            )
+
+    @staticmethod
+    def _uninstrument(self, **kwargs):
+        pass

openlit/instrumentation/embedchain/embedchain.py

@@ -0,0 +1,165 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument
+"""
+Module for monitoring EmbedChain 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.semcov import SemanticConvetion
+
+# Initialize logger for logging potential issues and operations
+logger = logging.getLogger(__name__)
+
+def evaluate(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content):
+    """
+    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 EmbedChain application.
+    - environment (str): The deployment environment (e.g., 'production', 'development').
+    - application_name (str): Name of the EmbedChain 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:
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_EMBEDCHAIN)
+                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_FRAMEWORK)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                    application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_EVAL_CONTEXT_RELEVANCY,
+                                    response["context_relevancy"])
+                span.set_attribute(SemanticConvetion.GEN_AI_EVAL_ANSWER_RELEVANCY,
+                                    response["answer_relevancy"])
+                span.set_attribute(SemanticConvetion.GEN_AI_EVAL_GROUNDEDNESS,
+                                    response["groundedness"])
+
+                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
+
+def get_data_sources(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content):
+    """
+    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 EmbedChain application.
+    - environment (str): The deployment environment (e.g., 'production', 'development').
+    - application_name (str): Name of the EmbedChain 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:
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_EMBEDCHAIN)
+                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_FRAMEWORK)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                    application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_DATA_SOURCES,
+                                    len(response))
+
+                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/llamaindex/__init__.py

@@ -25,7 +25,7 @@ WRAPPED_METHODS = [
 ]
 
 class LlamaIndexInstrumentor(BaseInstrumentor):
-    """An instrumentor for Cohere's client library."""
+    """An instrumentor for LlamaIndex's client library."""
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments

openlit/instrumentation/qdrant/qdrant.py

@@ -119,9 +119,9 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_OPERATION_STATUS,
                                        response.status)
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
-                                       object_count(kwargs.get("points")))
+                                       object_count(kwargs.get("points", [])))
                     span.set_attribute(SemanticConvetion.DB_PAYLOAD_COUNT,
-                                       object_count(kwargs.get("payload")))
+                                       object_count(kwargs.get("payload", [])))
 
                 elif gen_ai_endpoint == "qdrant.retrieve":
                     db_operation = SemanticConvetion.DB_OPERATION_QUERY
@@ -130,7 +130,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
                                        kwargs.get("collection_name", ""))
                     span.set_attribute(SemanticConvetion.DB_STATEMENT,
-                                       str(kwargs.get("ids")))
+                                       str(kwargs.get("ids", "")))
 
                 elif gen_ai_endpoint == "qdrant.scroll":
                     db_operation = SemanticConvetion.DB_OPERATION_QUERY
@@ -139,7 +139,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
                                        kwargs.get("collection_name", ""))
                     span.set_attribute(SemanticConvetion.DB_STATEMENT,
-                                       str(kwargs.get("scroll_filter")))
+                                       str(kwargs.get("scroll_filter", "")))
 
                 elif gen_ai_endpoint in ["qdrant.search", "qdrant.search_groups"]:
                     db_operation = SemanticConvetion.DB_OPERATION_QUERY
@@ -148,7 +148,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                     span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
                                        kwargs.get("collection_name", ""))
                     span.set_attribute(SemanticConvetion.DB_STATEMENT,
-                                       str(kwargs.get("query_vector")))
+                                       str(kwargs.get("query_vector", "")))
 
                 elif gen_ai_endpoint == "qdrant.recommend":
                     db_operation = SemanticConvetion.DB_OPERATION_QUERY

openlit/semcov/__init__.py

@@ -26,6 +26,7 @@ class SemanticConvetion:
     GEN_AI_HUB_REPO = "gen_ai.hub.repo"
     GEN_AI_RETRIEVAL_SOURCE = "gen_ai.retrieval.source"
     GEN_AI_REQUESTS = "gen_ai.total.requests"
+    GEN_AI_DATA_SOURCES = "gen_ai.data_source_count"
 
     # GenAI Request
     GEN_AI_REQUEST_MODEL = "gen_ai.request.model"
@@ -71,6 +72,11 @@ class SemanticConvetion:
     GEN_AI_CONTENT_COMPLETION = "gen_ai.content.completion"
     GEN_AI_CONTENT_REVISED_PROMPT = "gen_ai.content.revised_prompt"
 
+    # GenAI Evaluation Metrics
+    GEN_AI_EVAL_CONTEXT_RELEVANCY = "gen_ai.eval.context_relevancy"
+    GEN_AI_EVAL_ANSWER_RELEVANCY = "gen_ai.eval.answer_relevancy"
+    GEN_AI_EVAL_GROUNDEDNESS = "gen_ai.eval.groundedness"
+
     GEN_AI_TYPE_CHAT = "chat"
     GEN_AI_TYPE_EMBEDDING = "embedding"
     GEN_AI_TYPE_IMAGE = "image"
@@ -92,6 +98,7 @@ class SemanticConvetion:
     GEN_AI_SYSTEM_LANGCHAIN = "langchain"
     GEN_AI_SYSTEM_LLAMAINDEX = "llama_index"
     GEN_AI_SYSTEM_HAYSTACK = "haystack"
+    GEN_AI_SYSTEM_EMBEDCHAIN = "embedchain"
 
     # Vector DB
     DB_REQUESTS = "db.total.requests"

{openlit-1.8.0.dist-info → openlit-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 1.8.0
+Version: 1.10.0
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications, 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
@@ -38,6 +38,9 @@ OpenTelemetry Auto-Instrumentation for GenAI & LLM Applications</h1>
 [![Slack](https://img.shields.io/badge/Slack-4A154B?logo=slack&logoColor=white)](https://join.slack.com/t/openlit/shared_invite/zt-2etnfttwg-TjP_7BZXfYg84oAukY8QRQ)
 [![X](https://img.shields.io/badge/follow-%40OpenLIT-1DA1F2?logo=x&style=social)](https://twitter.com/openlit_io)
 
+![OpenLIT Connections Banner](https://github.com/openlit/.github/blob/main/profile/assets/github-readme-connections-banner.png?raw=true)
+
+
 </div>
 
 OpenLIT Python SDK is an **OpenTelemetry-native** Auto instrumentation library for monitoring LLM Applications, facilitating the integration of observability into your GenAI-driven projects. Designed with simplicity and efficiency, OpenLIT offers the ability to embed observability into your GenAI-driven projects effortlessly using just **a single line of code**.
@@ -46,31 +49,20 @@ Whether you're directly using LLM Libraries like OpenAI, Anthropic or building c
 
 This project adheres to the [Semantic Conventions](https://github.com/open-telemetry/semantic-conventions/tree/main/docs/gen-ai) proposed by the OpenTelemetry community. You can check out the current definitions [here](src/openlit/semcov/__init__.py).
 
-## What can be Auto Instrumented?
-
-### LLMs
-- [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)
-- [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama)
-- [✅ Anthropic](https://docs.openlit.io/latest/integrations/anthropic)
-- [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)
-- [✅ 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)
-- [✅ Vertex AI](https://docs.openlit.io/latest/integrations/vertexai)
-- [✅ Groq](https://docs.openlit.io/latest/integrations/groq)
-
-### Vector DBs
-- [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)
-- [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone)
-- [✅ Qdrant](https://docs.openlit.io/latest/integrations/qdrant)
-- [✅ Milvus](https://docs.openlit.io/latest/integrations/milvus)
-
-### Frameworks
-- [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)
-- [✅ LiteLLM](https://docs.openlit.io/latest/integrations/litellm)
-- [✅ LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index)
-- [✅ Haystack](https://docs.openlit.io/latest/integrations/haystack)
+## Auto Instrumentation Capabilities
+
+| LLMs                                                     | Vector DBs                                   | Frameworks                                   |
+|----------------------------------------------------------|----------------------------------------------|----------------------------------------------|
+| [✅ OpenAI](https://docs.openlit.io/latest/integrations/openai)               | [✅ ChromaDB](https://docs.openlit.io/latest/integrations/chromadb)       | [✅ Langchain](https://docs.openlit.io/latest/integrations/langchain)     |
+| [✅ 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)  |
+| [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)               | [✅ Milvus](https://docs.openlit.io/latest/integrations/milvus)           | [✅ Haystack](https://docs.openlit.io/latest/integrations/haystack)       |
+| [✅ 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)         |                                                                          |                                       
+| [✅ Vertex AI](https://docs.openlit.io/latest/integrations/vertexai)         |                                                                          |                                      
+| [✅ Groq](https://docs.openlit.io/latest/integrations/groq)                   |                                                                          |                                
 
 ## Supported Destinations
 - [✅ OpenTelemetry Collector](https://docs.openlit.io/latest/connections/otelcol)
@@ -92,14 +84,16 @@ pip install openlit
 
 ## 🚀 Getting Started
 
-## Step 1: Install OpenLIT SDK
+### Step 1: Install OpenLIT
+
+Open your command line or terminal and run:
 
 ```bash
 pip install openlit
 ```
 
-### Step 2: Instrument your Application
-Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **one line of code**: 
+### Step 2: Initialize OpenLIT in your Application
+Integrating the OpenLIT into LLM applications is straightforward. Start monitoring for your LLM Application with just **two lines of code**: 
 
 ```python
 import openlit
@@ -107,46 +101,68 @@ import openlit
 openlit.init()
 ```
 
-By default, OpenLIT directs traces and metrics straight to your console. To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.
+To forward telemetry data to an HTTP OTLP endpoint, such as the OpenTelemetry Collector, set the `otlp_endpoint` parameter with the desired endpoint. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable as recommended in the OpenTelemetry documentation.
+
+> 💡 Info: If you dont provide `otlp_endpoint` function argument or set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable, OpenLIT directs the trace directly to your console, which can be useful during development.
 
 To send telemetry to OpenTelemetry backends requiring authentication, set the `otlp_headers` parameter with its desired value. Alternatively, you can configure the endpoint by setting the `OTEL_EXPORTER_OTLP_HEADERS` environment variable as recommended in the OpenTelemetry documentation.
 
 #### Example
 
-Here is how you can send telemetry from OpenLIT to Grafana Cloud
+---
 
-```python
-openlit.init(
-  otlp_endpoint="https://otlp-gateway-prod-us-east-0.grafana.net/otlp", 
-  otlp_headers="Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-)
-```
+<details>
+  <summary>Initialize using Function Arguments</summary>
+  
+  ---
 
-Alternatively, You can also choose to set these values using `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` environment variables
+  Add the following two lines to your application code:
+  
+  ```python
+  import openlit
+  
+  openlit.init(
+    otlp_endpoint="YOUR_OTEL_ENDPOINT", 
+    otlp_headers ="YOUR_OTEL_ENDPOINT_AUTH"
+  )
+  ```
 
-```python
-openlit.init()
-```
+</details>
 
-```env
-export OTEL_EXPORTER_OTLP_ENDPOINT = "https://otlp-gateway-prod-us-east-0.grafana.net/otlp"
-export OTEL_EXPORTER_OTLP_HEADERS = "Authorization=Basic%20<base64 encoded Instance ID and API Token>"
-```
+---
+
+<details>
+
+  <summary>Initialize using Environment Variables</summary>
+
+  ---
+
+  Add the following two lines to your application code:
+
+  ```python
+  import openlit
+
+  openlit.init()
+  ```
+  
+  Then, configure the your OTLP endpoint using environment variable:
+
+  ```env
+  export OTEL_EXPORTER_OTLP_ENDPOINT = "YOUR_OTEL_ENDPOINT"
+  export OTEL_EXPORTER_OTLP_HEADERS = "YOUR_OTEL_ENDPOINT_AUTH"
+  ```
+</details>
+
+---
 
 ### Step 3: Visualize and Optimize!
-With the LLM Observability data now being collected and sent to your chosen OpenTelemetry backend, the next step is to visualize and analyze this data to glean insights into your application's performance, behavior, and identify areas of improvement. Here is how you would use the data in Grafana, follow these detailed instructions to explore your LLM application's Telemetry data.
+With the LLM Observability data now being collected and sent to OpenLIT, the next step is to visualize and analyze this data to get insights into your LLM application’s performance, behavior, and identify areas of improvement.
 
-   - Select the **Explore** option from Grafana's sidebar.
-   - At the top, ensure the correct Tempo data source is selected from the dropdown menu.
-   - Use the **Query** field to specify any particular traces you are interested in, or leave it empty to browse through all the available traces.
-   - You can adjust the time range to focus on specific periods of interest.
-   - Hit **Run Query** to fetch your trace data. You'll see a visual representation of your traces along with detailed information on particular spans when clicked.
+To begin exploring your LLM Application's performance data within the OpenLIT UI, please see the [Quickstart Guide](https://docs.openlit.io/latest/quickstart).
 
-#### Next Steps
+If you want to integrate and send metrics and traces to your existing observability tools, refer to our [Connections Guide](https://docs.openlit.io/latest/connections/intro) for detailed instructions.
 
-- **Create Dashboards:** Beyond just exploring traces, consider creating dashboards in Grafana to monitor key performance indicators (KPIs) and metrics over time. Dashboards can be customized with various panels to display graphs, logs, and single stats that are most relevant to your application's performance and usage patterns.
-- **Set Alerts:** Grafana also allows you to set up alerts based on specific thresholds. This feature can be invaluable in proactively managing your application's health by notifying you of potential issues before they impact users.
-- **Iterate and Optimize:** Use the insights gained from your observability data to make informed decisions on optimizing your LLM application. This might involve refining model parameters, adjusting scaling strategies, or identifying and resolving bottlenecks.
+![](https://github.com/openlit/.github/blob/main/profile/assets/openlit-client-1.png?raw=true)
 
 
 ### Configuration
@@ -163,7 +179,7 @@ Below is a detailed overview of the configuration options available, allowing yo
 | `otlp_headers`          | Defines headers for the OTLP exporter, useful for backends requiring authentication.          | `None`         |    No    |
 | `disable_batch`         | A flag to disable batch span processing, favoring immediate dispatch.                         | `False`        |    No    |
 | `trace_content`         | Enables tracing of content for deeper insights.                                               | `True`         |    No    |
-| `disabled_instrumentors`| List of instrumentors to disable. Choices: `["openai", "anthropic", "langchain", "cohere", "mistral", "transformers", "chroma", "pinecone"]`. | `None` |    No    |
+| `disabled_instrumentors`| List of instrumentors to disable. | `None` |    No    |
 | `disable_metrics`       | If set, disables the collection of metrics.                                                   | `False`        |    No    |
 | `pricing_json`          | URL or file path of the pricing JSON file.                                             | `https://github.com/openlit/openlit/blob/main/assets/pricing.json`        |    No    |
 

{openlit-1.8.0.dist-info → openlit-1.10.0.dist-info}/RECORD

@@ -1,14 +1,16 @@
 openlit/__helpers.py,sha256=lrn4PBs9owDudiCY2NBoVbAi7AU_HtUpyOj0oqPBsPY,5545
-openlit/__init__.py,sha256=5AMhhPAlW60YtRxttzCyJzJIWMpX9l8TlBM8ofxPkaY,10141
+openlit/__init__.py,sha256=rKjXPouODce9nDeysIwf5k8YWA27Fpnr8J6PDCg4k4Q,10299
 openlit/instrumentation/anthropic/__init__.py,sha256=oaU53BOPyfUKbEzYvLr1DPymDluurSnwo4Hernf2XdU,1955
 openlit/instrumentation/anthropic/anthropic.py,sha256=CYBui5eEfWdSfFF0xtCQjh1xO-gCVJc_V9Hli0szVZE,16026
 openlit/instrumentation/anthropic/async_anthropic.py,sha256=NW84kTQ3BkUx1zZuMRps_J7zTYkmq5BxOrqSjqWInBs,16068
 openlit/instrumentation/bedrock/__init__.py,sha256=QPvDMQde6Meodu5JvosHdZsnyExS19lcoP5Li4YrOkw,1540
 openlit/instrumentation/bedrock/bedrock.py,sha256=Q5t5283LGEvhyrUCr9ofEQF22JTkc1UvT2_6u7e7gmA,22278
 openlit/instrumentation/chroma/__init__.py,sha256=61lFpHlUEQUobsUJZHXdvOViKwsOH8AOvSfc4VgCmiM,3253
-openlit/instrumentation/chroma/chroma.py,sha256=r75mAdwSDmjgphixRJPiCmcSoqFIH8ojkohkcAOj7i4,10407
+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=_TXAB64-sujs51-JQVu30HqwBaNengNWHEL0hgAAgJA,20381
+openlit/instrumentation/cohere/cohere.py,sha256=GvxIp55TJIu4YyG0_FwLBDHvAMUlAXyvMNIFhl2CQP4,20437
+openlit/instrumentation/embedchain/__init__.py,sha256=8TYk1OEbz46yF19dr-gB_x80VZMagU3kJ8-QihPXTeA,1929
+openlit/instrumentation/embedchain/embedchain.py,sha256=SLlr7qieT3kp4M6OYSRy8FaVCXQ2t3oPyIiE99ioNE4,7892
 openlit/instrumentation/groq/__init__.py,sha256=uW_0G6HSanQyK2dIXYhzR604pDiyPQfybzc37DsfSew,1911
 openlit/instrumentation/groq/async_groq.py,sha256=WQwHpC-NJoyEf-jAJlxEcdnpd5jmlfAsDtEBRJ47CxA,19084
 openlit/instrumentation/groq/groq.py,sha256=4uiEFUjxJ0q-c3GlgPAMc4NijG1YLgQp7o3wcwFrxeg,19048
@@ -16,7 +18,7 @@ openlit/instrumentation/haystack/__init__.py,sha256=QK6XxxZUHX8vMv2Crk7rNBOc64iO
 openlit/instrumentation/haystack/haystack.py,sha256=oQIZiDhdp3gnJnhYQ1OouJMc9YT0pQ-_31cmNuopa68,3891
 openlit/instrumentation/langchain/__init__.py,sha256=TW1ZR7I1i9Oig-wDWp3j1gmtQFO76jNBXQRBGGKzoOo,2531
 openlit/instrumentation/langchain/langchain.py,sha256=G66UytYwWW0DdvChomzkc5_MJ-sjupuDwlxe4KqlGhY,7639
-openlit/instrumentation/llamaindex/__init__.py,sha256=FwE0iozGbZcd2dWo9uk4EO6qKPAe55byhZBuzuFyxXA,1973
+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
 openlit/instrumentation/milvus/milvus.py,sha256=qhKIoggBAJhRctRrBYz69AcvXH-eh7oBn_l9WfxpAjI,9121
@@ -34,7 +36,7 @@ openlit/instrumentation/openai/openai.py,sha256=VVl0fuQfxitH-V4hVeP5VxB31-yWMI74
 openlit/instrumentation/pinecone/__init__.py,sha256=Mv9bElqNs07_JQkYyNnO0wOM3hdbprmw7sttdMeKC7g,2526
 openlit/instrumentation/pinecone/pinecone.py,sha256=0EhLmtOuvwWVvAKh3e56wyd8wzQq1oaLOmF15SVHxVE,8765
 openlit/instrumentation/qdrant/__init__.py,sha256=OJIg17-IGmBEvBYVKjCHcJ0hFXuEL7XV_jzUTqkolN8,4799
-openlit/instrumentation/qdrant/qdrant.py,sha256=woK7BhmnjRqwU3OmXM6RfQdBBrjk88zV91rvQbPJ46c,14436
+openlit/instrumentation/qdrant/qdrant.py,sha256=4uHKYGvWQtRAEVLUWo3o4joJw7hFm2NxVuBu5YKZKiI,14456
 openlit/instrumentation/transformers/__init__.py,sha256=9-KLjq-aPTh13gTBYsWltV6hokGwt3mP4759SwsaaCk,1478
 openlit/instrumentation/transformers/transformers.py,sha256=peT0BGskYt7AZ0b93TZ7qECXfZRgDQMasUeamexYdZI,7592
 openlit/instrumentation/vertexai/__init__.py,sha256=N3E9HtzefD-zC0fvmfGYiDmSqssoavp_i59wfuYLyMw,6079
@@ -42,8 +44,8 @@ openlit/instrumentation/vertexai/async_vertexai.py,sha256=PMHYyLf1J4gZpC_-KZ_ZVx
 openlit/instrumentation/vertexai/vertexai.py,sha256=UvpNKBHPoV9idVMfGigZnmWuEQiyqSwZn0zK9-U7Lzw,52125
 openlit/otel/metrics.py,sha256=O7NoaDz0bY19mqpE4-0PcKwEe-B-iJFRgOCaanAuZAc,4291
 openlit/otel/tracing.py,sha256=vL1ifMbARPBpqK--yXYsCM6y5dSu5LFIKqkhZXtYmUc,3712
-openlit/semcov/__init__.py,sha256=wcy_1uP6_YxpaHxlo5he91m2GcuD5sfngZbZGgIwNlY,6328
-openlit-1.8.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.8.0.dist-info/METADATA,sha256=148uqS7Fbltn1PI2Ulk1T-9s1AnyJdtuE1tOQjxBYTU,12481
-openlit-1.8.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-openlit-1.8.0.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=sjbSzGH2p25cLrdm3OZxHxxv2gF2eh9Ij1hPamQtMdM,6649
+openlit-1.10.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.10.0.dist-info/METADATA,sha256=0oJJupg32D01gTLE2_YTna8zgf4TOF5hxpHJC2d3_Wk,12841
+openlit-1.10.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+openlit-1.10.0.dist-info/RECORD,,