openlit 1.33.19__tar.gz → 1.33.21__tar.gz

{openlit-1.33.19 → openlit-1.33.21}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: openlit
-Version: 1.33.19
+Version: 1.33.21
 Summary: OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects
 License: Apache-2.0
 Keywords: OpenTelemetry,otel,otlp,llm,tracing,openai,anthropic,claude,cohere,llm monitoring,observability,monitoring,gpt,Generative AI,chatGPT,gpu
 Author: OpenLIT
-Requires-Python: >=3.7.1,<4.0.0
+Requires-Python: >=3.8.0,<4.0.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -14,18 +14,18 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: anthropic (>=0.42.0,<0.43.0)
+Requires-Dist: anthropic (>=0.42.0,<1.0.0)
 Requires-Dist: boto3 (>=1.34.0,<2.0.0)
 Requires-Dist: botocore (>=1.34.0,<2.0.0)
 Requires-Dist: openai (>=1.1.1,<2.0.0)
-Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0)
-Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.48b0,<0.49)
-Requires-Dist: opentelemetry-sdk (>=1.27.0,<2.0.0)
+Requires-Dist: opentelemetry-api (>=1.30.0,<2.0.0)
+Requires-Dist: opentelemetry-exporter-otlp (>=1.30.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.52b0,<1.0.0)
+Requires-Dist: opentelemetry-sdk (>=1.30.0,<2.0.0)
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: requests (>=2.26.0,<3.0.0)
 Requires-Dist: schedule (>=1.2.2,<2.0.0)
-Requires-Dist: xmltodict (>=0.13.0,<0.14.0)
+Requires-Dist: xmltodict (>=0.13.0,<1.0.0)
 Project-URL: Homepage, https://github.com/openlit/openlit/tree/main/openlit/python
 Project-URL: Repository, https://github.com/openlit/openlit/tree/main/openlit/python
 Description-Content-Type: text/markdown

