PyPI - openlit - Versions diffs - 1.32.2__py3-none-any.whl → 1.32.3__py3-none-any.whl - Mend

openlit 1.32.2py3-none-any.whl → 1.32.3py3-none-any.whl

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

Files changed (9) hide show

openlit/__init__.py +3 -0
openlit/instrumentation/astra/__init__.py +179 -0
openlit/instrumentation/astra/astra.py +226 -0
openlit/instrumentation/astra/async_astra.py +226 -0
openlit/semcov/__init__.py +5 -0
{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/METADATA +3 -3
{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/RECORD +9 -6
{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/LICENSE +0 -0
{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/WHEEL +0 -0

openlit/__init__.py CHANGED Viewed

@@ -48,6 +48,7 @@ from openlit.instrumentation.chroma import ChromaInstrumentor
 from openlit.instrumentation.pinecone import PineconeInstrumentor
 from openlit.instrumentation.qdrant import QdrantInstrumentor
 from openlit.instrumentation.milvus import MilvusInstrumentor
+from openlit.instrumentation.astra import AstraInstrumentor
 from openlit.instrumentation.transformers import TransformersInstrumentor
 from openlit.instrumentation.litellm import LiteLLMInstrumentor
 from openlit.instrumentation.crewai import CrewAIInstrumentor
@@ -250,6 +251,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
         "reka-api": "reka",
         "premai": "premai",
         "julep": "julep",
+        "astra": "astrapy",
     }
     invalid_instrumentors = [
@@ -339,6 +341,7 @@ def init(environment="default", application_name="default", tracer=None, otlp_en
             "reka-api": RekaInstrumentor(),
             "premai": PremAIInstrumentor(),
             "julep": JulepInstrumentor(),
+            "astra": AstraInstrumentor(),
         }
         # Initialize and instrument only the enabled instrumentors

openlit/instrumentation/astra/__init__.py ADDED Viewed

@@ -0,0 +1,179 @@
+# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
+"""Initializer of Auto Instrumentation of AstraDB Functions"""
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+from openlit.instrumentation.astra.astra import general_wrap
+# from openlit.instrumentation.astra.async_astra import asyc_general_wrap
+_instruments = ("astrapy >= 1.5.2",)
+class AstraInstrumentor(BaseInstrumentor):
+    """An instrumentor for AstraDB'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")
+        metrics = kwargs.get("metrics_dict")
+        pricing_info = kwargs.get("pricing_info")
+        trace_content = kwargs.get("trace_content")
+        disable_metrics = kwargs.get("disable_metrics")
+        version = importlib.metadata.version("astrapy")
+        # Sync
+        wrap_function_wrapper(
+            "astrapy.database",
+            "Database.create_collection",
+            general_wrap("astra.create_collection", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.database",
+            "Database.drop_collection",
+            general_wrap("astra.drop_collection", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.insert_one",
+            general_wrap("astra.insert_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.insert_many",
+            general_wrap("astra.insert_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.update_one",
+            general_wrap("astra.update_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.update_many",
+            general_wrap("astra.update_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.find_one_and_update",
+            general_wrap("astra.find_one_and_update", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.find",
+            general_wrap("astra.find", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.replace_one",
+            general_wrap("astra.replace_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.find_one_and_delete",
+            general_wrap("astra.find_one_and_delete", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.delete_one",
+            general_wrap("astra.delete_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "Collection.delete_many",
+            general_wrap("astra.delete_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        # ASync
+        wrap_function_wrapper(
+            "astrapy.database",
+            "AsyncDatabase.create_collection",
+            general_wrap("astra.create_collection", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.database",
+            "AsyncDatabase.drop_collection",
+            general_wrap("astra.drop_collection", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.insert_one",
+            general_wrap("astra.insert_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.insert_many",
+            general_wrap("astra.insert_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.update_one",
+            general_wrap("astra.update_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.update_many",
+            general_wrap("astra.update_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.find_one_and_update",
+            general_wrap("astra.find_one_and_update", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.find",
+            general_wrap("astra.find", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.replace_one",
+            general_wrap("astra.replace_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.find_one_and_delete",
+            general_wrap("astra.find_one_and_delete", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.delete_one",
+            general_wrap("astra.delete_one", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+        wrap_function_wrapper(
+            "astrapy.collection",
+            "AsyncCollection.delete_many",
+            general_wrap("astra.delete_many", version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics),
+        )
+    @staticmethod
+    def _uninstrument(self, **kwargs):
+        pass

openlit/instrumentation/astra/astra.py ADDED Viewed

@@ -0,0 +1,226 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, too-many-branches
+"""
+Module for monitoring AstraDB.
+"""
+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 object_count(obj):
+    """
+    Counts Length of object if it exists, Else returns None
+    """
+    return len(obj) if obj else None
+def general_wrap(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Wraps a AstraDB operation to trace and log its execution metrics.
+    This function is intended to wrap around AstraDB operations in order to
+    measure their execution time, log relevant information, and trace the execution
+    using OpenTelemetry. This helps in monitoring and debugging operations within
+    the AstraDB space.
+    Parameters:
+    - operation (str): The specific AstraDB operation being monitored.
+                                Examples include 'create_index', 'query', 'upsert', etc.
+    - version (str): The version of the application interfacing with AstraDB.
+    - environment (str): The deployment environment, such as 'production' or 'development'.
+    - application_name (str): The name of the application performing the AstraDB operation.
+    - tracer (opentelemetry.trace.Tracer): An object used for OpenTelemetry tracing.
+    - pricing_info (dict): Information about pricing, not used in current implementation.
+    - trace_content (bool): A flag indicating whether the content of responses should be traced.
+    Returns:
+    - function: A decorator function that, when applied, wraps the target function with
+                additional functionality for tracing and logging AstraDB operations.
+    """
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Executes the wrapped AstraDB operation, adding tracing and logging.
+        This inner wrapper function captures the execution of AstraDB operations,
+        annotating the operation with relevant metrics and tracing information, and
+        ensuring any exceptions are caught and logged appropriately.
+        Parameters:
+        - wrapped (Callable): The AstraDB operation to be wrapped and executed.
+        - instance (object): The instance on which the operation is called (for class methods).
+        - args (tuple): Positional arguments for the AstraDB operation.
+        - kwargs (dict): Keyword arguments for the AstraDB operation.
+        Returns:
+        - Any: The result of executing the wrapped AstraDB operation.
+        """
+        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_ENDPOINT,
+                                   gen_ai_endpoint)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                   environment)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                   application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                   SemanticConvetion.GEN_AI_TYPE_VECTORDB)
+                span.set_attribute(SemanticConvetion.DB_SYSTEM,
+                                   SemanticConvetion.DB_SYSTEM_ASTRA)
+                if gen_ai_endpoint == "astra.create_collection":
+                    db_operation = SemanticConvetion.DB_OPERATION_CREATE_COLLECTION
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       response.name)
+                    span.set_attribute(SemanticConvetion.DB_INDEX_DIMENSION,
+                                       kwargs.get("dimension", ""))
+                    span.set_attribute(SemanticConvetion.DB_INDEX_METRIC,
+                                       kwargs.get("metric", ""))
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                        instance.api_endpoint)
+                elif gen_ai_endpoint == "astra.drop_collection":
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE_COLLECTION
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       kwargs.get("name_or_collection", ""))
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.api_endpoint)
+                elif gen_ai_endpoint == "astra.insert_one":
+                    db_operation = SemanticConvetion.DB_OPERATION_INSERT
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       1)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_ID,
+                                       response.inserted_id)
+                elif gen_ai_endpoint == "astra.insert_many":
+                    db_operation = SemanticConvetion.DB_OPERATION_INSERT
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       object_count(args[0]))
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                elif gen_ai_endpoint in ["astra.update_one", "astra.update_many"]:
+                    db_operation = SemanticConvetion.DB_OPERATION_UPDATE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       response.update_info.get("nModified", 0))
+                elif gen_ai_endpoint == "astra.find_one_and_update":
+                    db_operation = SemanticConvetion.DB_OPERATION_UPDATE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                elif gen_ai_endpoint == "astra.find":
+                    db_operation = SemanticConvetion.DB_OPERATION_QUERY
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                elif gen_ai_endpoint == "astra.replace_one":
+                    if kwargs.get("upsert") is True:
+                        db_operation = SemanticConvetion.DB_OPERATION_UPSERT
+                    else:
+                        db_operation = SemanticConvetion.DB_OPERATION_REPLACE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                elif gen_ai_endpoint in ["astra.delete_one", "astra.delete_many"]:
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       response.deleted_count)
+                elif gen_ai_endpoint == "astra.find_one_and_delete":
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                span.set_status(Status(StatusCode.OK))
+                if disable_metrics is False:
+                    attributes = {
+                        TELEMETRY_SDK_NAME:
+                            "openlit",
+                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                            application_name,
+                        SemanticConvetion.DB_SYSTEM:
+                            SemanticConvetion.DB_SYSTEM_ASTRA,
+                        SemanticConvetion.GEN_AI_ENVIRONMENT:
+                            environment,
+                        SemanticConvetion.GEN_AI_TYPE:
+                            SemanticConvetion.GEN_AI_TYPE_VECTORDB,
+                        SemanticConvetion.DB_OPERATION:
+                            db_operation
+                    }
+                    metrics["db_requests"].add(1, 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/astra/async_astra.py ADDED Viewed

@@ -0,0 +1,226 @@
+# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, possibly-used-before-assignment, too-many-branches
+"""
+Module for monitoring AstraDB.
+"""
+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 object_count(obj):
+    """
+    Counts Length of object if it exists, Else returns None
+    """
+    return len(obj) if obj else None
+def general_wrap(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+    """
+    Wraps a AstraDB operation to trace and log its execution metrics.
+    This function is intended to wrap around AstraDB operations in order to
+    measure their execution time, log relevant information, and trace the execution
+    using OpenTelemetry. This helps in monitoring and debugging operations within
+    the AstraDB space.
+    Parameters:
+    - operation (str): The specific AstraDB operation being monitored.
+                                Examples include 'create_index', 'query', 'upsert', etc.
+    - version (str): The version of the application interfacing with AstraDB.
+    - environment (str): The deployment environment, such as 'production' or 'development'.
+    - application_name (str): The name of the application performing the AstraDB operation.
+    - tracer (opentelemetry.trace.Tracer): An object used for OpenTelemetry tracing.
+    - pricing_info (dict): Information about pricing, not used in current implementation.
+    - trace_content (bool): A flag indicating whether the content of responses should be traced.
+    Returns:
+    - function: A decorator function that, when applied, wraps the target function with
+                additional functionality for tracing and logging AstraDB operations.
+    """
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Executes the wrapped AstraDB operation, adding tracing and logging.
+        This inner wrapper function captures the execution of AstraDB operations,
+        annotating the operation with relevant metrics and tracing information, and
+        ensuring any exceptions are caught and logged appropriately.
+        Parameters:
+        - wrapped (Callable): The AstraDB operation to be wrapped and executed.
+        - instance (object): The instance on which the operation is called (for class methods).
+        - args (tuple): Positional arguments for the AstraDB operation.
+        - kwargs (dict): Keyword arguments for the AstraDB operation.
+        Returns:
+        - Any: The result of executing the wrapped AstraDB operation.
+        """
+        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+            response = await wrapped(*args, **kwargs)
+            try:
+                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
+                                   gen_ai_endpoint)
+                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                                   environment)
+                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                                   application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_TYPE,
+                                   SemanticConvetion.GEN_AI_TYPE_VECTORDB)
+                span.set_attribute(SemanticConvetion.DB_SYSTEM,
+                                   SemanticConvetion.DB_SYSTEM_ASTRA)
+                if gen_ai_endpoint == "astra.create_collection":
+                    db_operation = SemanticConvetion.DB_OPERATION_CREATE_COLLECTION
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       response.name)
+                    span.set_attribute(SemanticConvetion.DB_INDEX_DIMENSION,
+                                       kwargs.get("dimension", ""))
+                    span.set_attribute(SemanticConvetion.DB_INDEX_METRIC,
+                                       kwargs.get("metric", ""))
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                        instance.api_endpoint)
+                elif gen_ai_endpoint == "astra.drop_collection":
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE_COLLECTION
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       kwargs.get("name_or_collection", ""))
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.api_endpoint)
+                elif gen_ai_endpoint == "astra.insert_one":
+                    db_operation = SemanticConvetion.DB_OPERATION_INSERT
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       1)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_ID,
+                                       response.inserted_id)
+                elif gen_ai_endpoint == "astra.insert_many":
+                    db_operation = SemanticConvetion.DB_OPERATION_INSERT
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       object_count(args[0]))
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                elif gen_ai_endpoint in ["astra.update_one", "astra.update_many"]:
+                    db_operation = SemanticConvetion.DB_OPERATION_UPDATE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       response.update_info.get("nModified", 0))
+                elif gen_ai_endpoint == "astra.find_one_and_update":
+                    db_operation = SemanticConvetion.DB_OPERATION_UPDATE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                elif gen_ai_endpoint == "astra.find":
+                    db_operation = SemanticConvetion.DB_OPERATION_QUERY
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                elif gen_ai_endpoint == "astra.replace_one":
+                    if kwargs.get("upsert") is True:
+                        db_operation = SemanticConvetion.DB_OPERATION_UPSERT
+                    else:
+                        db_operation = SemanticConvetion.DB_OPERATION_REPLACE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                elif gen_ai_endpoint in ["astra.delete_one", "astra.delete_many"]:
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                    span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT,
+                                       response.deleted_count)
+                elif gen_ai_endpoint == "astra.find_one_and_delete":
+                    db_operation = SemanticConvetion.DB_OPERATION_DELETE
+                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                                       db_operation)
+                    span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
+                                       instance.name)
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_API_ENDPOINT,
+                                       instance.database.api_endpoint)
+                    span.set_attribute(SemanticConvetion.DB_STATEMENT,
+                                       str(args))
+                span.set_status(Status(StatusCode.OK))
+                if disable_metrics is False:
+                    attributes = {
+                        TELEMETRY_SDK_NAME:
+                            "openlit",
+                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
+                            application_name,
+                        SemanticConvetion.DB_SYSTEM:
+                            SemanticConvetion.DB_SYSTEM_ASTRA,
+                        SemanticConvetion.GEN_AI_ENVIRONMENT:
+                            environment,
+                        SemanticConvetion.GEN_AI_TYPE:
+                            SemanticConvetion.GEN_AI_TYPE_VECTORDB,
+                        SemanticConvetion.DB_OPERATION:
+                            db_operation
+                    }
+                    metrics["db_requests"].add(1, 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/semcov/__init__.py CHANGED Viewed

@@ -121,17 +121,21 @@ class SemanticConvetion:
     GEN_AI_SYSTEM_JULEP = "julep"
     # Vector DB
+    DB_OPERATION_API_ENDPOINT = "db.operation.api_endpoint"
     DB_REQUESTS = "db.total.requests"
     DB_SYSTEM = "db.system"
     DB_COLLECTION_NAME = "db.collection.name"
     DB_OPERATION = "db.operation"
+    DB_OPERATION_ID = "db.operation.id"
     DB_OPERATION_STATUS = "db.operation.status"
     DB_OPERATION_COST = "db.operation.cost"
     DB_OPERATION_CREATE_INDEX = "create_index"
     DB_OPERATION_CREATE_COLLECTION = "create_collection"
     DB_OPERATION_UPDATE_COLLECTION = "update_collection"
     DB_OPERATION_DELETE_COLLECTION = "delete_collection"
+    DB_OPERATION_INSERT = "insert"
     DB_OPERATION_QUERY = "query"
+    DB_OPERATION_REPLACE = "replace"
     DB_OPERATION_DELETE = "delete"
     DB_OPERATION_UPDATE = "update"
     DB_OPERATION_UPSERT = "upsert"
@@ -166,6 +170,7 @@ class SemanticConvetion:
     DB_SYSTEM_PINECONE = "pinecone"
     DB_SYSTEM_QDRANT = "qdrant"
     DB_SYSTEM_MILVUS = "milvus"
+    DB_SYSTEM_ASTRA = "astra"
     # Agents
     GEN_AI_AGENT_ID = "gen_ai.agent.id"

{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openlit
-Version: 1.32.2
+Version: 1.32.3
 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
@@ -56,7 +56,7 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi
 ## ⚡ Features
-- 🔎 **Auto Instrumentation**: Works with 30+ LLM providers, vector databases, and GPUs with just one line of code.
+- 🔎 **Auto Instrumentation**: Works with 40+ LLM providers, Agents, Vector databases, and GPUs with just one line of code.
 - 🔭 **OpenTelemetry-Native Observability SDKs**: Vendor-neutral SDKs that can send traces and metrics to your existing observability tool like Prometheus and Jaeger.
 - 💲 **Cost Tracking for Custom and Fine-Tuned Models**: Pass custom pricing files for accurate budgeting of custom and fine-tuned models.
 - 🚀 **Suppport for OpenLIT Features**: Includes suppprt for prompt management and secrets management features available in OpenLIT.
@@ -69,7 +69,7 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi
 | [✅ 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](https://docs.openlit.io/latest/integrations/amd-gpu)      |
 | [✅ 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)    |               |
+| [✅ Cohere](https://docs.openlit.io/latest/integrations/cohere)                      | [✅ AstraDB](https://docs.openlit.io/latest/integrations/astradb) | [✅ 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) |                                                                          | [✅ DSPy](https://docs.openlit.io/latest/integrations/dspy)                |               |

{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/RECORD RENAMED Viewed

@@ -1,5 +1,5 @@
 openlit/__helpers.py,sha256=2OkGKOdsd9Hc011WxR70OqDlO6c4mZcu6McGuW1uAdA,6316
-openlit/__init__.py,sha256=F9WoSIEnxzZzZFGy1z---7gB7BlwMRcyph4lHdhgp-Q,20870
+openlit/__init__.py,sha256=aFhA4yNRGE17CB1heL4GEWTZcPQZpJ1-7_yZel8cm6A,21000
 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
@@ -17,6 +17,9 @@ openlit/instrumentation/ag2/ag2.py,sha256=_ncg8RqUH-wXMYfaOYx2bcQOrOrDMVVm0EZAEk
 openlit/instrumentation/anthropic/__init__.py,sha256=oaU53BOPyfUKbEzYvLr1DPymDluurSnwo4Hernf2XdU,1955
 openlit/instrumentation/anthropic/anthropic.py,sha256=y7CEGhKOGHWt8G_5Phr4qPJTfPGRJIAr9Yk6nM3CcvM,16775
 openlit/instrumentation/anthropic/async_anthropic.py,sha256=Zz1KRKIG9wGn0quOoLvjORC-49IvHQpJ6GBdB-4PfCQ,16816
+openlit/instrumentation/astra/__init__.py,sha256=G4alCOR6hXQvUQPDCS8lY1rj0Mz-KmrW5vVWk5loO78,8054
+openlit/instrumentation/astra/astra.py,sha256=ddZuzwhsszQK1nsttJrQ01YKsvbOJ4I6HHNFAS2KdtY,12074
+openlit/instrumentation/astra/async_astra.py,sha256=4l6HlQdCjPKZNFmKRGqEO0LMkSvwxLbg4BJ6x5RrSu4,12086
 openlit/instrumentation/azure_ai_inference/__init__.py,sha256=Xl_4hjQeXcA-NgkqwTbs1ejPKRRnQXsDErXfFIz0z7U,2699
 openlit/instrumentation/azure_ai_inference/async_azure_ai_inference.py,sha256=T3SLSJxwrjOaGGkedB6DT92SCHLWbaJu5YAzZzAeBsk,22748
 openlit/instrumentation/azure_ai_inference/azure_ai_inference.py,sha256=IzwDZ99h7HpOI-NnEkYqOIh2sAm-2aHi4BcTMoXNx1c,22694
@@ -95,8 +98,8 @@ openlit/instrumentation/vllm/__init__.py,sha256=OVWalQ1dXvip1DUsjUGaHX4J-2FrSp-T
 openlit/instrumentation/vllm/vllm.py,sha256=lDzM7F5pgxvh8nKL0dcKB4TD0Mc9wXOWeXOsOGN7Wd8,6527
 openlit/otel/metrics.py,sha256=y7SQDTyfLakMrz0V4DThN-WAeap7YZzyndeYGSP6nVg,4516
 openlit/otel/tracing.py,sha256=fG3vl-flSZ30whCi7rrG25PlkIhhr8PhnfJYCkZzCD0,3895
-openlit/semcov/__init__.py,sha256=asA0rhBek-BcovxS2EVz-pTsLpt0FE6aaR-7RaIqPaQ,9877
-openlit-1.32.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openlit-1.32.2.dist-info/METADATA,sha256=96ZqO5vl3oosge89lLRgOQqHUUM5-I-bVdJWcItGDcM,22396
-openlit-1.32.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-openlit-1.32.2.dist-info/RECORD,,
+openlit/semcov/__init__.py,sha256=knUQxtYMGrW3fwfx8uXGn0E17WLxVPTkWVNQWvY4w8g,10079
+openlit-1.32.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openlit-1.32.3.dist-info/METADATA,sha256=qrskMzUSxlj4SSzStMeKinTmB9dArpURwvS-s5NGJAY,22430
+openlit-1.32.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+openlit-1.32.3.dist-info/RECORD,,

{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/LICENSE RENAMED Viewed

File without changes

{openlit-1.32.2.dist-info → openlit-1.32.3.dist-info}/WHEEL RENAMED Viewed

File without changes

openlit 1.32.2__py3-none-any.whl → 1.32.3__py3-none-any.whl

openlit 1.32.2py3-none-any.whl → 1.32.3py3-none-any.whl