Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
[Feat]: Refactor AG2 OpenTelemetry Monitoring Instrumentation (#793)
Patcher4dcd74c65cee
diff --git a/.github/workflows/python-tests.yml b/.github/workflows/python-tests.ymlindex cc965a0d..831e14d7 100644--- a/.github/workflows/python-tests.yml+++ b/.github/workflows/python-tests.yml@@ -45,7 +45,7 @@ jobs:strategy:fail-fast: falsematrix:- python-version: ["3.10", "3.11", "3.12"]+ python-version: ["3.11", "3.12"]steps:- name: Checkout base codediff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.tomlindex abcfbaef..2df00ada 100644--- a/sdk/python/pyproject.toml+++ b/sdk/python/pyproject.toml@@ -1,6 +1,6 @@[tool.poetry]name = "openlit"-version = "1.34.22"+version = "1.34.23"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/ag2/__init__.py b/sdk/python/src/openlit/instrumentation/ag2/__init__.pyindex b6dbccc0..32d295b3 100644--- a/sdk/python/src/openlit/instrumentation/ag2/__init__.py+++ b/sdk/python/src/openlit/instrumentation/ag2/__init__.py@@ -8,40 +8,44 @@ from wrapt import wrap_function_wrapperfrom openlit.instrumentation.ag2.ag2 import (conversable_agent, agent_run)+from openlit.instrumentation.ag2.async_ag2 import (+ async_conversable_agent, async_agent_run+)-_instruments = ('ag2 >= 0.3.2',)+_instruments = ("ag2 >= 0.3.2",)class AG2Instrumentor(BaseInstrumentor):"""- An instrumentor for AG2's client library.+ An instrumentor for AG2 client library."""def instrumentation_dependencies(self) -> Collection[str]:return _instrumentsdef _instrument(self, **kwargs):- application_name = kwargs.get('application_name', 'default_application')- environment = kwargs.get('environment', 'default_environment')- tracer = kwargs.get('tracer')- event_provider = kwargs.get('event_provider')- metrics = kwargs.get('metrics_dict')- pricing_info = kwargs.get('pricing_info', {})- capture_message_content = kwargs.get('capture_message_content', False)- disable_metrics = kwargs.get('disable_metrics')- version = importlib.metadata.version('ag2')-+ version = importlib.metadata.version("ag2")+ 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 conversable agentwrap_function_wrapper(- 'autogen.agentchat.conversable_agent',- 'ConversableAgent.__init__',+ "autogen.agentchat.conversable_agent",+ "ConversableAgent.__init__",conversable_agent(version, environment, application_name,- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),+ tracer, pricing_info, capture_message_content, metrics, disable_metrics),)+ # sync agent runwrap_function_wrapper(- 'autogen.agentchat.conversable_agent',- 'ConversableAgent.run',+ "autogen.agentchat.conversable_agent",+ "ConversableAgent.run",agent_run(version, environment, application_name,- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics),+ tracer, pricing_info, capture_message_content, metrics, disable_metrics),)def _uninstrument(self, **kwargs):diff --git a/sdk/python/src/openlit/instrumentation/ag2/ag2.py b/sdk/python/src/openlit/instrumentation/ag2/ag2.pyindex 29dbff6c..db36a3a6 100644--- a/sdk/python/src/openlit/instrumentation/ag2/ag2.py+++ b/sdk/python/src/openlit/instrumentation/ag2/ag2.py@@ -2,162 +2,113 @@Module for monitoring AG2 API calls."""-import loggingimport time-from opentelemetry.trace import SpanKind, Status, StatusCode-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT+from opentelemetry.trace import SpanKindfrom openlit.__helpers import (handle_exception,- get_chat_model_cost,- otel_event,+ set_server_address_and_port+)+from openlit.instrumentation.ag2.utils import (+ process_agent_creation,+ process_agent_run,)from openlit.semcov import SemanticConvention-# Initialize logger for logging potential issues and operations-logger = logging.getLogger(__name__)--AGENT_NAME = ''-REQUEST_MODEL = ''-SYSTEM_MESSAGE = ''-MODEL_AND_NAME_SET = False--def set_span_attributes(span, version, operation_name, environment,- application_name, server_address, server_port, request_model):- """- Set common attributes for the span.- """-- # Set Span attributes (OTel Semconv)- span.set_attribute(TELEMETRY_SDK_NAME, 'openlit')- 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(SemanticConvention.GEN_AI_SDK_VERSION, version)--def calculate_tokens_and_cost(response, request_model, pricing_info):+def conversable_agent(version, environment, application_name, tracer, pricing_info,+ capture_message_content, metrics, disable_metrics):"""- Calculate the input, output tokens, and their respective costs.+ Generates a telemetry wrapper for AG2 conversable agent creation."""- input_tokens = 0- output_tokens = 0- for usage_data in response.cost.values():- if isinstance(usage_data, dict):- for model_data in usage_data.values():- if isinstance(model_data, dict):- input_tokens += model_data.get('prompt_tokens', 0)- output_tokens += model_data.get('completion_tokens', 0)-- cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)- return input_tokens, output_tokens, cost--def emit_events(response, event_provider, capture_message_content):- """- Emit OpenTelemetry events for each chat history entry.- """- for chat in response.chat_history:- event_type = (- SemanticConvention.GEN_AI_CHOICE if chat['role'] == 'user'- else SemanticConvention.GEN_AI_USER_MESSAGE- )- choice_event = otel_event(- name=event_type,- attributes={- SemanticConvention.GEN_AI_SYSTEM: SemanticConvention.GEN_AI_SYSTEM_AG2- },- body={- 'index': response.chat_history.index(chat),- 'message': {- **({'content': chat['content']} if capture_message_content else {}),- 'role': 'assistant' if chat['role'] == 'user' else 'user'- }- }- )- event_provider.emit(choice_event)--def conversable_agent(version, environment, application_name,- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics):- """- Generates a telemetry wrapper for GenAI function call- """def wrapper(wrapped, instance, args, kwargs):- server_address, server_port = '127.0.0.1', 80- global AGENT_NAME, MODEL_AND_NAME_SET, REQUEST_MODEL, SYSTEM_MESSAGE+ """+ Wraps the AG2 conversable agent creation call.+ """- if not MODEL_AND_NAME_SET:- AGENT_NAME = kwargs.get('name', 'NOT_FOUND')- REQUEST_MODEL = kwargs.get('llm_config', {}).get('model', 'gpt-4o')- SYSTEM_MESSAGE = kwargs.get('system_message', '')- MODEL_AND_NAME_SET = True+ server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 80)+ agent_name = kwargs.get("name", "NOT_FOUND")+ llm_config = kwargs.get("llm_config", {})+ system_message = kwargs.get("system_message", "")- span_name = f'{SemanticConvention.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:- start_time = time.time()- response = wrapped(*args, **kwargs)- end_time = time.time()-- set_span_attributes(span, version, SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT,- environment, application_name, server_address, server_port, REQUEST_MODEL)- 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))+ start_time = time.time()+ response = wrapped(*args, **kwargs)- return response+ try:+ process_agent_creation(+ agent_name=agent_name,+ llm_config=llm_config,+ system_message=system_message,+ 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+ )except Exception as e:handle_exception(span, e)- logger.error('Error in trace creation: %s', e)- return response++ return responsereturn wrapper-def agent_run(version, environment, application_name,- tracer, event_provider, pricing_info, capture_message_content, metrics, disable_metrics):+def agent_run(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 AG2 agent run execution."""+def wrapper(wrapped, instance, args, kwargs):- server_address, server_port = '127.0.0.1', 80+ """+ Wraps the AG2 agent run execution call.+ """- span_name = f'{SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {AGENT_NAME}'+ server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 80)- with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:- try:- start_time = time.time()- response = wrapped(*args, **kwargs)- end_time = time.time()+ # Extract agent name from instance+ agent_name = getattr(instance, "name", "NOT_FOUND")- 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]+ # Extract model from instance llm_config+ request_model = "gpt-4o"+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):+ request_model = instance.llm_config.get("model", "gpt-4o")- 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(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)+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {agent_name}"- emit_events(response, event_provider, capture_message_content)- span.set_status(Status(StatusCode.OK))+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ response = wrapped(*args, **kwargs)- return response+ try:+ response = process_agent_run(+ response=response,+ agent_name=agent_name,+ 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+ )except Exception as e:handle_exception(span, e)- logger.error('Error in trace creation: %s', e)- return response++ return responsereturn wrapperdiff --git a/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py b/sdk/python/src/openlit/instrumentation/ag2/async_ag2.pynew file mode 100644index 00000000..81058e7a--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py@@ -0,0 +1,114 @@+"""+Module for monitoring AG2 API calls (async version).+"""++import time+from opentelemetry.trace import SpanKind+from openlit.__helpers import (+ handle_exception,+ set_server_address_and_port+)+from openlit.instrumentation.ag2.utils import (+ process_agent_creation,+ process_agent_run,+)+from openlit.semcov import SemanticConvention++def async_conversable_agent(version, environment, application_name, tracer, pricing_info,+ capture_message_content, metrics, disable_metrics):+ """+ Generates a telemetry wrapper for AG2 async conversable agent creation.+ """++ async def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the AG2 async conversable agent creation call.+ """++ server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 80)+ agent_name = kwargs.get("name", "NOT_FOUND")+ llm_config = kwargs.get("llm_config", {})+ system_message = kwargs.get("system_message", "")++ 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:+ start_time = time.time()+ response = await wrapped(*args, **kwargs)++ try:+ process_agent_creation(+ agent_name=agent_name,+ llm_config=llm_config,+ system_message=system_message,+ 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+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapper++def async_agent_run(version, environment, application_name, tracer, pricing_info,+ capture_message_content, metrics, disable_metrics):+ """+ Generates a telemetry wrapper for AG2 async agent run execution.+ """++ async def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the AG2 async agent run execution call.+ """++ server_address, server_port = set_server_address_and_port(instance, "127.0.0.1", 80)++ # Extract agent name from instance+ agent_name = getattr(instance, "name", "NOT_FOUND")++ # Extract model from instance llm_config+ request_model = "gpt-4o"+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):+ request_model = instance.llm_config.get("model", "gpt-4o")++ 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:+ start_time = time.time()+ response = await wrapped(*args, **kwargs)++ try:+ response = process_agent_run(+ response=response,+ agent_name=agent_name,+ 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+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/ag2/utils.py b/sdk/python/src/openlit/instrumentation/ag2/utils.pynew file mode 100644index 00000000..4e7c0b0d--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/ag2/utils.py@@ -0,0 +1,175 @@+"""+AG2 OpenTelemetry instrumentation utility functions+"""+import time++from opentelemetry.trace import Status, StatusCode++from openlit.__helpers import (+ get_chat_model_cost,+ common_span_attributes,+ record_completion_metrics,+)+from openlit.semcov import SemanticConvention++def calculate_tokens_and_cost(response, request_model, pricing_info):+ """+ Calculate the input, output tokens, and their respective costs from AG2 response.+ """+ input_tokens = 0+ output_tokens = 0++ # Early return if response doesn't have cost data+ if not hasattr(response, "cost") or response.cost is None:+ cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)+ return input_tokens, output_tokens, cost++ try:+ input_tokens, output_tokens = _extract_tokens_from_cost(response.cost)+ except (AttributeError, TypeError):+ # If theres any issue accessing cost data, default to 0 tokens+ input_tokens = 0+ output_tokens = 0++ cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)+ return input_tokens, output_tokens, cost++def _extract_tokens_from_cost(cost_data):+ """+ Extract input and output tokens from AG2 cost data structure.+ """+ input_tokens = 0+ output_tokens = 0++ for usage_data in cost_data.values():+ if not isinstance(usage_data, dict):+ continue++ for model_data in usage_data.values():+ if isinstance(model_data, dict):+ input_tokens += model_data.get("prompt_tokens", 0)+ output_tokens += model_data.get("completion_tokens", 0)++ return input_tokens, output_tokens++def format_content(chat_history):+ """+ Format the chat history into a string for span events.+ """+ if not chat_history:+ return ""++ formatted_messages = []+ for chat in chat_history:+ role = chat.get("role", "user")+ content = chat.get("content", "")+ formatted_messages.append(f"{role}: {content}")++ return "\n".join(formatted_messages)++def common_agent_logic(scope, pricing_info, environment, application_name, metrics,+ capture_message_content, disable_metrics, version, operation_type):+ """+ Process agent request and generate Telemetry+ """++ # Common Span Attributes+ common_span_attributes(scope,+ operation_type, SemanticConvention.GEN_AI_SYSTEM_AG2,+ scope._server_address, scope._server_port, scope._request_model, scope._response_model,+ environment, application_name, False, 0, scope._end_time - scope._start_time, version)++ # Span Attributes for Agent-specific parameters+ scope._span.set_attribute(SemanticConvention.GEN_AI_AGENT_NAME, scope._agent_name)++ # Span Attributes for Response parameters+ if hasattr(scope, "_input_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.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens + scope._output_tokens)+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, scope._cost)++ # Span Attributes for Content+ if capture_message_content and hasattr(scope, "_chat_history"):+ chat_content = format_content(scope._chat_history)+ scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, chat_content)++ # To be removed once the change to span_attributes (from span events) is complete+ scope._span.add_event(+ name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,+ attributes={+ SemanticConvention.GEN_AI_CONTENT_COMPLETION: chat_content,+ },+ )++ # Set agent description for create agent operation+ if hasattr(scope, "_system_message"):+ scope._span.set_attribute(SemanticConvention.GEN_AI_AGENT_DESCRIPTION, scope._system_message)++ scope._span.set_status(Status(StatusCode.OK))++ # Metrics+ if not disable_metrics and hasattr(scope, "_input_tokens"):+ record_completion_metrics(metrics, operation_type, SemanticConvention.GEN_AI_SYSTEM_AG2,+ scope._server_address, scope._server_port, scope._request_model, scope._response_model, environment,+ application_name, scope._start_time, scope._end_time, scope._input_tokens, scope._output_tokens,+ scope._cost, 0, scope._end_time - scope._start_time)++def process_agent_creation(agent_name, llm_config, system_message, pricing_info, server_port, server_address,+ environment, application_name, metrics, start_time, span, capture_message_content=False,+ disable_metrics=False, version="1.0.0", **kwargs):+ """+ Process agent creation and generate Telemetry+ """++ # Create scope object+ scope = type("GenericScope", (), {})()++ scope._start_time = start_time+ scope._end_time = time.time()+ scope._span = span+ scope._agent_name = agent_name+ scope._request_model = llm_config.get("model", "gpt-4o")+ scope._response_model = scope._request_model+ scope._system_message = system_message+ scope._server_address, scope._server_port = server_address, server_port++ common_agent_logic(scope, pricing_info, environment, application_name, metrics,+ capture_message_content, disable_metrics, version, SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT)++def process_agent_run(response, agent_name, request_model, pricing_info, server_port, server_address,+ environment, application_name, metrics, start_time, span, capture_message_content=False,+ disable_metrics=False, version="1.0.0", **kwargs):+ """+ Process agent run and generate Telemetry+ """++ # Create scope object+ scope = type("GenericScope", (), {})()++ scope._start_time = start_time+ scope._end_time = time.time()+ scope._span = span+ scope._agent_name = agent_name+ scope._request_model = request_model+ scope._chat_history = getattr(response, "chat_history", [])+ scope._server_address, scope._server_port = server_address, server_port++ # Calculate tokens and cost+ scope._input_tokens, scope._output_tokens, scope._cost = calculate_tokens_and_cost(+ response, request_model, pricing_info)++ # Extract response model from cost data+ try:+ if hasattr(response, "cost") and response.cost is not None:+ cost_data = response.cost.get("usage_including_cached_inference", {})+ scope._response_model = list(cost_data.keys())[1] if len(cost_data) > 1 else request_model+ else:+ scope._response_model = request_model+ except (AttributeError, IndexError, KeyError, TypeError):+ scope._response_model = request_model++ common_agent_logic(scope, pricing_info, environment, application_name, metrics,+ capture_message_content, disable_metrics, version, SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK)++ return response