{openlit-1.33.19 → openlit-1.33.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openlit"
-version = "1.33.19"
+version = "1.33.21"
 description = "OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects"
 authors = ["OpenLIT"]
 license = "Apache-2.0"
@@ -10,19 +10,19 @@ homepage = "https://github.com/openlit/openlit/tree/main/openlit/python"
 keywords = ["OpenTelemetry", "otel", "otlp","llm", "tracing", "openai", "anthropic", "claude", "cohere", "llm monitoring", "observability", "monitoring", "gpt", "Generative AI", "chatGPT", "gpu"]
 
 [tool.poetry.dependencies]
-python = "^3.7.1"
+python = "^3.8.0"
 requests = "^2.26.0"
 schedule = "^1.2.2"
 pydantic = "^2.0.0"
-xmltodict = "^0.13.0"
+xmltodict = ">=0.13.0,<1.0.0"
 boto3 = "^1.34.0"
 botocore = "^1.34.0"
-opentelemetry-api = "^1.27.0"
-opentelemetry-sdk = "^1.27.0"
-opentelemetry-exporter-otlp = "^1.27.0"
-opentelemetry-instrumentation = "^0.48b0"
+opentelemetry-api = "^1.30.0"
+opentelemetry-sdk = "^1.30.0"
+opentelemetry-exporter-otlp = "^1.30.0"
+opentelemetry-instrumentation = ">=0.52b0,<1.0.0"
 openai = "^1.1.1"
-anthropic = "^0.42.0"
+anthropic = ">=0.42.0,<1.0.0"
 
 [build-system]
 requires = ["poetry-core>=1.1.0"]

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/__helpers.py

@@ -12,7 +12,7 @@ import requests
 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
+from openlit.semcov import SemanticConvention
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -176,12 +176,12 @@ def create_metrics_attributes(
         TELEMETRY_SDK_NAME: 'openlit',
         SERVICE_NAME: service_name,
         DEPLOYMENT_ENVIRONMENT: deployment_environment,
-        SemanticConvetion.GEN_AI_OPERATION: operation,
-        SemanticConvetion.GEN_AI_SYSTEM: system,
-        SemanticConvetion.GEN_AI_REQUEST_MODEL: request_model,
-        SemanticConvetion.SERVER_ADDRESS: server_address,
-        SemanticConvetion.SERVER_PORT: server_port,
-        SemanticConvetion.GEN_AI_RESPONSE_MODEL: response_model
+        SemanticConvention.GEN_AI_OPERATION: operation,
+        SemanticConvention.GEN_AI_SYSTEM: system,
+        SemanticConvention.GEN_AI_REQUEST_MODEL: request_model,
+        SemanticConvention.SERVER_ADDRESS: server_address,
+        SemanticConvention.SERVER_PORT: server_port,
+        SemanticConvention.GEN_AI_RESPONSE_MODEL: response_model
     }
 
 def set_server_address_and_port(client_instance: Any,
@@ -240,6 +240,11 @@ def extract_and_format_input(messages):
     fixed_roles = ['user', 'assistant', 'system', 'tool', 'developer']
     formatted_messages = {role_key: {'role': '', 'content': ''} for role_key in fixed_roles}
 
+    # Check if input is a simple string
+    if isinstance(messages, str):
+        formatted_messages['user'] = {'role': 'user', 'content': messages}
+        return formatted_messages
+
     for message in messages:
         message = response_as_dict(message)
 
@@ -276,3 +281,55 @@ def concatenate_all_contents(formatted_messages):
         for message_data in formatted_messages.values()
         if message_data['content']
     )
+
+def format_and_concatenate(messages):
+    """
+    Process a list of messages to extract content, categorize them by role,
+    and concatenate all 'content' fields into a single string with role: content format.
+    """
+
+    formatted_messages = {}
+
+    # Check if input is a simple string
+    if isinstance(messages, str):
+        formatted_messages['user'] = {'role': 'user', 'content': messages}
+    elif isinstance(messages, list) and all(isinstance(m, str) for m in messages):
+        # If it's a list of strings, each string is 'user' input
+        user_content = ' '.join(messages)
+        formatted_messages['user'] = {'role': 'user', 'content': user_content}
+    else:
+        for message in messages:
+            message = response_as_dict(message)
+            role = message.get('role', 'unknown')  # Default to 'unknown' if no role is specified
+            content = message.get('content', '')
+
+            # Initialize role in formatted messages if not present
+            if role not in formatted_messages:
+                formatted_messages[role] = {'role': role, 'content': ''}
+
+            # Handle list of dictionaries in content
+            if isinstance(content, list):
+                content_str = []
+                for item in content:
+                    if isinstance(item, dict):
+                        # Collect text or other attributes as needed
+                        text = item.get('text', '')
+                        image_url = item.get('image_url', '')
+                        content_str.append(text)
+                        content_str.append(image_url)
+                content_str = ", ".join(filter(None, content_str))
+            else:
+                content_str = content
+
+            # Concatenate content
+            if formatted_messages[role]['content']:
+                formatted_messages[role]['content'] += ' ' + content_str
+            else:
+                formatted_messages[role]['content'] = content_str
+
+    # Concatenate role and content for all messages
+    return ' '.join(
+        f"{message_data['role']}: {message_data['content']}"
+        for message_data in formatted_messages.values()
+        if message_data['content']
+    )

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/__init__.py

@@ -18,7 +18,7 @@ import requests
 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.semcov import SemanticConvention
 from openlit.otel.tracing import setup_tracing
 from openlit.otel.metrics import setup_meter
 from openlit.otel.events import setup_events
@@ -573,7 +573,7 @@ def trace(wrapped):
             try:
                 response = wrapped(*args, **kwargs)
                 span.set_attribute(
-                    SemanticConvetion.GEN_AI_CONTENT_COMPLETION, response or ""
+                    SemanticConvention.GEN_AI_CONTENT_COMPLETION, response or ""
                 )
                 span.set_status(Status(StatusCode.OK))
             except Exception as e:
@@ -632,7 +632,7 @@ class TracedSpan:
             result: The result to be set as an attribute on the span.
         """
 
-        self._span.set_attribute(SemanticConvetion.GEN_AI_CONTENT_COMPLETION, result)
+        self._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, result)
 
     def set_metadata(self, metadata: Dict):
         """

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/evals/utils.py

@@ -10,7 +10,7 @@ from opentelemetry.metrics import get_meter
 from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
 from anthropic import Anthropic
 from openai import OpenAI
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
@@ -238,7 +238,7 @@ def eval_metrics():
     )
 
     guard_requests = meter.create_counter(
-        name=SemanticConvetion.EVAL_REQUESTS,
+        name=SemanticConvention.EVAL_REQUESTS,
         description="Counter for evaluation requests",
         unit="1"
     )
