Skip to content

Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.

[Feat]: Refactor Anthropic OpenTelemetry Monitoring Instrumentation (#782)

Patchered5461e40859
diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.toml
index ecd5cbb9..d8f1ece2 100644
--- a/sdk/python/pyproject.toml
+++ b/sdk/python/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "openlit"
-version = "1.34.18"
+version = "1.34.19"
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"
diff --git a/sdk/python/src/openlit/instrumentation/anthropic/__init__.py b/sdk/python/src/openlit/instrumentation/anthropic/__init__.py
index ea14e074..fc8ccf88 100644
--- a/sdk/python/src/openlit/instrumentation/anthropic/__init__.py
+++ b/sdk/python/src/openlit/instrumentation/anthropic/__init__.py
@@ -8,7 +8,7 @@ from wrapt import wrap_function_wrapper
from openlit.instrumentation.anthropic.anthropic import messages
from openlit.instrumentation.anthropic.async_anthropic import async_messages
-_instruments = ('anthropic >= 0.21.0',)
+_instruments = ("anthropic >= 0.21.0",)
class AnthropicInstrumentor(BaseInstrumentor):
"""
@@ -19,32 +19,30 @@ class AnthropicInstrumentor(BaseInstrumentor):
return _instruments
def _instrument(self, **kwargs):
- application_name = kwargs.get('application_name', 'default')
- environment = kwargs.get('environment', 'default')
- 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('anthropic')
-
- #sync
+ version = importlib.metadata.version("anthropic")
+ environment = kwargs.get("environment", "default")
+ application_name = kwargs.get("application_name", "default")
+ tracer = kwargs.get("tracer")
+ pricing_info = kwargs.get("pricing_info", {})
+ capture_message_content = kwargs.get("capture_message_content", False)
+ metrics = kwargs.get("metrics_dict")
+ disable_metrics = kwargs.get("disable_metrics")
+
+ # sync
wrap_function_wrapper(
- 'anthropic.resources.messages',
- 'Messages.create',
- messages(version, environment, application_name,
- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+ "anthropic.resources.messages",
+ "Messages.create",
+ messages(version, environment, application_name, tracer, pricing_info,
+ capture_message_content, metrics, disable_metrics),
)
- #async
+ # async
wrap_function_wrapper(
- 'anthropic.resources.messages',
- 'AsyncMessages.create',
- async_messages(version, environment, application_name,
- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),
+ "anthropic.resources.messages",
+ "AsyncMessages.create",
+ async_messages(version, environment, application_name, tracer, pricing_info,
+ capture_message_content, metrics, disable_metrics),
)
def _uninstrument(self, **kwargs):
- # Proper uninstrumentation logic to revert patched methods
pass
diff --git a/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py b/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py
index d3460f91..52f2f445 100644
--- a/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py
+++ b/sdk/python/src/openlit/instrumentation/anthropic/anthropic.py
@@ -2,7 +2,6 @@
Module for monitoring Anthropic API calls.
"""
-import logging
import time
from opentelemetry.trace import SpanKind
from openlit.__helpers import (
@@ -16,13 +15,9 @@ from openlit.instrumentation.anthropic.utils import (
)
from openlit.semcov import SemanticConvention
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
-
-def messages(version, environment, application_name, tracer, event_provider,
- pricing_info, capture_message_content, metrics, disable_metrics):
+def messages(version, environment, application_name, tracer, pricing_info, capture_message_content, metrics, disable_metrics):
"""
- Generates a telemetry wrapper for GenAI function call
+ Generates a telemetry wrapper for Anthropic Messages.create calls.
"""
class TracedSyncStream:
@@ -38,24 +33,21 @@ def messages(version, environment, application_name, tracer, event_provider,
kwargs,
server_address,
server_port,
- **args,
):
self.__wrapped__ = wrapped
self._span = span
self._span_name = span_name
- self._llmresponse = ''
- self._response_id = ''
- self._response_model = ''
- self._finish_reason = ''
- self._input_tokens = ''
- self._output_tokens = ''
- self._tool_arguments = ''
- self._tool_id = ''
- self._tool_name = ''
+ self._llmresponse = ""
+ self._response_id = ""
+ self._response_model = ""
+ self._finish_reason = ""
+ self._input_tokens = 0
+ self._output_tokens = 0
+ self._tool_arguments = ""
+ self._tool_id = ""
+ self._tool_name = ""
self._tool_calls = None
- self._response_role = ''
-
- self._args = args
+ self._response_role = ""
self._kwargs = kwargs
self._start_time = time.time()
self._end_time = None
@@ -86,34 +78,31 @@ def messages(version, environment, application_name, tracer, event_provider,
return chunk
except StopIteration:
try:
- with tracer.start_as_current_span(self._span_name, kind= SpanKind.CLIENT) as self._span:
+ with self._span:
process_streaming_chat_response(
self,
pricing_info=pricing_info,
environment=environment,
application_name=application_name,
metrics=metrics,
- event_provider=event_provider,
capture_message_content=capture_message_content,
disable_metrics=disable_metrics,
version=version
)
-
except Exception as e:
handle_exception(self._span, e)
- logger.error("Error in trace creation: %s", e)
raise
def wrapper(wrapped, instance, args, kwargs):
"""
- Wraps the GenAI function call.
+ Wraps the Anthropic Messages.create call.
"""
- streaming = kwargs.get('stream', False)
- server_address, server_port = set_server_address_and_port(instance, 'api.anthropic.com', 443)
- request_model = kwargs.get('model', 'claude-3-5-sonnet-latest')
+ streaming = kwargs.get("stream", False)
+ 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'{SemanticConvention.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:
@@ -126,23 +115,27 @@ def messages(version, environment, application_name, tracer, event_provider,
with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
start_time = time.time()
response = wrapped(*args, **kwargs)
- response = process_chat_response(
- response=response,
- request_model=request_model,
- pricing_info=pricing_info,
- server_port=server_port,
- server_address=server_address,
- environment=environment,
- application_name=application_name,
- metrics=metrics,
- event_provider=event_provider,
- start_time=start_time,
- span=span,
- capture_message_content=capture_message_content,
- disable_metrics=disable_metrics,
- version=version,
- **kwargs
- )
+
+ try:
+ response = process_chat_response(
+ response=response,
+ request_model=request_model,
+ pricing_info=pricing_info,
+ server_port=server_port,
+ server_address=server_address,
+ environment=environment,
+ application_name=application_name,
+ metrics=metrics,
+ start_time=start_time,
+ span=span,
+ capture_message_content=capture_message_content,
+ disable_metrics=disable_metrics,
+ version=version,
+ **kwargs
+ )
+
+ except Exception as e:
+ handle_exception(span, e)
return response
diff --git a/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py b/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py
index 5bbb6a5f..467def84 100644
--- a/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py
+++ b/sdk/python/src/openlit/instrumentation/anthropic/async_anthropic.py
@@ -2,7 +2,6 @@
Module for monitoring Anthropic API calls.
"""
-import logging
import time
from opentelemetry.trace import SpanKind
from openlit.__helpers import (
@@ -16,18 +15,14 @@ from openlit.instrumentation.anthropic.utils import (
)
from openlit.semcov import SemanticConvention
-# Initialize logger for logging potential issues and operations
-logger = logging.getLogger(__name__)
-
-def async_messages(version, environment, application_name, tracer, event_provider,
- pricing_info, capture_message_content, metrics, disable_metrics):
+def async_messages(version, environment, application_name, tracer, pricing_info, capture_message_content, metrics, disable_metrics):
"""
- Generates a telemetry wrapper for GenAI function call
+ Generates a telemetry wrapper for Anthropic AsyncMessages.create calls.
"""
class TracedAsyncStream:
"""
- Wrapper for streaming responses to collect telemetry.
+ Wrapper for async streaming responses to collect telemetry.
"""
def __init__(
@@ -38,24 +33,21 @@ def async_messages(version, environment, application_name, tracer, event_provide
kwargs,
server_address,
server_port,
- **args,
):
self.__wrapped__ = wrapped
self._span = span
self._span_name = span_name
- self._llmresponse = ''
- self._response_id = ''
- self._response_model = ''
- self._finish_reason = ''
- self._input_tokens = ''
- self._output_tokens = ''
- self._tool_arguments = ''
- self._tool_id = ''
- self._tool_name = ''
+ self._llmresponse = ""
+ self._response_id = ""
+ self._response_model = ""
+ self._finish_reason = ""
+ self._input_tokens = 0
+ self._output_tokens = 0
+ self._tool_arguments = ""
+ self._tool_id = ""
+ self._tool_name = ""
self._tool_calls = None
- self._response_role = ''
-
- self._args = args
+ self._response_role = ""
self._kwargs = kwargs
self._start_time = time.time()
self._end_time = None
@@ -86,34 +78,31 @@ def async_messages(version, environment, application_name, tracer, event_provide
return chunk
except StopAsyncIteration:
try:
- with tracer.start_as_current_span(self._span_name, kind= SpanKind.CLIENT) as self._span:
+ with self._span:
process_streaming_chat_response(
self,
pricing_info=pricing_info,
environment=environment,
application_name=application_name,
metrics=metrics,
- event_provider=event_provider,
capture_message_content=capture_message_content,
disable_metrics=disable_metrics,
version=version
)
-
except Exception as e:
handle_exception(self._span, e)
- logger.error("Error in trace creation: %s", e)
raise
async def wrapper(wrapped, instance, args, kwargs):
"""
- Wraps the GenAI function call.
+ Wraps the Anthropic AsyncMessages.create call.
"""
- streaming = kwargs.get('stream', False)
- server_address, server_port = set_server_address_and_port(instance, 'api.anthropic.com', 443)
- request_model = kwargs.get('model', 'claude-3-5-sonnet-latest')
+ streaming = kwargs.get("stream", False)
+ 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'{SemanticConvention.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:
@@ -126,23 +115,27 @@ def async_messages(version, environment, application_name, tracer, event_provide
with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
start_time = time.time()
response = await wrapped(*args, **kwargs)
- response = process_chat_response(
- response=response,
- request_model=request_model,
- pricing_info=pricing_info,
- server_port=server_port,
- server_address=server_address,
- environment=environment,
- application_name=application_name,
- metrics=metrics,
- event_provider=event_provider,
- start_time=start_time,
- span=span,
- capture_message_content=capture_message_content,
- disable_metrics=disable_metrics,
- version=version,
- **kwargs
- )
+
+ try:
+ response = process_chat_response(
+ response=response,
+ request_model=request_model,
+ pricing_info=pricing_info,
+ server_port=server_port,
+ server_address=server_address,
+ environment=environment,
+ application_name=application_name,
+ metrics=metrics,
+ start_time=start_time,
+ span=span,
+ capture_message_content=capture_message_content,
+ disable_metrics=disable_metrics,
+ version=version,
+ **kwargs
+ )
+
+ except Exception as e:
+ handle_exception(span, e)
return response
diff --git a/sdk/python/src/openlit/instrumentation/anthropic/utils.py b/sdk/python/src/openlit/instrumentation/anthropic/utils.py
index 1c2b4e86..6e899101 100644
--- a/sdk/python/src/openlit/instrumentation/anthropic/utils.py
+++ b/sdk/python/src/openlit/instrumentation/anthropic/utils.py
@@ -3,63 +3,92 @@ Anthropic OpenTelemetry instrumentation utility functions
"""
import time
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
from opentelemetry.trace import Status, StatusCode
from openlit.__helpers import (
calculate_ttft,
response_as_dict,
calculate_tbt,
- extract_and_format_input,
get_chat_model_cost,
- create_metrics_attributes,
- otel_event,
- concatenate_all_contents
+ record_completion_metrics,
+ common_span_attributes,
)
from openlit.semcov import SemanticConvention
-def process_chunk(self, chunk):
+def format_content(messages):
+ """
+ Format the messages into a string for span events.
+ """
+
+ if not messages:
+ return ""
+
+ formatted_messages = []
+ for message in messages:
+ if isinstance(message, dict):
+ role = message.get("role", "user")
+ content = message.get("content", "")
+ else:
+ # Handle Anthropic object format
+ role = getattr(message, "role", "user")
+ content = getattr(message, "content", "")
+
+ if isinstance(content, list):
+ # Handle structured content (e.g., text + images)
+ text_parts = []
+ for part in content:
+ if isinstance(part, dict) and part.get("type") == "text":
+ text_parts.append(part.get("text", ""))
+ content = " ".join(text_parts)
+ elif not isinstance(content, str):
+ content = str(content)
+
+ formatted_messages.append(f"{role}: {content}")
+
+ return "\n".join(formatted_messages)
+
+def process_chunk(scope, chunk):
"""
Process a chunk of response data and update state.
"""
end_time = time.time()
# Record the timestamp for the current chunk
- self._timestamps.append(end_time)
+ scope._timestamps.append(end_time)
- if len(self._timestamps) == 1:
+ if len(scope._timestamps) == 1:
# Calculate time to first chunk
- self._ttft = calculate_ttft(self._timestamps, self._start_time)
+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)
chunked = response_as_dict(chunk)
# Collect message IDs and input token from events
- if chunked.get('type') == 'message_start':
- self._response_id = chunked.get('message').get('id')
- self._input_tokens = chunked.get('message').get('usage').get('input_tokens')
- self._response_model = chunked.get('message').get('model')
- self._response_role = chunked.get('message').get('role')
+ if chunked.get("type") == "message_start":
+ scope._response_id = chunked.get("message").get("id")
+ scope._input_tokens = chunked.get("message").get("usage").get("input_tokens")
+ scope._response_model = chunked.get("message").get("model")
+ scope._response_role = chunked.get("message").get("role")
# Collect message IDs and aggregated response from events
- if chunked.get('type') == 'content_block_delta':
- if chunked.get('delta').get('text'):
- self._llmresponse += chunked.get('delta').get('text')
- elif chunked.get('delta').get('partial_json'):
- self._tool_arguments += chunked.get('delta').get('partial_json')
-
- if chunked.get('type') == 'content_block_start':
- if chunked.get('content_block').get('id'):
- self._tool_id = chunked.get('content_block').get('id')
- if chunked.get('content_block').get('name'):
- self._tool_name = chunked.get('content_block').get('name')
+ if chunked.get("type") == "content_block_delta":
+ if chunked.get("delta").get("text"):
+ scope._llmresponse += chunked.get("delta").get("text")
+ elif chunked.get("delta").get("partial_json"):
+ scope._tool_arguments += chunked.get("delta").get("partial_json")
+
+ if chunked.get("type") == "content_block_start":
+ if chunked.get("content_block").get("id"):
+ scope._tool_id = chunked.get("content_block").get("id")
+ if chunked.get("content_block").get("name"):
+ scope._tool_name = chunked.get("content_block").get("name")
# Collect output tokens and stop reason from events
- if chunked.get('type') == 'message_delta':
- self._output_tokens = chunked.get('usage').get('output_tokens')
- self._finish_reason = chunked.get('delta').get('stop_reason')
+ if chunked.get("type") == "message_delta":
+ scope._output_tokens = chunked.get("usage").get("output_tokens")
+ scope._finish_reason = chunked.get("delta").get("stop_reason")
def common_chat_logic(scope, pricing_info, environment, application_name, metrics,
- event_provider, capture_message_content, disable_metrics, version, is_stream):
+ capture_message_content, disable_metrics, version, is_stream):
"""
Process chat request and generate Telemetry
"""
@@ -68,48 +97,56 @@ 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', 'claude-3-opus-20240229')
+ formatted_messages = format_content(scope._kwargs.get("messages", []))
+ request_model = scope._kwargs.get("model", "claude-3-5-sonnet-latest")
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(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)
- scope._span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC)
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, request_model)
- scope._span.set_attribute(SemanticConvention.SERVER_PORT, scope._server_port)
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, scope._kwargs.get('max_tokens', -1))
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, scope._kwargs.get('stop_sequences', []))
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, scope._kwargs.get('temperature', 1.0))
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K, scope._kwargs.get('top_k', 1.0))
- scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, scope._kwargs.get('top_p', 1.0))
- scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
+ # Common Span Attributes
+ common_span_attributes(scope,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC,
+ scope._server_address, scope._server_port, request_model, scope._response_model,
+ environment, application_name, is_stream, scope._tbt, scope._ttft, version)
+
+ # Span Attributes for Request parameters
+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, scope._kwargs.get("max_tokens", -1))
+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, scope._kwargs.get("stop_sequences", []))
+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, scope._kwargs.get("temperature", 1.0))
+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K, scope._kwargs.get("top_k", 1.0))
+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, scope._kwargs.get("top_p", 1.0))
+
+ # Span Attributes for Response parameters
scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id)
- scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, scope._response_model)
+ scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
+ scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "text" if isinstance(scope._llmresponse, str) else "json")
+
+ # Span Attributes for Cost and Tokens
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(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(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)
+ # Handle tool calls if present
+ if scope._tool_calls:
+ # Optimized tool handling - extract name, id, and arguments
+ tool_name = scope._tool_calls.get("name", "")
+ tool_id = scope._tool_calls.get("id", "")
+ tool_args = scope._tool_calls.get("input", "")
+
+ scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_NAME, tool_name)
+ scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALL_ID, tool_id)
+ scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_ARGS, str(tool_args))
+
+ # Span Attributes for Content
if capture_message_content:
+ scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, formatted_messages)
+ scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)
+
+ # To be removed once the change to span_attributes (from span events) is complete
scope._span.add_event(
name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
attributes={
- SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,
+ SemanticConvention.GEN_AI_CONTENT_PROMPT: formatted_messages,
},
)
scope._span.add_event(
@@ -119,133 +156,70 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
},
)
- choice_event_body = {
- 'finish_reason': scope._finish_reason,
- 'index': 0,
- 'message': {
- **({'content': scope._llmresponse} if capture_message_content else {}),
- 'role': scope._response_role
- }
- }
-
- if scope._tool_calls:
- choice_event_body['message'].update({
- 'tool_calls': {
- 'function': {
- 'name': scope._tool_calls.get('name', ''),
- 'arguments': scope._tool_calls.get('input', '')
- },
- 'id': scope._tool_calls.get('id', ''),
- 'type': 'function'
- }
- })
-
- # Emit events
- for role in ['user', 'system', 'assistant', 'tool']:
- if formatted_messages.get(role, {}).get('content', ''):
- event = otel_event(
- name=getattr(SemanticConvention, f'GEN_AI_{role.upper()}_MESSAGE'),
- attributes={
- SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC
- },
- body = {
- # pylint: disable=line-too-long
- **({'content': formatted_messages.get(role, {}).get('content', '')} if capture_message_content else {}),
- 'role': formatted_messages.get(role, {}).get('role', []),
- **({
- 'tool_calls': {
- 'function': {
- # pylint: disable=line-too-long
- 'name': (scope._tool_calls[0].get('function', {}).get('name', '') if scope._tool_calls else ''),
- 'arguments': (scope._tool_calls[0].get('function', {}).get('arguments', '') if scope._tool_calls else '')
- },
- 'id': (scope._tool_calls[0].get('id', '') if scope._tool_calls else ''),
- 'type': 'function'
- }
- } if role == 'assistant' else {}),
- **({
- 'id': (scope._tool_calls[0].get('id', '') if scope._tool_calls else '')
- } if role == 'tool' else {})
- }
- )
- event_provider.emit(event)
-
- choice_event = otel_event(
- name=SemanticConvention.GEN_AI_CHOICE,
- attributes={
- SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC
- },
- body=choice_event_body
- )
- event_provider.emit(choice_event)
-
scope._span.set_status(Status(StatusCode.OK))
+ # Record metrics
if not disable_metrics:
- metrics_attributes = create_metrics_attributes(
- service_name=application_name,
- deployment_environment=environment,
- operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
- system=SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC,
- request_model=request_model,
- server_address=scope._server_address,
- server_port=scope._server_port,
- response_model=scope._response_model,
- )
+ record_completion_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC,
+ scope._server_address, scope._server_port, request_model, scope._response_model, environment,
+ application_name, scope._start_time, scope._end_time, scope._input_tokens, scope._output_tokens,
+ cost, scope._tbt, scope._ttft)
- metrics['genai_client_usage_tokens'].record(scope._input_tokens + scope._output_tokens, metrics_attributes)
- metrics['genai_client_operation_duration'].record(scope._end_time - scope._start_time, metrics_attributes)
- metrics['genai_server_tbt'].record(scope._tbt, metrics_attributes)
- metrics['genai_server_ttft'].record(scope._ttft, metrics_attributes)
- metrics['genai_requests'].add(1, metrics_attributes)
- metrics['genai_completion_tokens'].add(scope._output_tokens, metrics_attributes)
- metrics['genai_prompt_tokens'].add(scope._input_tokens, metrics_attributes)
- metrics['genai_cost'].record(cost, metrics_attributes)
-
-def process_streaming_chat_response(self, pricing_info, environment, application_name, metrics,
- event_provider, capture_message_content=False, disable_metrics=False, version=''):
+def process_streaming_chat_response(scope, pricing_info, environment, application_name, metrics,
+ capture_message_content=False, disable_metrics=False, version=""):
"""
- Process chat request and generate Telemetry
+ Process streaming chat response and generate telemetry.
"""
- if self._tool_id != '':
- self._tool_calls = {
- 'id': self._tool_id,
- 'name': self._tool_name,
- 'input': self._tool_arguments
+
+ if scope._tool_id != "":
+ scope._tool_calls = {
+ "id": scope._tool_id,
+ "name": scope._tool_name,
+ "input": scope._tool_arguments
}
- common_chat_logic(self, pricing_info, environment, application_name, metrics,
- event_provider, capture_message_content, disable_metrics, version, is_stream=True)
+ common_chat_logic(scope, pricing_info, environment, application_name, metrics,
+ capture_message_content, disable_metrics, version, is_stream=True)
def process_chat_response(response, request_model, pricing_info, server_port, server_address,
- environment, application_name, metrics, event_provider, start_time,
- span, capture_message_content=False, disable_metrics=False, version='1.0.0', **kwargs):
+ environment, application_name, metrics, start_time,
+ span, capture_message_content=False, disable_metrics=False, version="1.0.0", **kwargs):
"""
- Process chat request and generate Telemetry
+ Process non-streaming chat response and generate telemetry.
"""
- self = type('GenericScope', (), {})()
+ scope = type("GenericScope", (), {})()
response_dict = response_as_dict(response)
# pylint: disable = no-member
- self._start_time = start_time
- self._end_time = time.time()
- self._span = span
- self._llmresponse = response_dict.get('content', {})[0].get('text', '')
- self._response_role = response_dict.get('message', {}).get('role', 'assistant')
- self._input_tokens = response_dict.get('usage').get('input_tokens')
- self._output_tokens = response_dict.get('usage').get('output_tokens')
- self._response_model = response_dict.get('model', '')
- self._finish_reason = response_dict.get('stop_reason', '')
- self._response_id = response_dict.get('id', '')
- self._timestamps = []
- self._ttft, self._tbt = self._end_time - self._start_time, 0
- self._server_address, self._server_port = server_address, server_port
- self._kwargs = kwargs
- #pylint: disable=line-too-long
- self._tool_calls = (lambda c: c[1] if len(c) > 1 and c[1].get('type') == 'tool_use' else None)(response_dict.get('content', []))
-
- common_chat_logic(self, pricing_info, environment, application_name, metrics,
- event_provider, capture_message_content, disable_metrics, version, is_stream=False)
+ scope._start_time = start_time
+ scope._end_time = time.time()
+ scope._span = span
+ scope._llmresponse = response_dict.get("content", [{}])[0].get("text", "")
+ scope._response_role = response_dict.get("role", "assistant")
+ scope._input_tokens = response_dict.get("usage").get("input_tokens")
+ scope._output_tokens = response_dict.get("usage").get("output_tokens")
+ scope._response_model = response_dict.get("model", "")
+ scope._finish_reason = response_dict.get("stop_reason", "")
+ scope._response_id = response_dict.get("id", "")
+ scope._timestamps = []
+ scope._ttft, scope._tbt = scope._end_time - scope._start_time, 0
+ scope._server_address, scope._server_port = server_address, server_port
+ scope._kwargs = kwargs
+
+ # Handle tool calls if present
+ content_blocks = response_dict.get("content", [])
+ scope._tool_calls = None
+ for block in content_blocks:
+ if block.get("type") == "tool_use":
+ scope._tool_calls = {
+ "id": block.get("id", ""),
+ "name": block.get("name", ""),
+ "input": block.get("input", "")
+ }
+ break
+
+ common_chat_logic(scope, pricing_info, environment, application_name, metrics,
+ capture_message_content, disable_metrics, version, is_stream=False)
return response