openlit 1.33.19__py3-none-any.whl → 1.33.21__py3-none-any.whl

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/__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/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/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/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/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/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()

openlit/instrumentation/ai21/utils.py

@@ -19,7 +19,7 @@ from openlit.__helpers import (
     otel_event,
     concatenate_all_contents
 )
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 def setup_common_span_attributes(span, request_model, kwargs, tokens,
                                  server_port, server_address, environment,
@@ -30,32 +30,32 @@ def setup_common_span_attributes(span, request_model, kwargs, tokens,
 
     # Base attributes from SDK and operation settings.
     span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')
-    span.set_attribute(SemanticConvetion.GEN_AI_OPERATION, SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT)
-    span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM, SemanticConvetion.GEN_AI_SYSTEM_AI21)
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL, request_model)
-    span.set_attribute(SemanticConvetion.SERVER_PORT, server_port)
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_SEED, kwargs.get('seed', ''))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY, kwargs.get('frequency_penalty', 0.0))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get('max_tokens', -1))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_PRESENCE_PENALTY, kwargs.get('presence_penalty', 0.0))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_STOP_SEQUENCES, kwargs.get('stop', []))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE, kwargs.get('temperature', 0.4))
-    span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_TOP_P, kwargs.get('top_p', 1.0))
+    span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)
+    span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_AI21)
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
+    span.set_attribute(SemanticConvention.SERVER_PORT, server_port)
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, kwargs.get('seed', ''))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY, kwargs.get('frequency_penalty', 0.0))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get('max_tokens', -1))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY, kwargs.get('presence_penalty', 0.0))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, kwargs.get('stop', []))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, kwargs.get('temperature', 0.4))
+    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, kwargs.get('top_p', 1.0))
 
     # Add token-related attributes if available.
     if 'finish_reason' in tokens:
-        span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON, [tokens['finish_reason']])
+        span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [tokens['finish_reason']])
     if 'response_id' in tokens:
-        span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_ID, tokens['response_id'])
+        span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, tokens['response_id'])
     if 'input_tokens' in tokens:
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_INPUT_TOKENS, tokens['input_tokens'])
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, tokens['input_tokens'])
     if 'output_tokens' in tokens:
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_OUTPUT_TOKENS, tokens['output_tokens'])
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, tokens['output_tokens'])
     if 'total_tokens' in tokens:
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_TOTAL_TOKENS, tokens['total_tokens'])
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, tokens['total_tokens'])
 
-    span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL, request_model)
-    span.set_attribute(SemanticConvetion.SERVER_ADDRESS, server_address)
+    span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, request_model)
+    span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)
     # Environment and service identifiers.
     span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
     span.set_attribute(SERVICE_NAME, application_name)
@@ -73,8 +73,8 @@ def record_common_metrics(metrics, application_name, environment, request_model,
     attributes = create_metrics_attributes(
         service_name=application_name,
         deployment_environment=environment,
-        operation=SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-        system=SemanticConvetion.GEN_AI_SYSTEM_AI21,
+        operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+        system=SemanticConvention.GEN_AI_SYSTEM_AI21,
         request_model=request_model,
         server_address=server_address,
         server_port=server_port,
@@ -121,15 +121,15 @@ def emit_common_events(event_provider, choices, finish_reason, llmresponse, form
                         }
                     })
                     event = otel_event(
-                        name=SemanticConvetion.GEN_AI_CHOICE,
-                        attributes={SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AI21},
+                        name=SemanticConvention.GEN_AI_CHOICE,
+                        attributes={SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AI21},
                         body=choice_event_body
                     )
                     event_provider.emit(event)
             else:
                 event = otel_event(
-                    name=SemanticConvetion.GEN_AI_CHOICE,
-                    attributes={SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AI21},
+                    name=SemanticConvention.GEN_AI_CHOICE,
+                    attributes={SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AI21},
                     body=choice_event_body
                 )
                 event_provider.emit(event)
