openlit 1.33.10__py3-none-any.whl → 1.33.12__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
@@ -20,12 +21,13 @@ def response_as_dict(response):
     """
     Return parsed response as a dict
     """
+
     # pylint: disable=no-else-return
     if isinstance(response, dict):
         return response
-    if hasattr(response, "model_dump"):
+    if hasattr(response, 'model_dump'):
         return response.model_dump()
-    elif hasattr(response, "parse"):
+    elif hasattr(response, 'parse'):
         return response_as_dict(response.parse())
     else:
         return response
@@ -33,8 +35,8 @@ def response_as_dict(response):
 def get_env_variable(name, arg_value, error_message):
     """
     Retrieve an environment variable if the argument is not provided
-    and raise an error if both are not set.
     """
+
     if arg_value is not None:
         return arg_value
     value = os.getenv(name)
@@ -46,14 +48,8 @@ def get_env_variable(name, arg_value, error_message):
 def openai_tokens(text, model):
     """
     Calculate the number of tokens a given text would take up for a specified model.
-    
-    Args:
-        text (str): The input text to be encoded.
-        model (str): The model identifier used for encoding.
-        
-    Returns:
-        int: The number of tokens the text is encoded into.
     """
+
     try:
         encoding = tiktoken.encoding_for_model(model)
     except:
@@ -65,16 +61,9 @@ def openai_tokens(text, model):
 def general_tokens(text):
     """
     Calculate the number of tokens a given text would take up.
-    
-    Args:
-        text (str): The input text to be encoded.
-        model (str): The model identifier used for encoding.
-        
-    Returns:
-        int: The number of tokens the text is encoded into.
     """
 
-    encoding = tiktoken.get_encoding("gpt2")
+    encoding = tiktoken.get_encoding('gpt2')
 
     num_tokens = len(encoding.encode(text))
     return num_tokens
@@ -82,19 +71,11 @@ def general_tokens(text):
 def get_chat_model_cost(model, pricing_info, prompt_tokens, completion_tokens):
     """
     Retrieve the cost of processing for a given model based on prompt and tokens.
-    
-    Args:
-        model (str): The model identifier.
-        pricing_info (dict): A dictionary containing pricing information for various models.
-        prompt_tokens (int): Number of tokens in the prompt.
-        completion_tokens (int): Number of tokens in the completion if applicable.
-        
-    Returns:
-        float: The calculated cost for the operation.
     """
+
     try:
-        cost = ((prompt_tokens / 1000) * pricing_info["chat"][model]["promptPrice"]) + \
-            ((completion_tokens / 1000) * pricing_info["chat"][model]["completionPrice"])
+        cost = ((prompt_tokens / 1000) * pricing_info['chat'][model]['promptPrice']) + \
+            ((completion_tokens / 1000) * pricing_info['chat'][model]['completionPrice'])
     except:
         cost = 0
     return cost
@@ -102,17 +83,10 @@ def get_chat_model_cost(model, pricing_info, prompt_tokens, completion_tokens):
 def get_embed_model_cost(model, pricing_info, prompt_tokens):
     """
     Retrieve the cost of processing for a given model based on prompt tokens.
-    
-    Args:
-        model (str): The model identifier.
-        pricing_info (dict): A dictionary containing pricing information for various models.
-        prompt_tokens (int): Number of tokens in the prompt.
-        
-    Returns:
-        float: The calculated cost for the operation.
     """
+
     try:
-        cost = (prompt_tokens / 1000) * pricing_info["embeddings"][model]
+        cost = (prompt_tokens / 1000) * pricing_info['embeddings'][model]
     except:
         cost = 0
     return cost
@@ -120,18 +94,10 @@ def get_embed_model_cost(model, pricing_info, prompt_tokens):
 def get_image_model_cost(model, pricing_info, size, quality):
     """
     Retrieve the cost of processing for a given model based on image size and quailty.
-    
-    Args:
-        model (str): The model identifier.
-        pricing_info (dict): A dictionary containing pricing information for various models.
-        size (str): Size of the Image.
-        quality (int): Quality of the Image.
-        
-    Returns:
-        float: The calculated cost for the operation.
     """
+
     try:
