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

openlit/instrumentation/ollama/__init__.py

@@ -16,6 +16,29 @@ from openlit.instrumentation.ollama.async_ollama import (
 
 _instruments = ("ollama >= 0.2.0",)
 
+# Dispatch wrapper to route instrumentation to chat or embeddings based on path
+def _dispatch(sync_chat_wrap, sync_emb_wrap):
+    def wrapper(wrapped, instance, args, kwargs):
+        if len(args) > 2 and isinstance(args[2], str):
+            op = args[2].rstrip("/").split("/")[-1]
+            if op == "chat":
+                return sync_chat_wrap(wrapped, instance, args, kwargs)
+            if op == "embeddings":
+                return sync_emb_wrap(wrapped, instance, args, kwargs)
+        return wrapped(*args, **kwargs)
+    return wrapper
+
+def _dispatch_async(async_chat_wrap, async_emb_wrap):
+    async def wrapper(wrapped, instance, args, kwargs):
+        if len(args) > 2 and isinstance(args[2], str):
+            op = args[2].rstrip("/").split("/")[-1]
+            if op == "chat":
+                return await async_chat_wrap(wrapped, instance, args, kwargs)
+            if op == "embeddings":
+                return await async_emb_wrap(wrapped, instance, args, kwargs)
+        return await wrapped(*args, **kwargs)
+    return wrapper
+
 class OllamaInstrumentor(BaseInstrumentor):
     """
     An instrumentor for Ollama's client library.
@@ -35,48 +58,38 @@ class OllamaInstrumentor(BaseInstrumentor):
         disable_metrics = kwargs.get("disable_metrics")
         version = importlib.metadata.version("ollama")
 
-        # sync chat
-        wrap_function_wrapper(
-            "ollama",
-            "chat",
-            chat(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+        # Build wrapper factories for chat and embeddings
+        sync_chat_wrap = chat(
+            version, environment, application_name,
+            tracer, event_provider, pricing_info,
+            capture_message_content, metrics, disable_metrics
         )
-        wrap_function_wrapper(
-            "ollama",
-            "Client.chat",
-            chat(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+        sync_emb_wrap = embeddings(
+            version, environment, application_name,
+            tracer, event_provider, pricing_info,
+            capture_message_content, metrics, disable_metrics
         )
-
-        # sync embeddings
-        wrap_function_wrapper(
-            "ollama",
-            "embeddings",
-            embeddings(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+        async_chat_wrap = async_chat(
+            version, environment, application_name,
+            tracer, event_provider, pricing_info,
+            capture_message_content, metrics, disable_metrics
         )
-        wrap_function_wrapper(
-            "ollama",
-            "Client.embeddings",
-            embeddings(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+        async_emb_wrap = async_embeddings(
+            version, environment, application_name,
+            tracer, event_provider, pricing_info,
+            capture_message_content, metrics, disable_metrics
         )
 
-        # async chat
+        # Patch underlying request methods to ensure instrumentation regardless of import order
         wrap_function_wrapper(
-            "ollama",
-            "AsyncClient.chat",
-            async_chat(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+            "ollama._client",
+            "Client._request",
+            _dispatch(sync_chat_wrap, sync_emb_wrap),
         )
-
-        # async embeddings
         wrap_function_wrapper(
-            "ollama",
-            "AsyncClient.embeddings",
-            async_embeddings(version, environment, application_name,
-                  tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+            "ollama._client",
+            "AsyncClient._request",
+            _dispatch_async(async_chat_wrap, async_emb_wrap),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/ollama/async_ollama.py

@@ -15,7 +15,7 @@ from openlit.instrumentation.ollama.utils import (
     process_streaming_chat_response,
     process_embedding_response
 )
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 logger = logging.getLogger(__name__)
 
@@ -106,9 +106,10 @@ def async_chat(version, environment, application_name,
         streaming = kwargs.get("stream", False)
 
         server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 11434)
-        request_model = kwargs.get("model", "gpt-4o")
+        json_body = kwargs.get("json", {}) or {}
+        request_model = json_body.get("model") or kwargs.get("model")
 
-        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:
@@ -154,9 +155,10 @@ def async_embeddings(version, environment, application_name,
         """
 
         server_address, server_port = set_server_address_and_port(instance, '127.0.0.1', 11434)
-        request_model = kwargs.get('model', 'all-minilm')
+        json_body = kwargs.get('json', {}) or {}
+        request_model = json_body.get('model') or kwargs.get('model')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}'
 
         with tracer.start_as_current_span(span_name, kind= SpanKind.CLIENT) as span:
             start_time = time.time()

openlit/instrumentation/ollama/ollama.py

@@ -15,7 +15,7 @@ from openlit.instrumentation.ollama.utils import (
     process_streaming_chat_response,
     process_embedding_response
 )
-from openlit.semcov import SemanticConvetion
+from openlit.semcov import SemanticConvention
 
 logger = logging.getLogger(__name__)
 