@@ -262,14 +262,14 @@ def eval_metric_attributes(verdict, score, validator, classification, explanatio
     return {
             TELEMETRY_SDK_NAME:
                 "openlit",
-            SemanticConvetion.EVAL_VERDICT:
+            SemanticConvention.EVAL_VERDICT:
                 verdict,
-            SemanticConvetion.EVAL_SCORE:
+            SemanticConvention.EVAL_SCORE:
                 score,
-            SemanticConvetion.EVAL_VALIDATOR:
+            SemanticConvention.EVAL_VALIDATOR:
                 validator,
-            SemanticConvetion.EVAL_CLASSIFICATION:
+            SemanticConvention.EVAL_CLASSIFICATION:
                 classification,
-            SemanticConvetion.EVAL_EXPLANATION:
+            SemanticConvention.EVAL_EXPLANATION:
                 explanation,
     }

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/guard/utils.py

@@ -11,7 +11,7 @@ from opentelemetry.metrics import get_meter
 from opentelemetry.sdk.resources import TELEMETRY_SDK_NAME
 from anthropic import Anthropic
 from openai import OpenAI
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
@@ -202,7 +202,7 @@ def guard_metrics():
     )
 
     guard_requests = meter.create_counter(
-        name=SemanticConvetion.GUARD_REQUESTS,
+        name=SemanticConvention.GUARD_REQUESTS,
         description="Counter for Guard requests",
         unit="1"
     )