-        cost = pricing_info["images"][model][quality][size]
+        cost = pricing_info['images'][model][quality][size]
     except:
         cost = 0
     return cost
@@ -139,20 +105,13 @@ def get_image_model_cost(model, pricing_info, size, quality):
 def get_audio_model_cost(model, pricing_info, prompt, duration=None):
     """
     Retrieve the cost of processing for a given model based on prompt.
-    
-    Args:
-        model (str): The model identifier.
-        pricing_info (dict): A dictionary containing pricing information for various models.
-        prompt (str): Prompt to the LLM Model
-        
-    Returns:
-        float: The calculated cost for the operation.
     """
+
     try:
         if prompt:
-            cost = (len(prompt) / 1000) * pricing_info["audio"][model]
+            cost = (len(prompt) / 1000) * pricing_info['audio'][model]
         else:
-            cost = duration * pricing_info["audio"][model]
+            cost = duration * pricing_info['audio'][model]
     except:
         cost = 0
     return cost
@@ -160,15 +119,10 @@ def get_audio_model_cost(model, pricing_info, prompt, duration=None):
 def fetch_pricing_info(pricing_json=None):
     """
     Fetches pricing information from a specified URL or File Path.
-
-    Args:
-        pricing_json(str): path or url to the pricing json file
-
-    Returns:
-        dict: The pricing json
     """
+
     if pricing_json:
-        is_url = urlparse(pricing_json).scheme != ""
+        is_url = urlparse(pricing_json).scheme != ''
         if is_url:
             pricing_url = pricing_json
         else:
@@ -176,39 +130,36 @@ def fetch_pricing_info(pricing_json=None):
                 with open(pricing_json, mode='r', encoding='utf-8') as f:
                     return json.load(f)
             except FileNotFoundError:
-                logger.error("Pricing information file not found: %s", pricing_json)
+                logger.error('Pricing information file not found: %s', pricing_json)
             except json.JSONDecodeError:
-                logger.error("Error decoding JSON from file: %s", pricing_json)
+                logger.error('Error decoding JSON from file: %s', pricing_json)
             except Exception as file_err:
-                logger.error("Unexpected error occurred while reading file: %s", file_err)
+                logger.error('Unexpected error occurred while reading file: %s', file_err)
             return {}
     else:
-        pricing_url = "https://raw.githubusercontent.com/openlit/openlit/main/assets/pricing.json"
+        pricing_url = 'https://raw.githubusercontent.com/openlit/openlit/main/assets/pricing.json'
     try:
         # Set a timeout of 10 seconds for both the connection and the read
         response = requests.get(pricing_url, timeout=20)
         response.raise_for_status()
         return response.json()
     except requests.HTTPError as http_err:
-        logger.error("HTTP error occured while fetching pricing info: %s", http_err)
+        logger.error('HTTP error occured while fetching pricing info: %s', http_err)
     except Exception as err:
-        logger.error("Unexpected error occurred while fetching pricing info: %s", err)
+        logger.error('Unexpected error occurred while fetching pricing info: %s', err)
     return {}
 
 def handle_exception(span,e):
     """Handles Exception when LLM Function fails or trace creation fails."""
-    # Record the exception details within the span
+
     span.record_exception(e)
     span.set_status(Status(StatusCode.ERROR))
 
 def calculate_ttft(timestamps: List[float], start_time: float) -> float:
     """
     Calculate the time to the first tokens.
-    
-    :param timestamps: List of timestamps for received tokens
-    :param start_time: The start time of the streaming process
-    :return: Time to the first tokens
     """
+
     if timestamps:
         return timestamps[0] - start_time
     return 0.0
@@ -216,10 +167,8 @@ def calculate_ttft(timestamps: List[float], start_time: float) -> float:
 def calculate_tbt(timestamps: List[float]) -> float:
     """
     Calculate the average time between tokens.
-    
-    :param timestamps: List of timestamps for received tokens
-    :return: Average time between tokens
     """
+
     if len(timestamps) > 1:
         time_diffs = [timestamps[i] - timestamps[i - 1] for i in range(1, len(timestamps))]
         return sum(time_diffs) / len(time_diffs)
