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

openlit/instrumentation/langchain/langchain.py

@@ -4,9 +4,17 @@ Module for monitoring Langchain applications.
 """
 
 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, get_chat_model_cost, general_tokens
+from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from openlit.__helpers import (
+    get_chat_model_cost,
+    handle_exception,
+    general_tokens,
+    calculate_ttft,
+    calculate_tbt,
+    create_metrics_attributes,
+)
 from openlit.semcov import SemanticConvetion
 
 # Initialize logger for logging potential issues and operations
@@ -33,7 +41,7 @@ def get_attribute_from_instance_or_kwargs(instance, attribute_name, default=-1):
         return default
 
 def general_wrap(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
 
@@ -47,7 +55,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
     - 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.
+    - capture_message_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
@@ -83,11 +91,11 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
                                     SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
                 span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
                                     gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
                                     environment)
                 span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
                                     SemanticConvetion.GEN_AI_OPERATION_TYPE_FRAMEWORK)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                span.set_attribute(SERVICE_NAME,
                                     application_name)
                 span.set_attribute(SemanticConvetion.GEN_AI_RETRIEVAL_SOURCE,
                                     response[0].metadata["source"])
@@ -106,7 +114,7 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name,
     return wrapper
 
 def hub(gen_ai_endpoint, version, environment, application_name, tracer,
-        pricing_info, trace_content, metrics, disable_metrics):
+        pricing_info, capture_message_content, metrics, disable_metrics):
     """
     Creates a wrapper around Langchain hub operations for tracing and logging.
 
@@ -121,7 +129,7 @@ def hub(gen_ai_endpoint, version, environment, application_name, tracer,
     - application_name (str): Name of the Langchain application.
     - tracer (opentelemetry.trace.Tracer): The tracer for OpenTelemetry tracing.
     - pricing_info (dict): Pricing information for the operation (not currently used).
-    - trace_content (bool): Indicates if the content of the response should be traced.
+    - capture_message_content (bool): Indicates if the content of the response should be traced.
 
     Returns:
     - function: A new function that wraps the original hub operation call with added
@@ -157,11 +165,11 @@ def hub(gen_ai_endpoint, version, environment, application_name, tracer,
                                     SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
                 span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
                                     gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
                                     environment)
                 span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
                                     SemanticConvetion.GEN_AI_OPERATION_TYPE_FRAMEWORK)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                span.set_attribute(SERVICE_NAME,
                                     application_name)
                 span.set_attribute(SemanticConvetion.GEN_AI_HUB_OWNER,
                                     response.metadata["lc_hub_owner"])
@@ -180,149 +188,8 @@ def hub(gen_ai_endpoint, version, environment, application_name, tracer,
 
     return wrapper
 
-
-def allm(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
-    """
-    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.
-    """
-
-    async 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 = await wrapped(*args, **kwargs)
-
-            try:
-                if args:
-                    prompt = str(args[0]) if args[0] is not None else ""
-                else:
-                    prompt = ""
-                input_tokens = general_tokens(prompt)
-                output_tokens = general_tokens(response)
-
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(
-                    str(get_attribute_from_instance_or_kwargs(instance, 'model')),
-                    pricing_info, input_tokens, output_tokens
-                )
-
-                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
-                                    SemanticConvetion.GEN_AI_OPERATION_TYPE_FRAMEWORK)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
-                                    application_name)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'model')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'temperature')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'top_k')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'top_p')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
-                                    False)
-                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_USAGE_TOTAL_TOKENS,
-                                    input_tokens + output_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                                    cost)
-                if trace_content:
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
-                        },
-                    )
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response,
-                        },
-                    )
-
-                span.set_status(Status(StatusCode.OK))
-
-                if disable_metrics is False:
-                    attributes = {
-                        TELEMETRY_SDK_NAME:
-                            "openlit",
-                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                            application_name,
-                        SemanticConvetion.GEN_AI_SYSTEM:
-                            SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN,
-                        SemanticConvetion.GEN_AI_ENVIRONMENT:
-                            environment,
-                        SemanticConvetion.GEN_AI_OPERATION:
-                            SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                            str(get_attribute_from_instance_or_kwargs(instance, 'model'))
-                    }
-
-                    metrics["genai_requests"].add(1, attributes)
-                    metrics["genai_total_tokens"].add(
-                        input_tokens + output_tokens, attributes
-                    )
-                    metrics["genai_completion_tokens"].add(output_tokens, attributes)
-                    metrics["genai_prompt_tokens"].add(input_tokens, attributes)
-                    metrics["genai_cost"].record(cost, 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
-
-def llm(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
+def chat(gen_ai_endpoint, version, environment, application_name,
+                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
 
@@ -330,13 +197,12 @@ def llm(gen_ai_endpoint, version, environment, application_name,
     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.
+    - capture_message_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
@@ -363,366 +229,111 @@ def llm(gen_ai_endpoint, version, environment, application_name,
         on the span based on the function's execution and response, and ensures
         errors are handled and logged appropriately.
         """
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
-            response = wrapped(*args, **kwargs)
-
-            try:
-                if args:
-                    prompt = str(args[0]) if args[0] is not None else ""
-                else:
-                    prompt = ""
-                input_tokens = general_tokens(prompt)
-                output_tokens = general_tokens(response)
-
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(
-                    str(get_attribute_from_instance_or_kwargs(instance, 'model')),
-                    pricing_info, input_tokens, output_tokens
-                )
-
-                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
-                                    SemanticConvetion.GEN_AI_OPERATION_TYPE_FRAMEWORK)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
-                                    application_name)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'model')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'temperature')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'top_k')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
-                                str(get_attribute_from_instance_or_kwargs(instance, 'top_p')))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
-                                    False)
-                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_USAGE_TOTAL_TOKENS,
-                                    input_tokens + output_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                                    cost)
-                if trace_content:
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
-                        },
-                    )
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response,
-                        },
-                    )
-
-                span.set_status(Status(StatusCode.OK))
-
-                if disable_metrics is False:
-                    attributes = {
-                        TELEMETRY_SDK_NAME:
-                            "openlit",
-                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                            application_name,
-                        SemanticConvetion.GEN_AI_SYSTEM:
-                            SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN,
-                        SemanticConvetion.GEN_AI_ENVIRONMENT:
-                            environment,
-                        SemanticConvetion.GEN_AI_OPERATION:
-                            SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                            str(get_attribute_from_instance_or_kwargs(instance, 'model'))
-                    }
-
-                    metrics["genai_requests"].add(1, attributes)
-                    metrics["genai_total_tokens"].add(
-                        input_tokens + output_tokens, attributes
-                    )
-                    metrics["genai_completion_tokens"].add(output_tokens, attributes)
-                    metrics["genai_prompt_tokens"].add(input_tokens, attributes)
-                    metrics["genai_cost"].record(cost, 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
-
-def chat(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
-    """
-    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.
-    """
+        server_address, server_port = "NOT_FOUND", "NOT_FOUND"
 
-    def wrapper(wrapped, instance, args, kwargs):
-        """
-        An inner wrapper function that executes the wrapped function, measures execution
-        time, and records trace data using OpenTelemetry.
+        if hasattr(instance, "model_id"):
+            request_model = instance.model_id
+        elif hasattr(instance, "model"):
+            request_model = instance.model
+        elif hasattr(instance, "model_name"):
+            request_model = instance.model_name
+        else:
+            request_model = "NOT_FOUND"
 
-        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.
+        span_name = f"{SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"
 
-        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:
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            start_time = time.time()
             response = wrapped(*args, **kwargs)
+            end_time = time.time()
 
             try:
-                prompt = ""
-                if hasattr(response, 'usage_metadata') and response.usage_metadata:
-                    token_usage = response.usage_metadata
-                    input_tokens = token_usage.get("input_tokens", 0)
-                    output_tokens = token_usage.get("output_tokens", 0)
-                    if hasattr(instance, "model_id"):
-                        model = instance.model_id
+                # Format 'messages' into a single string
+                message_prompt = kwargs.get("messages", "") or args[0]
+                formatted_messages = []
+
+                for message in message_prompt:
+                    # Handle the case where message is a tuple
+                    if isinstance(message, tuple) and len(message) == 2:
+                        role, content = message
+                    # Handle the case where message is a dictionary
+                    elif isinstance(message, dict):
+                        role = message["role"]
+                        content = message["content"]
                     else:
-                        model = instance.model_name
-                    prompt = "" if isinstance(args[0], list) else args[0]
-                else:
-                    if not isinstance(response, dict) or "output_text" not in response:
-                        return response
-                    # Fallback: Calculate tokens manually if response_metadata is missing
-                    model = "gpt-4o-mini"  # Fallback model
-                    input_texts = [
-                    doc.page_content for doc in response.get("input_documents", [])
-                    if isinstance(doc.page_content, str)
-                    ]
-                    input_tokens = sum(general_tokens(text) for text in input_texts)
-                    output_text = response.get("output_text", "")
-                    output_tokens = general_tokens(output_text)
+                        continue
+
+                    # Check if the content is a list
+                    if isinstance(content, list):
+                        content_str = ", ".join(
+                            f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'
+                            if "type" in item else f'text: {item["text"]}'
+                            for item in content
+                        )
+                        formatted_messages.append(f"{role}: {content_str}")
+                    else:
+                        formatted_messages.append(f"{role}: {content}")
+
+                # Join all formatted messages with newline
+                prompt = "\n".join(formatted_messages)
+
+                input_tokens = general_tokens(str(prompt))
+                output_tokens = general_tokens(str(response))
 
                 # Calculate cost of the operation
                 cost = get_chat_model_cost(
-                    model,
+                    request_model,
                     pricing_info, input_tokens, output_tokens
                 )
 
+                try:
+                    llm_response = response.content
+                except AttributeError:
+                    llm_response = response
+
+                # Set base span attribues (OTel Semconv)
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
-                                    environment)
                 span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
                                     SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
-                                    application_name)
+                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
+                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
-                                    model)
+                                    request_model)
+                span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL,
+                                    request_model)
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
                                     str(getattr(instance, 'temperature', 1)))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
                                     str(getattr(instance, 'top_k', 1)))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
                                     str(getattr(instance, 'top_p', 1)))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
-                                    False)
                 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_USAGE_TOTAL_TOKENS,
-                                    input_tokens + output_tokens)
-                span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
-                                    cost)
-                if trace_content:
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
-                        },
-                    )
-                    completion_content = getattr(response, 'content', "")
-                    span.add_event(
-                        name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
-                        attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: completion_content,
-                        },
-                    )
-
-                span.set_status(Status(StatusCode.OK))
-
-                if disable_metrics is False:
-                    attributes = {
-                        TELEMETRY_SDK_NAME:
-                            "openlit",
-                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                            application_name,
-                        SemanticConvetion.GEN_AI_SYSTEM:
-                            SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN,
-                        SemanticConvetion.GEN_AI_ENVIRONMENT:
-                            environment,
-                        SemanticConvetion.GEN_AI_OPERATION:
-                            SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                            model
-                    }
-
-                    metrics["genai_requests"].add(1, attributes)
-                    metrics["genai_total_tokens"].add(
-                        input_tokens + output_tokens, attributes
-                    )
-                    metrics["genai_completion_tokens"].add(output_tokens, attributes)
-                    metrics["genai_prompt_tokens"].add(input_tokens, attributes)
-                    metrics["genai_cost"].record(cost, 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
-
-def achat(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, trace_content, metrics, disable_metrics):
-    """
-    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.
-    """
-
-    async 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 = await wrapped(*args, **kwargs)
-
-            try:
-                prompt = ""
-                if hasattr(response, 'usage_metadata') and response.usage_metadata:
-                    token_usage = response.usage_metadata
-                    input_tokens = token_usage.get("input_tokens", 0)
-                    output_tokens = token_usage.get("output_tokens", 0)
-                    if hasattr(instance, "model_id"):
-                        model = instance.model_id
-                    else:
-                        model = instance.model_name
-                    prompt = "" if isinstance(args[0], list) else args[0]
-                else:
-                    if not isinstance(response, dict) or "output_text" not in response:
-                        return response
-                    # Fallback: Calculate tokens manually if response_metadata is missing
-                    model = "gpt-4o-mini"  # Fallback model
-                    input_texts = [
-                    doc.page_content for doc in response.get("input_documents", [])
-                    if isinstance(doc.page_content, str)
-                    ]
-                    input_tokens = sum(general_tokens(text) for text in input_texts)
-                    output_text = response.get("output_text", "")
-                    output_tokens = general_tokens(output_text)
-
-                # Calculate cost of the operation
-                cost = get_chat_model_cost(
-                    model,
-                    pricing_info, input_tokens, output_tokens
-                )
-
-                span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                                    SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SemanticConvetion.GEN_AI_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
-                                    SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT)
-                span.set_attribute(SemanticConvetion.GEN_AI_APPLICATION_NAME,
+                span.set_attribute(SemanticConvetion.SERVER_ADDRESS,
+                                    server_address)
+                span.set_attribute(SemanticConvetion.SERVER_PORT,
+                                    server_port)
+
+                # Set base span attribues (Extras)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
+                                     environment)
+                span.set_attribute(SERVICE_NAME,
                                     application_name)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
-                                    model)
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE,
-                                    str(getattr(instance, 'temperature',1)))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_K,
-                                    str(getattr(instance, 'top_k',1)))
-                span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P,
-                                    str(getattr(instance, 'top_p',1)))
                 span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM,
                                     False)
-                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_USAGE_TOTAL_TOKENS,
                                     input_tokens + output_tokens)
                 span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
                                     cost)
-                if trace_content:
+                span.set_attribute(SemanticConvetion.GEN_AI_SERVER_TTFT,
+                                    end_time - start_time)
+                span.set_attribute(SemanticConvetion.GEN_AI_SDK_VERSION,
+                                    version)
+
+                if capture_message_content:
                     span.add_event(
                         name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
                         attributes={
@@ -732,32 +343,34 @@ def achat(gen_ai_endpoint, version, environment, application_name,
                     span.add_event(
                         name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
                         attributes={
-                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: response.content,
+                            SemanticConvetion.GEN_AI_CONTENT_COMPLETION: llm_response,
                         },
                     )
 
                 span.set_status(Status(StatusCode.OK))
 
                 if disable_metrics is False:
-                    attributes = {
-                        TELEMETRY_SDK_NAME:
-                            "openlit",
-                        SemanticConvetion.GEN_AI_APPLICATION_NAME:
-                            application_name,
-                        SemanticConvetion.GEN_AI_SYSTEM:
-                            SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN,
-                        SemanticConvetion.GEN_AI_ENVIRONMENT:
-                            environment,
-                        SemanticConvetion.GEN_AI_OPERATION:
-                            SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-                        SemanticConvetion.GEN_AI_REQUEST_MODEL:
-                            model
-                    }
+                    attributes = create_metrics_attributes(
+                        service_name=application_name,
+                        deployment_environment=environment,
+                        operation=SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
+                        system=SemanticConvetion.GEN_AI_SYSTEM_LANGCHAIN,
+                        request_model=request_model,
+                        server_address=server_address,
+                        server_port=server_port,
+                        response_model=request_model,
+                    )
 
-                    metrics["genai_requests"].add(1, attributes)
-                    metrics["genai_total_tokens"].add(
+                    metrics["genai_client_usage_tokens"].record(
                         input_tokens + output_tokens, attributes
                     )
+                    metrics["genai_client_operation_duration"].record(
+                        end_time - start_time, attributes
+                    )
+                    metrics["genai_server_ttft"].record(
+                        end_time - start_time, attributes
+                    )
+                    metrics["genai_requests"].add(1, attributes)
                     metrics["genai_completion_tokens"].add(output_tokens, attributes)
                     metrics["genai_prompt_tokens"].add(input_tokens, attributes)
                     metrics["genai_cost"].record(cost, attributes)