openlit 1.33.14__tar.gz → 1.33.16__tar.gz

{openlit-1.33.14 → openlit-1.33.16}/PKG-INFO

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

{openlit-1.33.14 → openlit-1.33.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openlit"
-version = "1.33.14"
+version = "1.33.16"
 description = "OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects"
 authors = ["OpenLIT"]
 license = "Apache-2.0"

{openlit-1.33.14 → openlit-1.33.16}/src/openlit/__init__.py

@@ -65,6 +65,7 @@ from openlit.instrumentation.controlflow import ControlFlowInstrumentor
 from openlit.instrumentation.crawl4ai import Crawl4AIInstrumentor
 from openlit.instrumentation.firecrawl import FireCrawlInstrumentor
 from openlit.instrumentation.letta import LettaInstrumentor
+from openlit.instrumentation.openai_agents import OpenAIAgentsInstrumentor
 from openlit.instrumentation.gpu import GPUInstrumentor
 import openlit.guard
 import openlit.evals
@@ -293,6 +294,7 @@ def init(
         "firecrawl": "firecrawl",
         "letta": "letta",
         "together": "together",
+        "openai-agents": "agents"
     }
 
     invalid_instrumentors = [
@@ -411,6 +413,7 @@ def init(
             "firecrawl": FireCrawlInstrumentor(),
             "letta": LettaInstrumentor(),
             "together": TogetherInstrumentor(),
+            "openai-agents": OpenAIAgentsInstrumentor(),
         }
 
         # Initialize and instrument only the enabled instrumentors

{openlit-1.33.14 → openlit-1.33.16}/src/openlit/instrumentation/astra/__init__.py

@@ -1,4 +1,3 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
 """Initializer of Auto Instrumentation of AstraDB Functions"""
 from typing import Collection
 import importlib.metadata
@@ -8,7 +7,7 @@ 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",)
+_instruments = ('astrapy >= 1.5.2',)
 
 class AstraInstrumentor(BaseInstrumentor):
     """An instrumentor for AstraDB's client library."""
@@ -17,163 +16,163 @@ class AstraInstrumentor(BaseInstrumentor):
         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")
-        capture_message_content = kwargs.get("capture_message_content")
-        disable_metrics = kwargs.get("disable_metrics")
-        version = importlib.metadata.version("astrapy")
+        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')
+        capture_message_content = kwargs.get('capture_message_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,
+            'astrapy.database',
+            'Database.create_collection',
+            general_wrap('astra.create_collection', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.database",
-            "Database.drop_collection",
-            general_wrap("astra.drop_collection", version, environment, application_name,
+            'astrapy.database',
+            'Database.drop_collection',
+            general_wrap('astra.drop_collection', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.insert_one",
-            general_wrap("astra.insert_one", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.insert_one',
+            general_wrap('astra.insert', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.insert_many",
-            general_wrap("astra.insert_many", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.insert_many',
+            general_wrap('astra.insert', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.update_one",
-            general_wrap("astra.update_one", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.update_one',
+            general_wrap('astra.update', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.update_many",
-            general_wrap("astra.update_many", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.update_many',
+            general_wrap('astra.update', version, environment, application_name,
                  tracer, pricing_info, capture_message_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,
+            'astrapy.collection',
+            'Collection.find_one_and_update',
+            general_wrap('astra.find_one_and_update', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.find",
-            general_wrap("astra.find", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.find',
+            general_wrap('astra.find', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.replace_one",
-            general_wrap("astra.replace_one", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.replace_one',
+            general_wrap('astra.replace_one', version, environment, application_name,
                  tracer, pricing_info, capture_message_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,
+            'astrapy.collection',
+            'Collection.find_one_and_delete',
+            general_wrap('astra.find_one_and_delete', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.delete_one",
-            general_wrap("astra.delete_one", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.delete_one',
+            general_wrap('astra.delete', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "Collection.delete_many",
-            general_wrap("astra.delete_many", version, environment, application_name,
+            'astrapy.collection',
+            'Collection.delete_many',
+            general_wrap('astra.delete', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         # ASync
         wrap_function_wrapper(
-            "astrapy.database",
-            "AsyncDatabase.create_collection",
-            general_wrap("astra.create_collection", version, environment, application_name,
+            'astrapy.database',
+            'AsyncDatabase.create_collection',
+            general_wrap('astra.create_collection', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.database",
-            "AsyncDatabase.drop_collection",
-            general_wrap("astra.drop_collection", version, environment, application_name,
+            'astrapy.database',
+            'AsyncDatabase.drop_collection',
+            general_wrap('astra.drop_collection', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.insert_one",
-            general_wrap("astra.insert_one", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.insert_one',
+            general_wrap('astra.insert_one', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.insert_many",
-            general_wrap("astra.insert_many", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.insert_many',
+            general_wrap('astra.insert_many', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.update_one",
-            general_wrap("astra.update_one", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.update_one',
+            general_wrap('astra.update_one', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.update_many",
-            general_wrap("astra.update_many", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.update_many',
+            general_wrap('astra.update_many', version, environment, application_name,
                  tracer, pricing_info, capture_message_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,
+            'astrapy.collection',
+            'AsyncCollection.find_one_and_update',
+            general_wrap('astra.find_one_and_update', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.find",
-            general_wrap("astra.find", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.find',
+            general_wrap('astra.find', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.replace_one",
-            general_wrap("astra.replace_one", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.replace_one',
+            general_wrap('astra.replace_one', version, environment, application_name,
                  tracer, pricing_info, capture_message_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,
+            'astrapy.collection',
+            'AsyncCollection.find_one_and_delete',
+            general_wrap('astra.find_one_and_delete', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.delete_one",
-            general_wrap("astra.delete_one", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.delete_one',
+            general_wrap('astra.delete_one', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
-            "astrapy.collection",
-            "AsyncCollection.delete_many",
-            general_wrap("astra.delete_many", version, environment, application_name,
+            'astrapy.collection',
+            'AsyncCollection.delete_many',
+            general_wrap('astra.delete_many', version, environment, application_name,
                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
-    @staticmethod
     def _uninstrument(self, **kwargs):
+        # Proper uninstrumentation logic to revert patched methods
         pass

openlit-1.33.16/src/openlit/instrumentation/astra/astra.py

@@ -0,0 +1,45 @@
+"""
+Module for monitoring AstraDB.
+"""
+
+import time
+from opentelemetry.trace import SpanKind
+from openlit.instrumentation.astra.utils import (
+    DB_OPERATION_MAP,
+    process_db_operations
+)
+from openlit.semcov import SemanticConvetion
+
+def general_wrap(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for VectorDB function call
+    """
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the VectorDB function call.
+        """
+
+        db_operation = DB_OPERATION_MAP.get(gen_ai_endpoint, "UNKNOWN")
+        if db_operation == SemanticConvetion.DB_OPERATION_REPLACE and kwargs.get('upsert'):
+            db_operation = SemanticConvetion.DB_OPERATION_UPSERT
+
+        span_name = f"{db_operation} {instance.name}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            response = wrapped(*args, **kwargs)
+            server_address = getattr(getattr(instance, 'database', instance), 'api_endpoint', '')
+            server_port = 443
+            collection_name = instance.name
+            response = process_db_operations(
+                response, span, start_time, gen_ai_endpoint,
+                version, environment, application_name, capture_message_content,
+                metrics, disable_metrics, server_address, server_port,
+                collection_name, db_operation, kwargs, args
+            )
+
+            return response
+
+    return wrapper

openlit-1.33.16/src/openlit/instrumentation/astra/async_astra.py

@@ -0,0 +1,45 @@
+"""
+Module for monitoring AstraDB.
+"""
+
+import time
+from opentelemetry.trace import SpanKind
+from openlit.instrumentation.astra.utils import (
+    DB_OPERATION_MAP,
+    process_db_operations
+)
+from openlit.semcov import SemanticConvetion
+
+def async_general_wrap(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for VectorDB function call
+    """
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the VectorDB function call.
+        """
+
+        db_operation = DB_OPERATION_MAP.get(gen_ai_endpoint, "UNKNOWN")
+        if db_operation == SemanticConvetion.DB_OPERATION_REPLACE and kwargs.get('upsert'):
+            db_operation = SemanticConvetion.DB_OPERATION_UPSERT
+
+        span_name = f"{db_operation} {instance.name}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
+            response = await wrapped(*args, **kwargs)
+            server_address = getattr(getattr(instance, 'database', instance), 'api_endpoint', '')
+            server_port = 443
+            collection_name = instance.name
+            response = process_db_operations(
+                response, span, start_time, gen_ai_endpoint,
+                version, environment, application_name, capture_message_content,
+                metrics, disable_metrics, server_address, server_port,
+                collection_name, db_operation, kwargs, args
+            )
+
+            return response
+
+    return wrapper

openlit-1.33.16/src/openlit/instrumentation/astra/utils.py

@@ -0,0 +1,102 @@
+"""
+Astra OpenTelemetry instrumentation utility functions
+"""
+
+import time
+import logging
+from opentelemetry.trace import Status, StatusCode
+from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+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 isinstance(obj, list) else 1
+
+DB_OPERATION_MAP = {
+    'astra.create_collection': SemanticConvetion.DB_OPERATION_CREATE_COLLECTION,
+    'astra.drop_collection': SemanticConvetion.DB_OPERATION_DELETE_COLLECTION,
+    'astra.insert': SemanticConvetion.DB_OPERATION_INSERT,
+    'astra.update': SemanticConvetion.DB_OPERATION_UPDATE,
+    'astra.find': SemanticConvetion.DB_OPERATION_SELECT,
+    'astra.find_one_and_update': SemanticConvetion.DB_OPERATION_REPLACE,
+    'astra.replace_one': SemanticConvetion.DB_OPERATION_REPLACE,
+    'astra.delete': SemanticConvetion.DB_OPERATION_DELETE,
+    'astra.find_one_and_delete': SemanticConvetion.DB_OPERATION_FIND_AND_DELETE
+}
+
+def process_db_operations(response, span, start_time, gen_ai_endpoint,
+        version, environment, application_name,
+        capture_message_content, metrics, disable_metrics, server_address,
+        server_port, collection_name, db_operation, kwargs, args):
+    """
+    Process DB operation and generate Telemetry
+    """
+
+    end_time = time.time()
+
+    try:
+        span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')
+        span.set_attribute(SemanticConvetion.GEN_AI_OPERATION, SemanticConvetion.GEN_AI_OPERATION_TYPE_VECTORDB)
+        span.set_attribute(SemanticConvetion.DB_SYSTEM_NAME, SemanticConvetion.DB_SYSTEM_ASTRA)
+        span.set_attribute(SemanticConvetion.DB_CLIENT_OPERATION_DURATION, end_time - start_time)
+        span.set_attribute(SemanticConvetion.SERVER_ADDRESS, server_address)
+        span.set_attribute(SemanticConvetion.SERVER_PORT, server_port)
+        span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+        span.set_attribute(SERVICE_NAME, application_name)
+        span.set_attribute(SemanticConvetion.DB_OPERATION_NAME, db_operation)
+        span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME, collection_name)
+        span.set_attribute(SemanticConvetion.DB_SDK_VERSION, version)
+
+        if db_operation == SemanticConvetion.DB_OPERATION_CREATE_COLLECTION:
+            span.set_attribute(SemanticConvetion.DB_NAMESPACE, response.keyspace)
+            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, str(kwargs.get('metric', '')))
+
+        if db_operation == SemanticConvetion.DB_OPERATION_INSERT:
+            span.set_attribute(SemanticConvetion.DB_DOCUMENTS_COUNT, object_count(args[0]))
+            span.set_attribute(SemanticConvetion.DB_QUERY_TEXT, str(args[0] or kwargs.get('documents', {})))
+
+        elif db_operation == SemanticConvetion.DB_OPERATION_UPDATE:
+            span.set_attribute(SemanticConvetion.DB_RESPONSE_RETURNED_ROWS, response.update_info.get('nModified', 0))
+            span.set_attribute(SemanticConvetion.DB_QUERY_TEXT, str(args[1] or kwargs.get('update', {})))
+
+        elif db_operation == SemanticConvetion.DB_OPERATION_DELETE:
+            span.set_attribute(SemanticConvetion.DB_RESPONSE_RETURNED_ROWS, response.deleted_count)
+            span.set_attribute(SemanticConvetion.DB_QUERY_TEXT, str(args[0] or kwargs.get('filter', {})))
+
+        elif db_operation in [
+            SemanticConvetion.DB_OPERATION_SELECT,
+            SemanticConvetion.DB_OPERATION_FIND_AND_DELETE,
+            SemanticConvetion.DB_OPERATION_REPLACE
+        ]:
+            span.set_attribute(SemanticConvetion.DB_QUERY_TEXT, str(args or kwargs.get('filter', {})))
+
+        span.set_status(Status(StatusCode.OK))
+
+        if not disable_metrics:
+            attributes = {
+                TELEMETRY_SDK_NAME: 'openlit',
+                SERVICE_NAME: application_name,
+                SemanticConvetion.DB_SYSTEM_NAME: SemanticConvetion.DB_SYSTEM_ASTRA,
+                DEPLOYMENT_ENVIRONMENT: environment,
+                SemanticConvetion.GEN_AI_OPERATION: SemanticConvetion.GEN_AI_OPERATION_TYPE_VECTORDB,
+                SemanticConvetion.DB_OPERATION_NAME: db_operation
+            }
+
+            metrics['db_requests'].add(1, attributes)
+            metrics['db_client_operation_duration'].record(end_time - start_time, 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

{openlit-1.33.14 → openlit-1.33.16}/src/openlit/instrumentation/chroma/chroma.py

@@ -79,14 +79,14 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                                    application_name)
                 span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
                                    SemanticConvetion.GEN_AI_OPERATION_TYPE_VECTORDB)
-                span.set_attribute(SemanticConvetion.DB_SYSTEM,
+                span.set_attribute(SemanticConvetion.DB_SYSTEM_NAME,
                                    SemanticConvetion.DB_SYSTEM_CHROMA)
                 span.set_attribute(SemanticConvetion.DB_COLLECTION_NAME,
                                    instance.name)
 
                 if gen_ai_endpoint == "chroma.add":
                     db_operation = SemanticConvetion.DB_OPERATION_ADD
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_ADD)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
                                        object_count(kwargs.get("ids", [])))
@@ -99,7 +99,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.get":
                     db_operation = SemanticConvetion.DB_OPERATION_GET
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_GET)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
                                        object_count(kwargs.get("ids", [])))
@@ -112,7 +112,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.query":
                     db_operation = SemanticConvetion.DB_OPERATION_QUERY
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_QUERY)
                     span.set_attribute(SemanticConvetion.DB_STATEMENT,
                                        str(kwargs.get("query_texts", "")))
@@ -125,7 +125,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.update":
                     db_operation = SemanticConvetion.DB_OPERATION_UPDATE
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_UPDATE)
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
                                        object_count(kwargs.get("embeddings", [])))
@@ -138,7 +138,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.upsert":
                     db_operation = SemanticConvetion.DB_OPERATION_UPSERT
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_UPSERT)
                     span.set_attribute(SemanticConvetion.DB_VECTOR_COUNT,
                                        object_count(kwargs.get("embeddings", [])))
@@ -151,7 +151,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.delete":
                     db_operation = SemanticConvetion.DB_OPERATION_DELETE
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_DELETE)
                     span.set_attribute(SemanticConvetion.DB_ID_COUNT,
                                        object_count(kwargs.get("ids", [])))
@@ -164,7 +164,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
 
                 elif gen_ai_endpoint == "chroma.peek":
                     db_operation = SemanticConvetion.DB_OPERATION_PEEK
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_PEEK)
 
                 span.set_status(Status(StatusCode.OK))
@@ -175,13 +175,13 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                             "openlit",
                         SERVICE_NAME:
                             application_name,
-                        SemanticConvetion.DB_SYSTEM:
+                        SemanticConvetion.DB_SYSTEM_NAME:
                             SemanticConvetion.DB_SYSTEM_CHROMA,
                         DEPLOYMENT_ENVIRONMENT:
                             environment,
                         SemanticConvetion.GEN_AI_OPERATION:
                             SemanticConvetion.GEN_AI_OPERATION_TYPE_VECTORDB,
-                        SemanticConvetion.DB_OPERATION:
+                        SemanticConvetion.DB_OPERATION_NAME:
                             db_operation
                     }
 

{openlit-1.33.14 → openlit-1.33.16}/src/openlit/instrumentation/dynamiq/dynamiq.py

@@ -84,13 +84,13 @@ def dynamiq_wrap(gen_ai_endpoint, version, environment, application_name,
                       getattr(getattr(instance.flow, 'nodes', [None])[0], 'model', 'default_model'))
 
                 elif gen_ai_endpoint == "dynamiq.memory_add":
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_ADD)
                     span.set_attribute(SemanticConvetion.DB_METADATA, str(kwargs.get('metadata', '')))
 
                 elif gen_ai_endpoint == "dynamiq.memory_search":
                     query_value = kwargs.get('query', '') or (args[0] if args else '')
-                    span.set_attribute(SemanticConvetion.DB_OPERATION,
+                    span.set_attribute(SemanticConvetion.DB_OPERATION_NAME,
                                        SemanticConvetion.DB_OPERATION_GET)
                     span.set_attribute(SemanticConvetion.DB_FILTER, str(kwargs.get('filters', '')))
                     span.set_attribute(SemanticConvetion.DB_STATEMENT, query_value)