@@ -238,8 +187,9 @@ def create_metrics_attributes(
     """
     Returns OTel metrics attributes
     """
+
     return {
-        TELEMETRY_SDK_NAME: "openlit",
+        TELEMETRY_SDK_NAME: 'openlit',
         SERVICE_NAME: service_name,
         DEPLOYMENT_ENVIRONMENT: deployment_environment,
         SemanticConvetion.GEN_AI_OPERATION: operation,
@@ -258,18 +208,18 @@ def set_server_address_and_port(client_instance: Any,
     """
 
     # Try getting base_url from multiple potential attributes
-    base_client = getattr(client_instance, "_client", None)
-    base_url = getattr(base_client, "base_url", None)
+    base_client = getattr(client_instance, '_client', None)
+    base_url = getattr(base_client, 'base_url', None)
 
     if not base_url:
         # Attempt to get endpoint from instance._config.endpoint if base_url is not set
-        config = getattr(client_instance, "_config", None)
-        base_url = getattr(config, "endpoint", None)
+        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)
+        config = getattr(client_instance, 'sdk_configuration', None)
+        base_url = getattr(config, 'server_url', None)
 
     if base_url:
         if isinstance(base_url, str):
@@ -277,11 +227,98 @@ def set_server_address_and_port(client_instance: Any,
             server_address = url.hostname or default_server_address
             server_port = url.port if url.port is not None else default_server_port
         else:  # base_url might not be a str; handle as an object.
-            server_address = getattr(base_url, "host", None) or default_server_address
-            port_attr = getattr(base_url, "port", None)
+            server_address = getattr(base_url, 'host', None) or default_server_address
+            port_attr = getattr(base_url, 'port', None)
             server_port = port_attr if port_attr is not None else default_server_port
     else:  # no base_url or endpoint provided; use defaults.
         server_address = default_server_address
         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', 'tool'.
+    """
+
+    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(
+                f'{item.get("type", "text")}: {extract_text_from_item(item)}'
+                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
+
+def extract_text_from_item(item):
+    """
+    Extract text from inpit message
+    """
+
+    #pylint: disable=no-else-return
+    if item.get('type') == 'text':
+        return item.get('text', '')
+    elif item.get('type') == 'image':
+        # Handle image content specifically checking for 'url' or 'base64'
+        source = item.get('source', {})
+        if isinstance(source, dict):
+            if source.get('type') == 'base64':
+                # Return the actual base64 data if present
+                return source.get('data', '[Missing base64 data]')
+            elif source.get('type') == 'url':
+                return source.get('url', '[Missing URL]')
+    elif item.get('type') == 'image_url':
+        # New format: Handle the 'image_url' type
+        image_url = item.get('image_url', {})
+        if isinstance(image_url, dict):
+            return image_url.get('url', '[Missing image URL]')
+    return ''
+
+# To be removed one the change to log events (from span events) is complete
+def concatenate_all_contents(formatted_messages):
+    """
+    Concatenate all 'content' fields into a single strin
+    """
+    return ' '.join(
+        message_data['content']
+        for message_data in formatted_messages.values()
+        if message_data['content']
+    )

openlit/__init__.py

@@ -21,9 +21,9 @@ 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
@@ -85,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
@@ -107,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
@@ -120,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,
@@ -135,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
 
 
@@ -187,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,
             )
@@ -207,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,
@@ -227,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).
@@ -308,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,
@@ -326,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,

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,10 +6,10 @@ 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",)
+_instruments = ('ag2 >= 0.3.2',)
 
 class AG2Instrumentor(BaseInstrumentor):
     """
@@ -21,30 +20,30 @@ class AG2Instrumentor(BaseInstrumentor):
         return _instruments
 
     def _instrument(self, **kwargs):
-        application_name = kwargs.get("application_name", "default_application")
-        environment = kwargs.get("environment", "default_environment")
-        tracer = kwargs.get("tracer")
-        metrics = kwargs.get("metrics_dict")
-        pricing_info = kwargs.get("pricing_info", {})
-        trace_content = kwargs.get("trace_content", False)
-        disable_metrics = kwargs.get("disable_metrics")
-        version = importlib.metadata.version("ag2")
+        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', {})
+        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),
+            'autogen.agentchat.conversable_agent',
+            '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),
+            'autogen.agentchat.conversable_agent',
+            '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