@@ -224,9 +224,9 @@ def guard_metric_attributes(verdict, score, validator, classification, explanati
     """
     return {
         TELEMETRY_SDK_NAME: "openlit",
-        SemanticConvetion.GUARD_VERDICT: verdict,
-        SemanticConvetion.GUARD_SCORE: score,
-        SemanticConvetion.GUARD_VALIDATOR: validator,
-        SemanticConvetion.GUARD_CLASSIFICATION: classification,
-        SemanticConvetion.GUARD_EXPLANATION: explanation,
+        SemanticConvention.GUARD_VERDICT: verdict,
+        SemanticConvention.GUARD_SCORE: score,
+        SemanticConvention.GUARD_VALIDATOR: validator,
+        SemanticConvention.GUARD_CLASSIFICATION: classification,
+        SemanticConvention.GUARD_EXPLANATION: explanation,
     }

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/instrumentation/ag2/ag2.py

@@ -11,7 +11,7 @@ from openlit.__helpers import (
     get_chat_model_cost,
     otel_event,
 )
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
@@ -29,17 +29,17 @@ def set_span_attributes(span, version, operation_name, environment,
 
     # 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)
+    span.set_attribute(SemanticConvention.GEN_AI_OPERATION, operation_name)
+    span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_AG2)
+    span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, AGENT_NAME)
+    span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
+    span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
+    span.set_attribute(SemanticConvention.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)
+    span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
 
 def calculate_tokens_and_cost(response, request_model, pricing_info):
     """
@@ -64,13 +64,13 @@ def emit_events(response, event_provider, capture_message_content):
     """
     for chat in response.chat_history:
         event_type = (
-            SemanticConvetion.GEN_AI_CHOICE if chat['role'] == 'user'
-            else SemanticConvetion.GEN_AI_USER_MESSAGE
+            SemanticConvention.GEN_AI_CHOICE if chat['role'] == 'user'
+            else SemanticConvention.GEN_AI_USER_MESSAGE
         )
         choice_event = otel_event(
             name=event_type,
             attributes={
-                SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AG2
+                SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AG2
             },
             body={
                 'index': response.chat_history.index(chat),
@@ -97,7 +97,7 @@ def conversable_agent(version, environment, application_name,
             SYSTEM_MESSAGE = kwargs.get('system_message', '')
             MODEL_AND_NAME_SET = True
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_CREATE_AGENT} {AGENT_NAME}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT} {AGENT_NAME}'
 
         with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
             try:
@@ -105,11 +105,11 @@ def conversable_agent(version, environment, application_name,
                 response = wrapped(*args, **kwargs)
                 end_time = time.time()
 
-                set_span_attributes(span, version, SemanticConvetion.GEN_AI_OPERATION_TYPE_CREATE_AGENT,
+                set_span_attributes(span, version, SemanticConvention.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_attribute(SemanticConvention.GEN_AI_AGENT_DESCRIPTION, SYSTEM_MESSAGE)
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, REQUEST_MODEL)
+                span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, end_time - start_time)
 
                 span.set_status(Status(StatusCode.OK))
 
@@ -130,7 +130,7 @@ def agent_run(version, environment, application_name,
     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}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {AGENT_NAME}'
 
         with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
             try:
@@ -141,14 +141,14 @@ def agent_run(version, environment, application_name,
                 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,
+                set_span_attributes(span, version, SemanticConvention.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)
+                span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, response_model)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens)
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
+                span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, end_time - start_time)
 
                 emit_events(response, event_provider, capture_message_content)
                 span.set_status(Status(StatusCode.OK))

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/instrumentation/ai21/ai21.py

@@ -16,7 +16,7 @@ from openlit.instrumentation.ai21.utils import (
     process_chat_rag_response
 )
 
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
@@ -113,7 +113,7 @@ def chat(version, environment, application_name,
         server_address, server_port = set_server_address_and_port(instance, 'api.ai21.com', 443)
         request_model = kwargs.get('model', 'jamba-1.5-mini')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
 
         # pylint: disable=no-else-return
         if streaming:
@@ -163,7 +163,7 @@ def chat_rag(version, environment, application_name,
         server_address, server_port = set_server_address_and_port(instance, 'api.ai21.com', 443)
         request_model = kwargs.get('model', 'jamba-1.5-mini')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
 
         with tracer.start_as_current_span(span_name, kind= SpanKind.CLIENT) as span:
             start_time = time.time()

{openlit-1.33.19 → openlit-1.33.21}/src/openlit/instrumentation/ai21/async_ai21.py

@@ -16,7 +16,7 @@ from openlit.instrumentation.ai21.utils import (
     process_chat_rag_response
 )
 
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
@@ -113,7 +113,7 @@ def async_chat(version, environment, application_name,
         server_address, server_port = set_server_address_and_port(instance, 'api.ai21.com', 443)
         request_model = kwargs.get('model', 'jamba-1.5-mini')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
 
         # pylint: disable=no-else-return
         if streaming:
@@ -163,7 +163,7 @@ def async_chat_rag(version, environment, application_name,
         server_address, server_port = set_server_address_and_port(instance, 'api.ai21.com', 443)
         request_model = kwargs.get('model', 'jamba-1.5-mini')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}'
 
         with tracer.start_as_current_span(span_name, kind= SpanKind.CLIENT) as span:
             start_time = time.time()