@@ -144,8 +144,8 @@ def emit_common_events(event_provider, choices, finish_reason, llmresponse, form
             }
         }
         event = otel_event(
-            name=SemanticConvetion.GEN_AI_CHOICE,
-            attributes={SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AI21},
+            name=SemanticConvention.GEN_AI_CHOICE,
+            attributes={SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AI21},
             body=choice_event_body
         )
         event_provider.emit(event)
@@ -175,8 +175,8 @@ def emit_common_events(event_provider, choices, finish_reason, llmresponse, form
                 if tool_calls:
                     event_body['id'] = tool_calls[0].get('id', '')
             event = otel_event(
-                name=getattr(SemanticConvetion, f'GEN_AI_{role.upper()}_MESSAGE'),
-                attributes={SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_AI21},
+                name=getattr(SemanticConvention, f'GEN_AI_{role.upper()}_MESSAGE'),
+                attributes={SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AI21},
                 body=event_body
             )
             event_provider.emit(event)
@@ -233,13 +233,13 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
         'total_tokens': scope._input_tokens + scope._output_tokens,
     }
     extra_attrs = {
-        SemanticConvetion.GEN_AI_REQUEST_IS_STREAM: is_stream,
-        SemanticConvetion.GEN_AI_CLIENT_TOKEN_USAGE: scope._input_tokens + scope._output_tokens,
-        SemanticConvetion.GEN_AI_USAGE_COST: cost,
-        SemanticConvetion.GEN_AI_SERVER_TBT: scope._tbt,
-        SemanticConvetion.GEN_AI_SERVER_TTFT: scope._ttft,
-        SemanticConvetion.GEN_AI_SDK_VERSION: version,
-        SemanticConvetion.GEN_AI_OUTPUT_TYPE: 'text' if isinstance(scope._llmresponse, str) else 'json'
+        SemanticConvention.GEN_AI_REQUEST_IS_STREAM: is_stream,
+        SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE: scope._input_tokens + scope._output_tokens,
+        SemanticConvention.GEN_AI_USAGE_COST: cost,
+        SemanticConvention.GEN_AI_SERVER_TBT: scope._tbt,
+        SemanticConvention.GEN_AI_SERVER_TTFT: scope._ttft,
+        SemanticConvention.GEN_AI_SDK_VERSION: version,
+        SemanticConvention.GEN_AI_OUTPUT_TYPE: 'text' if isinstance(scope._llmresponse, str) else 'json'
     }
     # Set span attributes.
     setup_common_span_attributes(scope._span, request_model, scope._kwargs, tokens,
@@ -249,12 +249,12 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
     # Optionally add events capturing the prompt and completion.
     if capture_message_content:
         scope._span.add_event(
-            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
-            attributes={SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt},
+            name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
+            attributes={SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt},
         )
         scope._span.add_event(
-            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
-            attributes={SemanticConvetion.GEN_AI_CONTENT_COMPLETION: scope._llmresponse},
+            name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
+            attributes={SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse},
         )
 
     # Emit events for each choice and message role.
@@ -336,15 +336,15 @@ def process_chat_rag_response(response, request_model, pricing_info, server_port
         # Create tokens dict and RAG-specific extra attributes.
         tokens = {'response_id': response_dict.get('id'), 'input_tokens': input_tokens}
         extra_attrs = {
-            SemanticConvetion.GEN_AI_REQUEST_IS_STREAM: False,
-            SemanticConvetion.GEN_AI_SERVER_TTFT: end_time - start_time,
-            SemanticConvetion.GEN_AI_SDK_VERSION: version,
-            SemanticConvetion.GEN_AI_RAG_MAX_SEGMENTS: kwargs.get('max_segments', -1),
-            SemanticConvetion.GEN_AI_RAG_STRATEGY: kwargs.get('retrieval_strategy', 'segments'),
-            SemanticConvetion.GEN_AI_RAG_SIMILARITY_THRESHOLD: kwargs.get('retrieval_similarity_threshold', -1),
-            SemanticConvetion.GEN_AI_RAG_MAX_NEIGHBORS: kwargs.get('max_neighbors', -1),
-            SemanticConvetion.GEN_AI_RAG_FILE_IDS: str(kwargs.get('file_ids', '')),
-            SemanticConvetion.GEN_AI_RAG_DOCUMENTS_PATH: kwargs.get('path', '')
+            SemanticConvention.GEN_AI_REQUEST_IS_STREAM: False,
+            SemanticConvention.GEN_AI_SERVER_TTFT: end_time - start_time,
+            SemanticConvention.GEN_AI_SDK_VERSION: version,
+            SemanticConvention.GEN_AI_RAG_MAX_SEGMENTS: kwargs.get('max_segments', -1),
+            SemanticConvention.GEN_AI_RAG_STRATEGY: kwargs.get('retrieval_strategy', 'segments'),
+            SemanticConvention.GEN_AI_RAG_SIMILARITY_THRESHOLD: kwargs.get('retrieval_similarity_threshold', -1),
+            SemanticConvention.GEN_AI_RAG_MAX_NEIGHBORS: kwargs.get('max_neighbors', -1),
+            SemanticConvention.GEN_AI_RAG_FILE_IDS: str(kwargs.get('file_ids', '')),
+            SemanticConvention.GEN_AI_RAG_DOCUMENTS_PATH: kwargs.get('path', '')
         }
         # Set common span attributes.
         setup_common_span_attributes(span, request_model, kwargs, tokens,
@@ -354,8 +354,8 @@ def process_chat_rag_response(response, request_model, pricing_info, server_port
         # Record the prompt event if requested.
         if capture_message_content:
             span.add_event(
-                name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
-                attributes={SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt},
+                name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
+                attributes={SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt},
             )
 
         output_tokens = 0
@@ -368,13 +368,13 @@ def process_chat_rag_response(response, request_model, pricing_info, server_port
             aggregated_completion.append(content)
             output_tokens += general_tokens(content)
             if kwargs.get('tools'):
-                span.set_attribute(SemanticConvetion.GEN_AI_TOOL_CALLS,
+                span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALLS,
                                    str(choices[i].get('message', {}).get('tool_calls')))
             # Set output type based on actual content type.
             if isinstance(content, str):
-                span.set_attribute(SemanticConvetion.GEN_AI_OUTPUT_TYPE, 'text')
+                span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, 'text')
             elif content is not None:
-                span.set_attribute(SemanticConvetion.GEN_AI_OUTPUT_TYPE, 'json')
+                span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, 'json')
 
         # Concatenate completion responses.
         llmresponse = ''.join(aggregated_completion)
@@ -382,16 +382,16 @@ def process_chat_rag_response(response, request_model, pricing_info, server_port
         tokens['total_tokens'] = input_tokens + output_tokens
 
         cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST, cost)
-        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(SemanticConvention.GEN_AI_USAGE_COST, cost)
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, input_tokens + output_tokens)
 
         span.set_status(Status(StatusCode.OK))
         # Emit a single aggregated completion event.
         if capture_message_content:
             span.add_event(
-                name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
-                attributes={SemanticConvetion.GEN_AI_CONTENT_COMPLETION: llmresponse},
+                name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
+                attributes={SemanticConvention.GEN_AI_CONTENT_COMPLETION: llmresponse},
             )
         # Emit the rest of the events (choice and role-based events) as before.
         n = kwargs.get('n', 1)

openlit/instrumentation/anthropic/anthropic.py

@@ -14,7 +14,7 @@ from openlit.instrumentation.anthropic.utils import (
     process_chat_response,
     process_streaming_chat_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 messages(version, environment, application_name, tracer, event_provider,
         server_address, server_port = set_server_address_and_port(instance, 'api.anthropic.com', 443)
         request_model = kwargs.get('model', 'claude-3-5-sonnet-latest')
 
-        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:

openlit/instrumentation/anthropic/async_anthropic.py

@@ -14,7 +14,7 @@ from openlit.instrumentation.anthropic.utils import (
     process_chat_response,
     process_streaming_chat_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_messages(version, environment, application_name, tracer, event_provide
         server_address, server_port = set_server_address_and_port(instance, 'api.anthropic.com', 443)
         request_model = kwargs.get('model', 'claude-3-5-sonnet-latest')
 
-        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: