openlit 1.34.29__py3-none-any.whl → 1.34.31__py3-none-any.whl

openlit/instrumentation/qdrant/utils.py

@@ -35,6 +35,7 @@ DB_OPERATION_MAP = {
     "qdrant.create_payload_index": SemanticConvention.DB_OPERATION_CREATE_INDEX,
 }
 
+
 def object_count(obj):
     """
     Counts Length of object if it exists, Else returns 0.
@@ -44,6 +45,7 @@ def object_count(obj):
     except (TypeError, AttributeError):
         return 0
 
+
 def set_server_address_and_port(instance):
     """
     Extracts server address and port from Qdrant client instance.
@@ -79,75 +81,117 @@ def set_server_address_and_port(instance):
 
     return server_address, server_port
 
-def common_qdrant_logic(scope, environment, application_name,
-    metrics, capture_message_content, disable_metrics, version,
-    instance=None, endpoint=None):
+
+def common_qdrant_logic(
+    scope,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+    instance=None,
+    endpoint=None,
+):
     """
     Process Qdrant request and generate telemetry.
     """
     scope._end_time = time.time()
 
     # Set common database span attributes using helper
-    common_db_span_attributes(scope, SemanticConvention.DB_SYSTEM_QDRANT,
-        scope._server_address, scope._server_port,
-        environment, application_name, version)
+    common_db_span_attributes(
+        scope,
+        SemanticConvention.DB_SYSTEM_QDRANT,
+        scope._server_address,
+        scope._server_port,
+        environment,
+        application_name,
+        version,
+    )
 
     # Set DB operation specific attributes
     scope._span.set_attribute(SemanticConvention.DB_OPERATION_NAME, scope._db_operation)
-    scope._span.set_attribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION,
-        scope._end_time - scope._start_time)
+    scope._span.set_attribute(
+        SemanticConvention.DB_CLIENT_OPERATION_DURATION,
+        scope._end_time - scope._start_time,
+    )
 
     # Handle collection management operations
-    if scope._db_operation in [SemanticConvention.DB_OPERATION_CREATE_COLLECTION,
-                              SemanticConvention.DB_OPERATION_DELETE_COLLECTION,
-                              SemanticConvention.DB_OPERATION_UPDATE_COLLECTION]:
+    if scope._db_operation in [
+        SemanticConvention.DB_OPERATION_CREATE_COLLECTION,
+        SemanticConvention.DB_OPERATION_DELETE_COLLECTION,
+        SemanticConvention.DB_OPERATION_UPDATE_COLLECTION,
+    ]:
         collection_name = scope._kwargs.get("collection_name", "unknown")
 
-        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT,
-            f"Collection: {collection_name}")
-        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-            f"{scope._db_operation} {collection_name}")
+        scope._span.set_attribute(
+            SemanticConvention.DB_COLLECTION_NAME, collection_name
+        )
+        scope._span.set_attribute(
+            SemanticConvention.DB_QUERY_TEXT, f"Collection: {collection_name}"
+        )
+        scope._span.set_attribute(
+            SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name}",
+        )
 
     # Handle data insertion operations
-    elif scope._db_operation in [SemanticConvention.DB_OPERATION_INSERT,
-                                SemanticConvention.DB_OPERATION_UPSERT]:
+    elif scope._db_operation in [
+        SemanticConvention.DB_OPERATION_INSERT,
+        SemanticConvention.DB_OPERATION_UPSERT,
+    ]:
         collection_name = scope._kwargs.get("collection_name", "unknown")
 
         if endpoint == "qdrant.set_payload":
             points = scope._kwargs.get("points", [])
             payload = scope._kwargs.get("payload", {})
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points))
-            scope._span.set_attribute(SemanticConvention.DB_PAYLOAD_COUNT, object_count(payload))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points)
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_PAYLOAD_COUNT, object_count(payload)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
                 f"points={object_count(points)} "
-                f"payload={object_count(payload)}")
+                f"payload={object_count(payload)}",
+            )
 
         elif endpoint in ["qdrant.upsert", "qdrant.upload_points"]:
             points = scope._kwargs.get("points", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
-                f"points={object_count(points)}")
+                f"points={object_count(points)}",
+            )
 
     # Handle data update operations
     elif scope._db_operation == SemanticConvention.DB_OPERATION_UPDATE:
@@ -157,36 +201,52 @@ def common_qdrant_logic(scope, environment, application_name,
             points = scope._kwargs.get("points", [])
             payload = scope._kwargs.get("payload", {})
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points))
-            scope._span.set_attribute(SemanticConvention.DB_PAYLOAD_COUNT, object_count(payload))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points)
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_PAYLOAD_COUNT, object_count(payload)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
                 f"points={object_count(points)} "
-                f"payload={object_count(payload)}")
+                f"payload={object_count(payload)}",
+            )
 
         elif endpoint == "qdrant.update_vectors":
             points = scope._kwargs.get("points", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
-                f"points={object_count(points)}")
+                f"points={object_count(points)}",
+            )
 
     # Handle data deletion operations
     elif scope._db_operation == SemanticConvention.DB_OPERATION_DELETE:
@@ -195,34 +255,50 @@ def common_qdrant_logic(scope, environment, application_name,
         if endpoint in ["qdrant.delete_payload", "qdrant.delete_vectors"]:
             points = scope._kwargs.get("points", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
-                f"points={object_count(points)}")
+                f"points={object_count(points)}",
+            )
 
         elif endpoint in ["qdrant.clear_payload", "qdrant.delete"]:
             points_selector = scope._kwargs.get("points_selector", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(points_selector))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(points_selector))
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_TEXT, str(points_selector)
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(points_selector)
+            )
 
             # Set operation status if response available
             if scope._response and hasattr(scope._response, "status"):
-                scope._span.set_attribute(SemanticConvention.DB_OPERATION_STATUS,
-                    scope._response.status)
+                scope._span.set_attribute(
+                    SemanticConvention.DB_OPERATION_STATUS, scope._response.status
+                )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
-                f"selector={object_count(points_selector)}")
+                f"selector={object_count(points_selector)}",
+            )
 
     # Handle query operations
     elif scope._db_operation == SemanticConvention.DB_OPERATION_GET:
@@ -231,82 +307,133 @@ def common_qdrant_logic(scope, environment, application_name,
         if endpoint == "qdrant.retrieve":
             ids = scope._kwargs.get("ids", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(ids))
-            scope._span.set_attribute(SemanticConvention.DB_VECTOR_COUNT, object_count(ids))
+            scope._span.set_attribute(
+                SemanticConvention.DB_VECTOR_COUNT, object_count(ids)
+            )
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-                f"{scope._db_operation} {collection_name} ids={ids}")
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
+                f"{scope._db_operation} {collection_name} ids={ids}",
+            )
 
         elif endpoint == "qdrant.scroll":
             scroll_filter = scope._kwargs.get("scroll_filter", {})
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(scroll_filter))
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_TEXT, str(scroll_filter)
+            )
             scope._span.set_attribute(SemanticConvention.DB_FILTER, str(scroll_filter))
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-                f"{scope._db_operation} {collection_name} "
-                f"filter={scroll_filter}")
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
+                f"{scope._db_operation} {collection_name} filter={scroll_filter}",
+            )
 
         elif endpoint in ["qdrant.search", "qdrant.search_groups"]:
             query_vector = scope._kwargs.get("query_vector", [])
             limit = scope._kwargs.get("limit", 10)
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(query_vector))
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_TEXT, str(query_vector)
+            )
             scope._span.set_attribute(SemanticConvention.DB_VECTOR_QUERY_TOP_K, limit)
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-                f"{scope._db_operation} {collection_name} "
-                f"limit={limit}")
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
+                f"{scope._db_operation} {collection_name} limit={limit}",
+            )
 
         elif endpoint == "qdrant.recommend":
             positive = scope._kwargs.get("positive", [])
             negative = scope._kwargs.get("negative", [])
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             query_content = f"positive:{positive} negative:{negative}"
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, query_content)
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
                 f"{scope._db_operation} {collection_name} "
                 f"positive={object_count(positive)} "
-                f"negative={object_count(negative)}")
+                f"negative={object_count(negative)}",
+            )
 
         elif endpoint == "qdrant.query_points":
             query = scope._kwargs.get("query", {})
 
-            scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
+            scope._span.set_attribute(
+                SemanticConvention.DB_COLLECTION_NAME, collection_name
+            )
             scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, str(query))
 
-            scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-                f"{scope._db_operation} {collection_name} query={query}")
+            scope._span.set_attribute(
+                SemanticConvention.DB_QUERY_SUMMARY,
+                f"{scope._db_operation} {collection_name} query={query}",
+            )
 
     # Handle index operations
     elif scope._db_operation == SemanticConvention.DB_OPERATION_CREATE_INDEX:
         collection_name = scope._kwargs.get("collection_name", "unknown")
         field_name = scope._kwargs.get("field_name", "unknown")
 
-        scope._span.set_attribute(SemanticConvention.DB_COLLECTION_NAME, collection_name)
-        scope._span.set_attribute(SemanticConvention.DB_QUERY_TEXT, f"Field: {field_name}")
+        scope._span.set_attribute(
+            SemanticConvention.DB_COLLECTION_NAME, collection_name
+        )
+        scope._span.set_attribute(
+            SemanticConvention.DB_QUERY_TEXT, f"Field: {field_name}"
+        )
 
-        scope._span.set_attribute(SemanticConvention.DB_QUERY_SUMMARY,
-            f"{scope._db_operation} {collection_name} field={field_name}")
+        scope._span.set_attribute(
+            SemanticConvention.DB_QUERY_SUMMARY,
+            f"{scope._db_operation} {collection_name} field={field_name}",
+        )
 
     scope._span.set_status(Status(StatusCode.OK))
 
     # Record metrics using helper
     if not disable_metrics:
-        record_db_metrics(metrics, SemanticConvention.DB_SYSTEM_QDRANT,
-            scope._server_address, scope._server_port,
-            environment, application_name,
-            scope._start_time, scope._end_time)
-
-def process_qdrant_response(response, db_operation, server_address, server_port,
-    environment, application_name, metrics, start_time, span,
-    capture_message_content, disable_metrics, version,
-    instance=None, args=None, endpoint=None, **kwargs):
+        record_db_metrics(
+            metrics,
+            SemanticConvention.DB_SYSTEM_QDRANT,
+            scope._server_address,
+            scope._server_port,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+        )
+
+
+def process_qdrant_response(
+    response,
+    db_operation,
+    server_address,
+    server_port,
+    environment,
+    application_name,
+    metrics,
+    start_time,
+    span,
+    capture_message_content,
+    disable_metrics,
+    version,
+    instance=None,
+    args=None,
+    endpoint=None,
+    **kwargs,
+):
     """
     Process Qdrant response and generate telemetry.
     """
@@ -321,8 +448,16 @@ def process_qdrant_response(response, db_operation, server_address, server_port,
     scope._kwargs = kwargs
 
     # Process the response
-    common_qdrant_logic(scope, environment, application_name,
-        metrics, capture_message_content, disable_metrics, version,
-        instance=instance, endpoint=endpoint)
+    common_qdrant_logic(
+        scope,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+        instance=instance,
+        endpoint=endpoint,
+    )
 
     return response

openlit/instrumentation/reka/__init__.py

@@ -5,15 +5,12 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.reka.reka import (
-    chat
-)
-from openlit.instrumentation.reka.async_reka import (
-    async_chat
-)
+from openlit.instrumentation.reka.reka import chat
+from openlit.instrumentation.reka.async_reka import async_chat
 
 _instruments = ("reka-api >= 3.2.0",)
 
+
 class RekaInstrumentor(BaseInstrumentor):
     """
     An instrumentor for Reka client library.
@@ -36,16 +33,32 @@ class RekaInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "reka.chat.client",
             "ChatClient.create",
-            chat(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            chat(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # Chat completions
         wrap_function_wrapper(
             "reka.chat.client",
             "AsyncChatClient.create",
-            async_chat(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            async_chat(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/reka/async_reka.py

@@ -4,17 +4,21 @@ Module for monitoring Reka API calls.
 
 import time
 from opentelemetry.trace import SpanKind
-from openlit.__helpers import (
-    handle_exception,
-    set_server_address_and_port
-)
-from openlit.instrumentation.reka.utils import (
-    process_chat_response
-)
+from openlit.__helpers import handle_exception, set_server_address_and_port
+from openlit.instrumentation.reka.utils import process_chat_response
 from openlit.semcov import SemanticConvention
 
-def async_chat(version, environment, application_name,
-    tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_chat(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -24,7 +28,9 @@ def async_chat(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "api.reka.ai", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "api.reka.ai", 443
+        )
         request_model = kwargs.get("model", "reka-core-20240501")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -48,7 +54,7 @@ def async_chat(version, environment, application_name,
                     capture_message_content=capture_message_content,
                     disable_metrics=disable_metrics,
                     version=version,
-                    **kwargs
+                    **kwargs,
                 )
 
             except Exception as e:

openlit/instrumentation/reka/reka.py

@@ -4,17 +4,21 @@ Module for monitoring Reka API calls.
 
 import time
 from opentelemetry.trace import SpanKind
-from openlit.__helpers import (
-    handle_exception,
-    set_server_address_and_port
-)
-from openlit.instrumentation.reka.utils import (
-    process_chat_response
-)
+from openlit.__helpers import handle_exception, set_server_address_and_port
+from openlit.instrumentation.reka.utils import process_chat_response
 from openlit.semcov import SemanticConvention
 
-def chat(version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def chat(
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for GenAI function call
     """
@@ -24,7 +28,9 @@ def chat(version, environment, application_name,
         Wraps the GenAI function call.
         """
 
-        server_address, server_port = set_server_address_and_port(instance, "api.reka.ai", 443)
+        server_address, server_port = set_server_address_and_port(
+            instance, "api.reka.ai", 443
+        )
         request_model = kwargs.get("model", "reka-core-20240501")
 
         span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
@@ -48,7 +54,7 @@ def chat(version, environment, application_name,
                     capture_message_content=capture_message_content,
                     disable_metrics=disable_metrics,
                     version=version,
-                    **kwargs
+                    **kwargs,
                 )
 
             except Exception as e: