openlit 1.33.9__py3-none-any.whl → 1.33.11__py3-none-any.whl

openlit/__helpers.py

@@ -11,6 +11,7 @@ import requests
 import tiktoken
 from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
 from opentelemetry.trace import Status, StatusCode
+from opentelemetry._events import Event
 from openlit.semcov import SemanticConvetion
 
 # Set up logging
@@ -266,6 +267,11 @@ def set_server_address_and_port(client_instance: Any,
         config = getattr(client_instance, "_config", None)
         base_url = getattr(config, "endpoint", None)
 
+    if not base_url:
+        # Attempt to get server_url from instance.sdk_configuration.server_url
+        config = getattr(client_instance, "sdk_configuration", None)
+        base_url = getattr(config, "server_url", None)
+
     if base_url:
         if isinstance(base_url, str):
             url = urlparse(base_url)
@@ -280,3 +286,75 @@ def set_server_address_and_port(client_instance: Any,
         server_port = default_server_port
 
     return server_address, server_port
+
+def otel_event(name, attributes, body):
+    """
+    Returns an OpenTelemetry Event object
+    """
+
+    return Event(
+        name=name,
+        attributes=attributes,
+        body=body,
+    )
+
+def extract_and_format_input(messages):
+    """
+    Process a list of messages to extract content and categorize
+    them into fixed roles like 'user', 'assistant', 'system'.
+    """
+
+    fixed_roles = ['user', 'assistant', 'system', 'tool']  # Ensure these are your fixed keys
+    # Initialize the dictionary with fixed keys and empty structures
+    formatted_messages = {role_key: {"role": "", "content": ""} for role_key in fixed_roles}
+
+    for message in messages:
+        # Normalize the message structure
+        message = response_as_dict(message)
+
+        # Extract role and content
+        role = message.get("role")
+        if role not in fixed_roles:
+            continue  # Skip any role not in our predefined roles
+
+        content = message.get("content", "")
+
+        # Prepare content as a string
+        if isinstance(content, list):
+            content_str = ", ".join(
+                # pylint: disable=line-too-long
+                f'{item.get("type", "text")}: {item.get("text", item.get("image_url", "").get("url", "") if isinstance(item.get("image_url", ""), dict) else item.get("image_url", ""))}'
+                for item in content
+            )
+        else:
+            content_str = content
+
+        # Set the role in the formatted message and concatenate content
+        if not formatted_messages[role]["role"]:
+            formatted_messages[role]["role"] = role
+
+        if formatted_messages[role]["content"]:
+            formatted_messages[role]["content"] += " " + content_str
+        else:
+            formatted_messages[role]["content"] = content_str
+
+    return formatted_messages
+
+# To be removed one the change to log events (from span events) is complete
+def concatenate_all_contents(formatted_messages):
+    """
+    Concatenate all 'content' fields from the formatted messages
+    dictionary into a single string.
+
+    Parameters:
+    - formatted_messages: Dictionary with roles as keys and corresponding
+      role and content as values.
+
+    Returns:
+    - A single string with all content concatenated.
+    """
+    return " ".join(
+        message_data['content']
+        for message_data in formatted_messages.values()
+        if message_data['content']
+    )

openlit/__init__.py

@@ -17,12 +17,13 @@ import requests
 # Import internal modules for setting up tracing and fetching pricing info.
 from opentelemetry import trace as t
 from opentelemetry.trace import SpanKind, Status, StatusCode, Span
+from opentelemetry.sdk.resources import SERVICE_NAME, DEPLOYMENT_ENVIRONMENT
 from openlit.semcov import SemanticConvetion
 from openlit.otel.tracing import setup_tracing
 from openlit.otel.metrics import setup_meter
+from openlit.otel.events import setup_events
 from openlit.__helpers import fetch_pricing_info, get_env_variable
 
-
 # Instrumentors for various large language models.
 from openlit.instrumentation.openai import OpenAIInstrumentor
 from openlit.instrumentation.anthropic import AnthropicInstrumentor
@@ -84,10 +85,11 @@ class OpenlitConfig:
         application_name (str): Name of the application using openLIT.
         pricing_info (Dict[str, Any]): Pricing information.
         tracer (Optional[Any]): Tracer instance for OpenTelemetry.
+        event_provider (Optional[Any]): Event logger provider for OpenTelemetry.
         otlp_endpoint (Optional[str]): Endpoint for OTLP.
         otlp_headers (Optional[Dict[str, str]]): Headers for OTLP.
         disable_batch (bool): Flag to disable batch span processing in tracing.
-        trace_content (bool): Flag to enable or disable tracing of content.
+        capture_message_content (bool): Flag to enable or disable tracing of content.
     """
 
     _instance = None
@@ -106,11 +108,12 @@ class OpenlitConfig:
         cls.application_name = "default"
         cls.pricing_info = {}
         cls.tracer = None
+        cls.event_provider = None
         cls.metrics_dict = {}
         cls.otlp_endpoint = None
         cls.otlp_headers = None
         cls.disable_batch = False
-        cls.trace_content = True
+        cls.capture_message_content = True
         cls.disable_metrics = False
 
     @classmethod
@@ -119,10 +122,11 @@ class OpenlitConfig:
         environment,
         application_name,
         tracer,
+        event_provider,
         otlp_endpoint,
         otlp_headers,
         disable_batch,
-        trace_content,
+        capture_message_content,
         metrics_dict,
         disable_metrics,
         pricing_json,
@@ -134,22 +138,26 @@ class OpenlitConfig:
             environment (str): Deployment environment.
             application_name (str): Application name.
             tracer: Tracer instance.
+            event_provider: Event logger provider instance.
             meter: Metric Instance
             otlp_endpoint (str): OTLP endpoint.
             otlp_headers (Dict[str, str]): OTLP headers.
             disable_batch (bool): Disable batch span processing flag.
-            trace_content (bool): Enable or disable content tracing.
+            capture_message_content (bool): Enable or disable content tracing.
+            metrics_dict: Dictionary of metrics.
+            disable_metrics (bool): Flag to disable metrics.
             pricing_json(str): path or url to the pricing json file
         """
         cls.environment = environment
         cls.application_name = application_name
         cls.pricing_info = fetch_pricing_info(pricing_json)
         cls.tracer = tracer
+        cls.event_provider = event_provider
         cls.metrics_dict = metrics_dict
         cls.otlp_endpoint = otlp_endpoint
         cls.otlp_headers = otlp_headers
         cls.disable_batch = disable_batch
-        cls.trace_content = trace_content
+        cls.capture_message_content = capture_message_content
         cls.disable_metrics = disable_metrics
 
 
@@ -186,8 +194,9 @@ def instrument_if_available(
                 environment=config.environment,
                 application_name=config.application_name,
                 tracer=config.tracer,
+                event_provider=config.event_provider,
                 pricing_info=config.pricing_info,
-                trace_content=config.trace_content,
+                capture_message_content=config.capture_message_content,
                 metrics_dict=config.metrics_dict,
                 disable_metrics=config.disable_metrics,
             )
@@ -206,10 +215,11 @@ def init(
     environment="default",
     application_name="default",
     tracer=None,
+    event_logger=None,
     otlp_endpoint=None,
     otlp_headers=None,
     disable_batch=False,
-    trace_content=True,
+    capture_message_content=True,
     disabled_instrumentors=None,
     meter=None,
     disable_metrics=False,
@@ -226,11 +236,12 @@ def init(
         environment (str): Deployment environment.
         application_name (str): Application name.
         tracer: Tracer instance (Optional).
+        event_logger: EventLoggerProvider instance (Optional).
         meter: OpenTelemetry Metrics Instance (Optional).
         otlp_endpoint (str): OTLP endpoint for exporter (Optional).
         otlp_headers (Dict[str, str]): OTLP headers for exporter (Optional).
         disable_batch (bool): Flag to disable batch span processing (Optional).
-        trace_content (bool): Flag to trace content (Optional).
+        capture_message_content (bool): Flag to trace content (Optional).
         disabled_instrumentors (List[str]): Optional. List of instrumentor names to disable.
         disable_metrics (bool): Flag to disable metrics (Optional).
         pricing_json(str): File path or url to the pricing json (Optional).
@@ -307,9 +318,22 @@ def init(
         )
 
         if not tracer:
-            logger.error("openLIT tracing setup failed. Tracing will not be available.")
+            logger.error("OpenLIT tracing setup failed. Tracing will not be available.")
             return
 
+        # Setup events based on the provided or default configuration.
+        event_provider = setup_events(
+                application_name=application_name,
+                environment=environment,
+                event_logger=event_logger,
+                otlp_endpoint=None,
+                otlp_headers=None,
+                disable_batch=disable_batch,
+            )
+
+        if not event_provider:
+            logger.error("OpenLIT events setup failed. Events will not be available")
+
         # Setup meter and receive metrics_dict instead of meter.
         metrics_dict, err = setup_meter(
             application_name=application_name,
@@ -325,15 +349,19 @@ def init(
             )
             return
 
+        if os.getenv("OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT", "").lower == "false":
+            capture_message_content=False
+
         # Update global configuration with the provided settings.
         config.update_config(
             environment,
             application_name,
             tracer,
+            event_provider,
             otlp_endpoint,
             otlp_headers,
             disable_batch,
-            trace_content,
+            capture_message_content,
             metrics_dict,
             disable_metrics,
             pricing_json,
@@ -555,11 +583,11 @@ def trace(wrapped):
                 span.set_attribute("function.args", str(args))
                 span.set_attribute("function.kwargs", str(kwargs))
                 span.set_attribute(
-                    SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                    SERVICE_NAME,
                     OpenlitConfig.application_name,
                 )
                 span.set_attribute(
-                    SemanticConvetion.GEN_AI_ENVIRONMENT, OpenlitConfig.environment
+                    DEPLOYMENT_ENVIRONMENT, OpenlitConfig.environment
                 )
             except Exception as meta_exception:
                 logging.error(

openlit/instrumentation/ag2/__init__.py

@@ -1,4 +1,3 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
 """Initializer of Auto Instrumentation of AG2 Functions"""
 
 from typing import Collection
@@ -7,7 +6,7 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
 from openlit.instrumentation.ag2.ag2 import (
-    wrap_ag2
+    conversable_agent, agent_run
 )
 
 _instruments = ("ag2 >= 0.3.2",)
@@ -24,27 +23,27 @@ class AG2Instrumentor(BaseInstrumentor):
         application_name = kwargs.get("application_name", "default_application")
         environment = kwargs.get("environment", "default_environment")
         tracer = kwargs.get("tracer")
+        event_provider = kwargs.get("event_provider")
         metrics = kwargs.get("metrics_dict")
         pricing_info = kwargs.get("pricing_info", {})
-        trace_content = kwargs.get("trace_content", False)
+        capture_message_content = kwargs.get("capture_message_content", False)
         disable_metrics = kwargs.get("disable_metrics")
         version = importlib.metadata.version("ag2")
 
         wrap_function_wrapper(
             "autogen.agentchat.conversable_agent",
-            "ConversableAgent.initiate_chat",
-            wrap_ag2("ag2.initiate_chat", version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+            "ConversableAgent.__init__",
+            conversable_agent(version, environment, application_name,
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
             "autogen.agentchat.conversable_agent",
-            "ConversableAgent.generate_reply",
-            wrap_ag2("ag2.generate_reply", version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+            "ConversableAgent.run",
+            agent_run(version, environment, application_name,
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
-
     def _uninstrument(self, **kwargs):
         # Proper uninstrumentation logic to revert patched methods
         pass

openlit/instrumentation/ag2/ag2.py

@@ -1,98 +1,163 @@
-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument
 """
-Module for monitoring AG2.
+Module for monitoring AG2 API calls.
 """
 
 import logging
+import time
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
-from openlit.__helpers import handle_exception
+from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from openlit.__helpers import (
+    handle_exception,
+    get_chat_model_cost,
+    otel_event,
+)
 from openlit.semcov import SemanticConvetion
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def wrap_ag2(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+AGENT_NAME = ''
+REQUEST_MODEL = ''
+SYSTEM_MESSAGE = ''
+MODEL_AND_NAME_SET = False
+
+def set_span_attributes(span, version, operation_name, environment,
+        application_name, server_address, server_port, request_model):
+    """
+    Set common attributes for the span.
+    """
+
+    # Set Span attributes (OTel Semconv)
+    span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
+    span.set_attribute(SemanticConvetion.GEN_AI_OPERATION, operation_name)
+    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM, SemanticConvetion.GEN_AI_SYSTEM_AG2)
+    span.set_attribute(SemanticConvetion.GEN_AI_AGENT_NAME, AGENT_NAME)
+    span.set_attribute(SemanticConvetion.SERVER_ADDRESS, server_address)
+    span.set_attribute(SemanticConvetion.SERVER_PORT, server_port)
+    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL, request_model)
+
+    # Set Span attributes (Extras)
+    span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+    span.set_attribute(SERVICE_NAME, application_name)
+    span.set_attribute(SemanticConvetion.GEN_AI_SDK_VERSION, version)
+
+def calculate_tokens_and_cost(response, request_model, pricing_info):
     """
-    Creates a wrapper around a function call to trace and log its execution metrics.
-
-    This function wraps any given function to measure its execution time,
-    log its operation, and trace its execution using OpenTelemetry.
-    
-    Parameters:
-    - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.
-    - version (str): The version of the Langchain application.
-    - environment (str): The deployment environment (e.g., 'production', 'development').
-    - application_name (str): Name of the Langchain application.
-    - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.
-    - pricing_info (dict): Information about the pricing for internal metrics (currently not used).
-    - trace_content (bool): Flag indicating whether to trace the content of the response.
-
-    Returns:
-    - function: A higher-order function that takes a function 'wrapped' and returns
-                a new function that wraps 'wrapped' with additional tracing and logging.
+    Calculate the input, output tokens, and their respective costs.
     """
+    input_tokens = 0
+    output_tokens = 0
 
+    for usage_data in response.cost.values():
+        if isinstance(usage_data, dict):
+            for model_data in usage_data.values():
+                if isinstance(model_data, dict):
+                    input_tokens += model_data.get('prompt_tokens', 0)
+                    output_tokens += model_data.get('completion_tokens', 0)
+
+    cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)
+    return input_tokens, output_tokens, cost
+
+def emit_events(response, event_provider, capture_message_content):
+    """
+    Emit OpenTelemetry events for each chat history entry.
+    """
+    for chat in response.chat_history:
+        event_type = (
+            SemanticConvetion.GEN_AI_CHOICE if chat['role'] == 'user'
+            else SemanticConvetion.GEN_AI_USER_MESSAGE
+        )
+        choice_event = otel_event(
+            name=event_type,
+            attributes={
+                SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AG2
+            },
+            body={
+                "index": response.chat_history.index(chat),
+                "message": {
+                    **({"content": chat['content']} if capture_message_content else {}),
+                    "role": 'assistant' if chat['role'] == 'user' else 'user'
+                }
+            }
+        )
+        event_provider.emit(choice_event)
+
+def conversable_agent(version, environment, application_name,
+                      tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for GenAI function call
+    """
     def wrapper(wrapped, instance, args, kwargs):
-        """
-        An inner wrapper function that executes the wrapped function, measures execution
-        time, and records trace data using OpenTelemetry.
-
-        Parameters:
-        - wrapped (Callable): The original function that this wrapper will execute.
-        - instance (object): The instance to which the wrapped function belongs. This
-                             is used for instance methods. For static and classmethods,
-                             this may be None.
-        - args (tuple): Positional arguments passed to the wrapped function.
-        - kwargs (dict): Keyword arguments passed to the wrapped function.
-
-        Returns:
-        - The result of the wrapped function call.
-        
-        The wrapper initiates a span with the provided tracer, sets various attributes
-        on the span based on the function's execution and response, and ensures
-        errors are handled and logged appropriately.
-        """
-
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
-            response = wrapped(*args, **kwargs)
-
-            if isinstance(instance.__dict__.get('llm_config'), dict):
-                llm_model = instance.__dict__['llm_config'].get('model', 'gpt-4')
-            else:
-                # Fallback to default if 'llm_config' is not a dictionary
-                llm_model = None
+        server_address, server_port = '127.0.0.1', 80
+        global AGENT_NAME, MODEL_AND_NAME_SET, REQUEST_MODEL, SYSTEM_MESSAGE
+
+        if not MODEL_AND_NAME_SET:
+            AGENT_NAME = kwargs.get("name", "NOT_FOUND")
+            REQUEST_MODEL = kwargs.get("llm_config", {}).get('model', 'gpt-4o')
+            SYSTEM_MESSAGE = kwargs.get('system_message', '')
+            MODEL_AND_NAME_SET = True
 
+        span_name = f"{SemanticConvetion.GEN_AI_OPERATION_TYPE_CREATE_AGENT} {AGENT_NAME}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
             try:
-                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
-                                   gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                                   SemanticConvetion.GEN_AI_SYSTEM_AG2)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
-                                   environment)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
-                                   application_name)
-                span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
-                                   SemanticConvetion.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvetion.GEN_AI_AGENT_ROLE,
-                                   instance.name)
-                if llm_model:
-                    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
-                                   llm_model)
+                start_time = time.time()
+                response = wrapped(*args, **kwargs)
+                end_time = time.time()
 
+                set_span_attributes(span, version, SemanticConvetion.GEN_AI_OPERATION_TYPE_CREATE_AGENT,
+                    environment, application_name, server_address, server_port, REQUEST_MODEL)
+                span.set_attribute(SemanticConvetion.GEN_AI_AGENT_DESCRIPTION, SYSTEM_MESSAGE)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL, REQUEST_MODEL)
+                span.set_attribute(SemanticConvetion.GEN_AI_SERVER_TTFT, end_time - start_time)
 
                 span.set_status(Status(StatusCode.OK))
 
-                # Return original response
                 return response
 
             except Exception as e:
                 handle_exception(span, e)
                 logger.error("Error in trace creation: %s", e)
+                return response
+
+    return wrapper
+
+def agent_run(version, environment, application_name,
+              tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for GenAI function call
+    """
+    def wrapper(wrapped, instance, args, kwargs):
+        server_address, server_port = '127.0.0.1', 80
+
+        span_name = f"{SemanticConvetion.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {AGENT_NAME}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            try:
+                start_time = time.time()
+                response = wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                input_tokens, output_tokens, cost = calculate_tokens_and_cost(response, REQUEST_MODEL, pricing_info)
+                response_model = list(response.cost.get('usage_including_cached_inference', {}).keys())[1]
+
+                set_span_attributes(span, version, SemanticConvetion.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK,
+                    environment, application_name, server_address, server_port, REQUEST_MODEL)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL, response_model)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens)
+                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST, cost)
+                span.set_attribute(SemanticConvetion.GEN_AI_SERVER_TTFT, end_time - start_time)
+
+                emit_events(response, event_provider, capture_message_content)
+                span.set_status(Status(StatusCode.OK))
+
+                return response
 
-                # Return original response
+            except Exception as e:
+                handle_exception(span, e)
+                logger.error("Error in trace creation: %s", e)
                 return response
 
     return wrapper

openlit/instrumentation/ai21/__init__.py

@@ -27,9 +27,10 @@ class AI21Instrumentor(BaseInstrumentor):
         application_name = kwargs.get("application_name", "default_application")
         environment = kwargs.get("environment", "default_environment")
         tracer = kwargs.get("tracer")
+        event_provider = kwargs.get("event_provider")
         metrics = kwargs.get("metrics_dict")
         pricing_info = kwargs.get("pricing_info", {})
-        trace_content = kwargs.get("trace_content", False)
+        capture_message_content = kwargs.get("capture_message_content", False)
         disable_metrics = kwargs.get("disable_metrics")
         version = importlib.metadata.version("ai21")
 
@@ -38,13 +39,13 @@ class AI21Instrumentor(BaseInstrumentor):
             "ai21.clients.studio.resources.chat.chat_completions",
             "ChatCompletions.create",
             chat(version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
             "ai21.clients.studio.resources.studio_conversational_rag",
             "StudioConversationalRag.create",
             chat_rag(version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         #Async
@@ -52,13 +53,13 @@ class AI21Instrumentor(BaseInstrumentor):
             "ai21.clients.studio.resources.chat.async_chat_completions",
             "AsyncChatCompletions.create",
             async_chat(version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
         wrap_function_wrapper(
             "ai21.clients.studio.resources.studio_conversational_rag",
             "AsyncStudioConversationalRag.create",
             async_chat_rag(version, environment, application_name,
-                  tracer, pricing_info, trace_content, metrics, disable_metrics),
+                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
     def _uninstrument(self, **kwargs):