@@ -106,9 +106,10 @@ def chat(version, environment, application_name,
         streaming = kwargs.get("stream", False)
 
         server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 11434)
-        request_model = kwargs.get("model", "gpt-4o")
+        json_body = kwargs.get("json", {}) or {}
+        request_model = json_body.get("model") or kwargs.get("model")
 
-        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:
@@ -154,9 +155,10 @@ def embeddings(version, environment, application_name,
         """
 
         server_address, server_port = set_server_address_and_port(instance, '127.0.0.1', 11434)
-        request_model = kwargs.get('model', 'all-minilm')
+        json_body = kwargs.get('json', {}) or {}
+        request_model = json_body.get('model') or kwargs.get('model')
 
-        span_name = f'{SemanticConvetion.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}'
+        span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}'
 
         with tracer.start_as_current_span(span_name, kind= SpanKind.CLIENT) as span:
             start_time = time.time()

openlit/instrumentation/ollama/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 process_chunk(self, chunk):
     """
@@ -57,27 +57,29 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
     if len(scope._timestamps) > 1:
         scope._tbt = calculate_tbt(scope._timestamps)
 
-    formatted_messages = extract_and_format_input(scope._kwargs.get("messages", ""))
-    request_model = scope._kwargs.get("model", "gpt-4o")
+    json_body = scope._kwargs.get("json", {}) or {}
+    request_model = json_body.get("model") or scope._kwargs.get("model")
+    messages = json_body.get("messages", scope._kwargs.get("messages", ""))
+    formatted_messages = extract_and_format_input(messages)
 
     cost = get_chat_model_cost(request_model, pricing_info, scope._input_tokens, scope._output_tokens)
 
     # Set Span attributes (OTel Semconv)
     scope._span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_OPERATION, SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM, SemanticConvetion.GEN_AI_SYSTEM_OLLAMA)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL, request_model)
-    scope._span.set_attribute(SemanticConvetion.SERVER_PORT, scope._server_port)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_OLLAMA)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
+    scope._span.set_attribute(SemanticConvention.SERVER_PORT, scope._server_port)
 
     options = scope._kwargs.get('options', {})
     attributes = [
-        (SemanticConvetion.GEN_AI_REQUEST_FREQUENCY_PENALTY, 'repeat_penalty'),
-        (SemanticConvetion.GEN_AI_REQUEST_MAX_TOKENS, 'max_tokens'),
-        (SemanticConvetion.GEN_AI_REQUEST_SEED, 'seed'),
-        (SemanticConvetion.GEN_AI_REQUEST_STOP_SEQUENCES, 'stop'),
-        (SemanticConvetion.GEN_AI_REQUEST_TEMPERATURE, 'temperature'),
-        (SemanticConvetion.GEN_AI_REQUEST_TOP_P, 'top_p'),
-        (SemanticConvetion.GEN_AI_REQUEST_TOP_K, 'top_k'),
+        (SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY, 'repeat_penalty'),
+        (SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, 'max_tokens'),
+        (SemanticConvention.GEN_AI_REQUEST_SEED, 'seed'),
+        (SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, 'stop'),
+        (SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, 'temperature'),
+        (SemanticConvention.GEN_AI_REQUEST_TOP_P, 'top_p'),
+        (SemanticConvention.GEN_AI_REQUEST_TOP_K, 'top_k'),
     ]
 
     for attribute, key in attributes:
@@ -85,37 +87,37 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
         if value is not None:
             scope._span.set_attribute(attribute, value)
 
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL, scope._response_model)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens)
-    scope._span.set_attribute(SemanticConvetion.SERVER_ADDRESS, scope._server_address)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
+    scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, scope._response_model)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens)
+    scope._span.set_attribute(SemanticConvention.SERVER_ADDRESS, scope._server_address)
 
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_OUTPUT_TYPE,
+    scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE,
                               "text" if isinstance(scope._llmresponse, str) else "json")
 
     scope._span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
     scope._span.set_attribute(SERVICE_NAME, application_name)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_IS_STREAM, is_stream)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens + scope._output_tokens)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST, cost)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_SERVER_TBT, scope._tbt)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_SERVER_TTFT, scope._ttft)
-    scope._span.set_attribute(SemanticConvetion.GEN_AI_SDK_VERSION, version)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, is_stream)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens + scope._output_tokens)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SERVER_TBT, scope._tbt)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT, scope._ttft)
+    scope._span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
 
     # To be removed one the change to log events (from span events) is complete
     prompt = concatenate_all_contents(formatted_messages)
     if capture_message_content:
         scope._span.add_event(
-            name=SemanticConvetion.GEN_AI_CONTENT_PROMPT_EVENT,
+            name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
             attributes={
-                SemanticConvetion.GEN_AI_CONTENT_PROMPT: prompt,
+                SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,
             },
         )
         scope._span.add_event(
-            name=SemanticConvetion.GEN_AI_CONTENT_COMPLETION_EVENT,
+            name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
             attributes={
-                SemanticConvetion.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,
+                SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,
             },
         )
 
@@ -145,9 +147,9 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
     for role in ['user', 'system', 'assistant', 'tool']:
         if formatted_messages.get(role, {}).get('content', ''):
             event = otel_event(
-                name=getattr(SemanticConvetion, f'GEN_AI_{role.upper()}_MESSAGE'),
+                name=getattr(SemanticConvention, f'GEN_AI_{role.upper()}_MESSAGE'),
                 attributes={
-                    SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_OLLAMA
+                    SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_OLLAMA
                 },
                 body = {
                     # pylint: disable=line-too-long
@@ -172,9 +174,9 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
             event_provider.emit(event)
 
     choice_event = otel_event(
-        name=SemanticConvetion.GEN_AI_CHOICE,
+        name=SemanticConvention.GEN_AI_CHOICE,
         attributes={
-            SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_OLLAMA
+            SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_OLLAMA
         },
         body=choice_event_body
     )
@@ -186,8 +188,8 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
         metrics_attributes = create_metrics_attributes(
             service_name=application_name,
             deployment_environment=environment,
-            operation=SemanticConvetion.GEN_AI_OPERATION_TYPE_CHAT,
-            system=SemanticConvetion.GEN_AI_SYSTEM_OLLAMA,
+            operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+            system=SemanticConvention.GEN_AI_SYSTEM_OLLAMA,
             request_model=request_model,
             server_address=scope._server_address,
             server_port=scope._server_port,
@@ -252,7 +254,9 @@ def process_embedding_response(response, request_model, pricing_info, server_por
     end_time = time.time()
 
     try:
-        input_tokens = general_tokens(str(kwargs.get('prompt')))
+        json_body = kwargs.get("json", {}) or {}
+        prompt_val = json_body.get('prompt', kwargs.get('prompt', ''))
+        input_tokens = general_tokens(str(prompt_val))
 
         # Calculate cost of the operation
         cost = get_embed_model_cost(request_model,
@@ -260,19 +264,19 @@ def process_embedding_response(response, request_model, pricing_info, server_por
 
         # Set Span attributes (OTel Semconv)
         span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')
-        span.set_attribute(SemanticConvetion.GEN_AI_OPERATION,
-                            SemanticConvetion.GEN_AI_OPERATION_TYPE_EMBEDDING)
-        span.set_attribute(SemanticConvetion.GEN_AI_SYSTEM,
-                            SemanticConvetion.GEN_AI_SYSTEM_OLLAMA)
-        span.set_attribute(SemanticConvetion.GEN_AI_REQUEST_MODEL,
+        span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
+                            SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING)
+        span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
+                            SemanticConvention.GEN_AI_SYSTEM_OLLAMA)
+        span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
                             request_model)
-        span.set_attribute(SemanticConvetion.GEN_AI_RESPONSE_MODEL,
+        span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL,
                             request_model)
-        span.set_attribute(SemanticConvetion.SERVER_ADDRESS,
+        span.set_attribute(SemanticConvention.SERVER_ADDRESS,
                             server_address)
-        span.set_attribute(SemanticConvetion.SERVER_PORT,
+        span.set_attribute(SemanticConvention.SERVER_PORT,
                             server_port)
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_INPUT_TOKENS,
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,
                             input_tokens)
 
         # Set Span attributes (Extras)
@@ -280,20 +284,20 @@ def process_embedding_response(response, request_model, pricing_info, server_por
                             environment)
         span.set_attribute(SERVICE_NAME,
                             application_name)
-        span.set_attribute(SemanticConvetion.GEN_AI_CLIENT_TOKEN_USAGE,
+        span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE,
                             input_tokens)
-        span.set_attribute(SemanticConvetion.GEN_AI_USAGE_COST,
+        span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST,
                             cost)
-        span.set_attribute(SemanticConvetion.GEN_AI_SDK_VERSION,
+        span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION,
                             version)
 
         prompt_event = otel_event(
-            name=SemanticConvetion.GEN_AI_USER_MESSAGE,
+            name=SemanticConvention.GEN_AI_USER_MESSAGE,
             attributes={
-                SemanticConvetion.GEN_AI_SYSTEM: SemanticConvetion.GEN_AI_SYSTEM_OLLAMA
+                SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_OLLAMA
             },
             body={
-                **({"content": kwargs.get('prompt', '')} if capture_message_content else {}),
+                **({"content": prompt_val} if capture_message_content else {}),
                 "role":  'user'
             }
         )
@@ -305,8 +309,8 @@ def process_embedding_response(response, request_model, pricing_info, server_por
             attributes = create_metrics_attributes(
                 service_name=application_name,
                 deployment_environment=environment,
-                operation=SemanticConvetion.GEN_AI_OPERATION_TYPE_EMBEDDING,
-                system=SemanticConvetion.GEN_AI_SYSTEM_OLLAMA,
+                operation=SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,
+                system=SemanticConvention.GEN_AI_SYSTEM_OLLAMA,
                 request_model=request_model,
                 server_address=server_address,
                 server_port=server_port,