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 AG2 OpenTelemetry Monitoring Instrumentation (#811)

Patcherc2eda51ecf56
diff --git a/sdk/python/.pylintrc b/sdk/python/.pylintrc
index 61ab3967..f5cffa4f 100644
--- a/sdk/python/.pylintrc
+++ b/sdk/python/.pylintrc
@@ -7,7 +7,7 @@ max-locals=30
max-args=25
# Maximum number of positional arguments (see R0917).
-max-positional-arguments=16
+max-positional-arguments=20
# Maximum allowed line length
max-line-length=135
diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.toml
index bcfebd18..65001f3f 100644
--- a/sdk/python/pyproject.toml
+++ b/sdk/python/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "openlit"
-version = "1.34.31"
+version = "1.34.32"
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/__init__.py b/sdk/python/src/openlit/__init__.py
index 18b28050..1a509785 100644
--- a/sdk/python/src/openlit/__init__.py
+++ b/sdk/python/src/openlit/__init__.py
@@ -268,7 +268,9 @@ def init(
logger.error(
"OpenLIT metrics setup failed. Metrics will not be available: %s", err
)
- return
+ # Set metrics_dict to None and disable metrics instead of returning early
+ metrics_dict = None
+ disable_metrics = True
if (
os.getenv("OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT", "").lower
diff --git a/sdk/python/src/openlit/instrumentation/ag2/__init__.py b/sdk/python/src/openlit/instrumentation/ag2/__init__.py
index f2f7aa4d..80267054 100644
--- a/sdk/python/src/openlit/instrumentation/ag2/__init__.py
+++ b/sdk/python/src/openlit/instrumentation/ag2/__init__.py
@@ -5,10 +5,21 @@ import importlib.metadata
from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
from wrapt import wrap_function_wrapper
-from openlit.instrumentation.ag2.ag2 import conversable_agent, agent_run
+from openlit.instrumentation.ag2.ag2 import (
+ conversable_agent,
+ agent_run,
+ agent_generate_reply,
+ agent_receive,
+ agent_send,
+ groupchat_manager_run_chat,
+ groupchat_select_speaker,
+)
from openlit.instrumentation.ag2.async_ag2 import (
async_conversable_agent,
async_agent_run,
+ async_agent_generate_reply,
+ async_agent_receive,
+ async_agent_send,
)
_instruments = ("ag2 >= 0.3.2",)
@@ -64,6 +75,86 @@ class AG2Instrumentor(BaseInstrumentor):
),
)
+ # sync agent generate_reply
+ wrap_function_wrapper(
+ "autogen.agentchat.conversable_agent",
+ "ConversableAgent.generate_reply",
+ agent_generate_reply(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+ ),
+ )
+
+ # sync agent receive
+ wrap_function_wrapper(
+ "autogen.agentchat.conversable_agent",
+ "ConversableAgent.receive",
+ agent_receive(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+ ),
+ )
+
+ # sync agent send
+ wrap_function_wrapper(
+ "autogen.agentchat.conversable_agent",
+ "ConversableAgent.send",
+ agent_send(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+ ),
+ )
+
+ # sync groupchat manager run_chat
+ wrap_function_wrapper(
+ "autogen.agentchat.groupchat",
+ "GroupChatManager.run_chat",
+ groupchat_manager_run_chat(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+ ),
+ )
+
+ # sync groupchat select_speaker
+ wrap_function_wrapper(
+ "autogen.agentchat.groupchat",
+ "GroupChat.select_speaker",
+ groupchat_select_speaker(
+ 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/ag2/ag2.py b/sdk/python/src/openlit/instrumentation/ag2/ag2.py
index 6dc03ca7..7528e86f 100644
--- a/sdk/python/src/openlit/instrumentation/ag2/ag2.py
+++ b/sdk/python/src/openlit/instrumentation/ag2/ag2.py
@@ -8,10 +8,45 @@ from openlit.__helpers import handle_exception, set_server_address_and_port
from openlit.instrumentation.ag2.utils import (
process_agent_creation,
process_agent_run,
+ process_agent_generate_reply,
+ process_agent_receive,
+ process_agent_send,
+ process_groupchat_operation,
+ process_speaker_selection,
)
from openlit.semcov import SemanticConvention
+def extract_agent_name(instance, fallback="unknown_agent"):
+ """
+ Extract agent name from AG2 instance with intelligent fallbacks.
+
+ Args:
+ instance: AG2 instance (Agent, GroupChat, etc.)
+ fallback: Default name if no name can be extracted
+
+ Returns:
+ str: Agent name or meaningful fallback
+ """
+ # Try to get the name attribute first
+ agent_name = getattr(instance, "name", None)
+ if agent_name:
+ return agent_name
+
+ # Try to get from class name and make it meaningful
+ class_name = getattr(instance, "__class__", type(instance)).__name__.lower()
+
+ # Map common AG2 class names to meaningful names
+ class_name_map = {
+ "conversableagent": "conversable_agent",
+ "groupchat": "group_chat",
+ "groupchatmanager": "group_chat_manager",
+ "agent": "agent",
+ }
+
+ return class_name_map.get(class_name, fallback)
+
+
def conversable_agent(
version,
environment,
@@ -34,7 +69,7 @@ def conversable_agent(
server_address, server_port = set_server_address_and_port(
instance, "127.0.0.1", 80
)
- agent_name = kwargs.get("name", "NOT_FOUND")
+ agent_name = kwargs.get("name", "unknown_agent")
llm_config = kwargs.get("llm_config", {})
system_message = kwargs.get("system_message", "")
@@ -96,12 +131,12 @@ def agent_run(
)
# Extract agent name from instance
- agent_name = getattr(instance, "name", "NOT_FOUND")
+ agent_name = extract_agent_name(instance)
# Extract model from instance llm_config
- request_model = "gpt-4o"
+ request_model = "unknown"
if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
- request_model = instance.llm_config.get("model", "gpt-4o")
+ request_model = instance.llm_config.get("model", "unknown")
span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {agent_name}"
@@ -133,3 +168,389 @@ def agent_run(
return response
return wrapper
+
+
+def agent_generate_reply(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.generate_reply.
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.generate_reply call.
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract model from instance llm_config
+ request_model = "unknown"
+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
+ request_model = instance.llm_config.get("model", "unknown")
+
+ 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 = wrapped(*args, **kwargs)
+
+ try:
+ response = process_agent_generate_reply(
+ response=response,
+ agent_name=agent_name,
+ request_model=request_model,
+ messages=args[0] if args else kwargs.get("messages", []),
+ sender=args[1] if len(args) > 1 else kwargs.get("sender", None),
+ 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 agent_receive(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.receive.
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.receive call.
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract sender information
+ sender = args[0] if args else kwargs.get("sender", None)
+ sender_name = getattr(sender, "name", "Unknown") if sender else "Unknown"
+
+ # Extract message
+ message = args[1] if len(args) > 1 else kwargs.get("message", "")
+
+ 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 = wrapped(*args, **kwargs)
+
+ try:
+ process_agent_receive(
+ message=message,
+ agent_name=agent_name,
+ sender_name=sender_name,
+ agent_instance=instance,
+ 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 agent_send(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.send.
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.send call.
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract recipient information
+ recipient = args[0] if args else kwargs.get("recipient", None)
+ recipient_name = (
+ getattr(recipient, "name", "Unknown") if recipient else "Unknown"
+ )
+
+ # Extract message
+ message = args[1] if len(args) > 1 else kwargs.get("message", "")
+
+ 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 = wrapped(*args, **kwargs)
+
+ try:
+ process_agent_send(
+ message=message,
+ agent_name=agent_name,
+ recipient_name=recipient_name,
+ agent_instance=instance,
+ 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 groupchat_manager_run_chat(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 GroupChatManager.run_chat.
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 GroupChatManager.run_chat call.
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract groupchat information
+ groupchat = getattr(instance, "groupchat", None)
+ if groupchat:
+ participants = [agent.name for agent in groupchat.agents]
+ group_name = f"GroupChat_{len(participants)}_agents"
+ else:
+ participants = []
+ group_name = "UnknownGroupChat"
+
+ # Extract model information from GroupChatManager
+ request_model = "unknown" # Default fallback
+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
+ request_model = instance.llm_config.get("model", "unknown")
+
+ # Try to get more specific model from groupchat
+ if groupchat and hasattr(groupchat, "select_speaker_auto_llm_config"):
+ llm_config = groupchat.select_speaker_auto_llm_config
+ if isinstance(llm_config, dict):
+ request_model = llm_config.get("model", request_model)
+ elif hasattr(llm_config, "model"):
+ request_model = llm_config.model
+
+ # Extract sender information
+ sender = kwargs.get("sender", None)
+
+ # Extract messages
+ messages = args[0] if args else kwargs.get("messages", [])
+
+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK} {group_name}"
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = wrapped(*args, **kwargs)
+
+ try:
+ process_groupchat_operation(
+ group_name=group_name,
+ participants=participants,
+ messages=messages,
+ sender=sender,
+ max_turns=None, # Not available in new API
+ 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 wrapper
+
+
+def groupchat_select_speaker(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 GroupChat.select_speaker.
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 GroupChat.select_speaker call.
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract speaker information
+ last_speaker = args[0] if args else kwargs.get("last_speaker", None)
+ selector = args[1] if len(args) > 1 else kwargs.get("selector", None)
+
+ last_speaker_name = (
+ getattr(last_speaker, "name", "Unknown") if last_speaker else "Unknown"
+ )
+
+ # Extract agents list
+ agents = getattr(instance, "agents", [])
+
+ # Extract model information from GroupChat instance
+ request_model = "unknown" # Default fallback
+ # Check for speaker selection specific config
+ if hasattr(instance, "select_speaker_auto_llm_config"):
+ llm_config = instance.select_speaker_auto_llm_config
+ if isinstance(llm_config, dict):
+ request_model = llm_config.get("model", "unknown")
+ elif hasattr(llm_config, "model"):
+ request_model = llm_config.model
+
+ # Try to get model from selector if available
+ if (
+ selector
+ and hasattr(selector, "llm_config")
+ and isinstance(selector.llm_config, dict)
+ ):
+ request_model = selector.llm_config.get("model", request_model)
+
+ # Try to get model from agents if still unknown
+ if request_model == "unknown" and agents:
+ for agent in agents:
+ if hasattr(agent, "llm_config") and isinstance(agent.llm_config, dict):
+ model = agent.llm_config.get("model")
+ if model:
+ request_model = model
+ break
+
+ span_name = (
+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT} speaker_selection"
+ )
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = wrapped(*args, **kwargs)
+
+ try:
+ selected_speaker_name = (
+ getattr(response, "name", "Unknown") if response else "Unknown"
+ )
+
+ process_speaker_selection(
+ last_speaker=last_speaker_name,
+ selected_speaker=selected_speaker_name,
+ selector=selector,
+ agents=agents,
+ 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 wrapper
diff --git a/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py b/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py
index 3f25bc78..7ba155d5 100644
--- a/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py
+++ b/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py
@@ -8,10 +8,45 @@ from openlit.__helpers import handle_exception, set_server_address_and_port
from openlit.instrumentation.ag2.utils import (
process_agent_creation,
process_agent_run,
+ process_agent_generate_reply,
+ process_agent_receive,
+ process_agent_send,
+ process_groupchat_operation,
+ process_speaker_selection,
)
from openlit.semcov import SemanticConvention
+def extract_agent_name(instance, fallback="unknown_agent"):
+ """
+ Extract agent name from AG2 instance with intelligent fallbacks.
+
+ Args:
+ instance: AG2 instance (Agent, GroupChat, etc.)
+ fallback: Default name if no name can be extracted
+
+ Returns:
+ str: Agent name or meaningful fallback
+ """
+ # Try to get the name attribute first
+ agent_name = getattr(instance, "name", None)
+ if agent_name:
+ return agent_name
+
+ # Try to get from class name and make it meaningful
+ class_name = getattr(instance, "__class__", type(instance)).__name__.lower()
+
+ # Map common AG2 class names to meaningful names
+ class_name_map = {
+ "conversableagent": "conversable_agent",
+ "groupchat": "group_chat",
+ "groupchatmanager": "group_chat_manager",
+ "agent": "agent",
+ }
+
+ return class_name_map.get(class_name, fallback)
+
+
def async_conversable_agent(
version,
environment,
@@ -34,7 +69,7 @@ def async_conversable_agent(
server_address, server_port = set_server_address_and_port(
instance, "127.0.0.1", 80
)
- agent_name = kwargs.get("name", "NOT_FOUND")
+ agent_name = kwargs.get("name", "unknown_agent")
llm_config = kwargs.get("llm_config", {})
system_message = kwargs.get("system_message", "")
@@ -96,12 +131,12 @@ def async_agent_run(
)
# Extract agent name from instance
- agent_name = getattr(instance, "name", "NOT_FOUND")
+ agent_name = extract_agent_name(instance)
# Extract model from instance llm_config
- request_model = "gpt-4o"
+ request_model = "unknown"
if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
- request_model = instance.llm_config.get("model", "gpt-4o")
+ request_model = instance.llm_config.get("model", "unknown")
span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_EXECUTE_AGENT_TASK} {agent_name}"
@@ -133,3 +168,389 @@ def async_agent_run(
return response
return wrapper
+
+
+def async_agent_generate_reply(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.generate_reply (async version).
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.generate_reply call (async version).
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract model from instance llm_config
+ request_model = "unknown"
+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
+ request_model = instance.llm_config.get("model", "unknown")
+
+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {agent_name}"
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = wrapped(*args, **kwargs)
+
+ try:
+ response = process_agent_generate_reply(
+ response=response,
+ agent_name=agent_name,
+ request_model=request_model,
+ messages=args[0] if args else kwargs.get("messages", []),
+ sender=args[1] if len(args) > 1 else kwargs.get("sender", None),
+ 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_receive(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.receive (async version).
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.receive call (async version).
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract sender information
+ sender = args[0] if args else kwargs.get("sender", None)
+ sender_name = getattr(sender, "name", "Unknown") if sender else "Unknown"
+
+ # Extract message
+ message = args[1] if len(args) > 1 else kwargs.get("message", "")
+
+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {agent_name}"
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = wrapped(*args, **kwargs)
+
+ try:
+ process_agent_receive(
+ message=message,
+ agent_name=agent_name,
+ sender_name=sender_name,
+ agent_instance=instance,
+ 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_send(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 ConversableAgent.send (async version).
+ """
+
+ def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 ConversableAgent.send call (async version).
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract agent name from instance
+ agent_name = extract_agent_name(instance)
+
+ # Extract recipient information
+ recipient = args[0] if args else kwargs.get("recipient", None)
+ recipient_name = (
+ getattr(recipient, "name", "Unknown") if recipient else "Unknown"
+ )
+
+ # Extract message
+ message = args[1] if len(args) > 1 else kwargs.get("message", "")
+
+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {agent_name}"
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = wrapped(*args, **kwargs)
+
+ try:
+ process_agent_send(
+ message=message,
+ agent_name=agent_name,
+ recipient_name=recipient_name,
+ agent_instance=instance,
+ 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_groupchat_manager_run_chat(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 GroupChatManager.run_chat (async version).
+ """
+
+ async def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 GroupChatManager.run_chat call (async version).
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract groupchat information
+ groupchat = getattr(instance, "groupchat", None)
+ if groupchat:
+ participants = [agent.name for agent in groupchat.agents]
+ group_name = f"GroupChat_{len(participants)}_agents"
+ else:
+ participants = []
+ group_name = "UnknownGroupChat"
+
+ # Extract model information from GroupChatManager
+ request_model = "unknown" # Default fallback
+ if hasattr(instance, "llm_config") and isinstance(instance.llm_config, dict):
+ request_model = instance.llm_config.get("model", "unknown")
+
+ # Try to get more specific model from groupchat
+ if groupchat and hasattr(groupchat, "select_speaker_auto_llm_config"):
+ llm_config = groupchat.select_speaker_auto_llm_config
+ if isinstance(llm_config, dict):
+ request_model = llm_config.get("model", request_model)
+ elif hasattr(llm_config, "model"):
+ request_model = llm_config.model
+
+ # Extract sender information
+ sender = kwargs.get("sender", None)
+
+ # Extract messages
+ messages = args[0] if args else kwargs.get("messages", [])
+
+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK} {group_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_groupchat_operation(
+ group_name=group_name,
+ participants=participants,
+ messages=messages,
+ sender=sender,
+ max_turns=None, # Not available in new API
+ 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 wrapper
+
+
+def async_groupchat_select_speaker(
+ version,
+ environment,
+ application_name,
+ tracer,
+ pricing_info,
+ capture_message_content,
+ metrics,
+ disable_metrics,
+):
+ """
+ Generates a telemetry wrapper for AG2 GroupChat.select_speaker (async version).
+ """
+
+ async def wrapper(wrapped, instance, args, kwargs):
+ """
+ Wraps the AG2 GroupChat.select_speaker call (async version).
+ """
+
+ server_address, server_port = set_server_address_and_port(
+ instance, "127.0.0.1", 80
+ )
+
+ # Extract speaker information
+ last_speaker = args[0] if args else kwargs.get("last_speaker", None)
+ selector = args[1] if len(args) > 1 else kwargs.get("selector", None)
+
+ last_speaker_name = (
+ getattr(last_speaker, "name", "Unknown") if last_speaker else "Unknown"
+ )
+
+ # Extract agents list
+ agents = getattr(instance, "agents", [])
+
+ # Extract model information from GroupChat instance
+ request_model = "unknown" # Default fallback
+ # Check for speaker selection specific config
+ if hasattr(instance, "select_speaker_auto_llm_config"):
+ llm_config = instance.select_speaker_auto_llm_config
+ if isinstance(llm_config, dict):
+ request_model = llm_config.get("model", "unknown")
+ elif hasattr(llm_config, "model"):
+ request_model = llm_config.model
+
+ # Try to get model from selector if available
+ if (
+ selector
+ and hasattr(selector, "llm_config")
+ and isinstance(selector.llm_config, dict)
+ ):
+ request_model = selector.llm_config.get("model", request_model)
+
+ # Try to get model from agents if still unknown
+ if request_model == "unknown" and agents:
+ for agent in agents:
+ if hasattr(agent, "llm_config") and isinstance(agent.llm_config, dict):
+ model = agent.llm_config.get("model")
+ if model:
+ request_model = model
+ break
+
+ span_name = (
+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT} speaker_selection"
+ )
+
+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+ start_time = time.time()
+ response = await wrapped(*args, **kwargs)
+
+ try:
+ selected_speaker_name = (
+ getattr(response, "name", "Unknown") if response else "Unknown"
+ )
+
+ process_speaker_selection(
+ last_speaker=last_speaker_name,
+ selected_speaker=selected_speaker_name,
+ selector=selector,
+ agents=agents,
+ 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 wrapper
diff --git a/sdk/python/src/openlit/instrumentation/ag2/utils.py b/sdk/python/src/openlit/instrumentation/ag2/utils.py
index 9fdb4571..e1adefcb 100644
--- a/sdk/python/src/openlit/instrumentation/ag2/utils.py
+++ b/sdk/python/src/openlit/instrumentation/ag2/utils.py
@@ -147,7 +147,7 @@ def common_agent_logic(
scope._span.set_status(Status(StatusCode.OK))
# Metrics
- if not disable_metrics and hasattr(scope, "_input_tokens"):
+ if not disable_metrics and metrics is not None and hasattr(scope, "_input_tokens"):
record_completion_metrics(
metrics,
operation_type,
@@ -196,7 +196,7 @@ def process_agent_creation(
scope._end_time = time.time()
scope._span = span
scope._agent_name = agent_name
- scope._request_model = llm_config.get("model", "gpt-4o")
+ scope._request_model = llm_config.get("model", "unknown")
scope._response_model = scope._request_model
scope._system_message = system_message
scope._server_address, scope._server_port = server_address, server_port
@@ -276,3 +276,344 @@ def process_agent_run(
)
return response
+
+
+def process_agent_generate_reply(
+ response,
+ agent_name,
+ request_model,
+ messages,
+ sender,
+ 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 generate_reply 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._response_model = request_model
+ scope._server_address, scope._server_port = server_address, server_port
+ scope._messages = messages
+ scope._sender_name = getattr(sender, "name", "Unknown") if sender else "Unknown"
+
+ # Set agent-specific attributes
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_MESSAGE_TYPE, "generate_reply")
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_SENDER, scope._sender_name)
+
+ # Process response content
+ if response and isinstance(response, str):
+ scope._response_content = response
+ elif response and hasattr(response, "content"):
+ scope._response_content = response.content
+ else:
+ scope._response_content = str(response) if response else ""
+
+ # Try to extract token information if available
+ try:
+ # Mock token calculation for generate_reply
+ scope._input_tokens = len(str(messages)) // 4 if messages else 0
+ scope._output_tokens = len(scope._response_content) // 4
+ scope._cost = get_chat_model_cost(
+ request_model, pricing_info, scope._input_tokens, scope._output_tokens
+ )
+ except Exception:
+ scope._input_tokens = 0
+ scope._output_tokens = 0
+ scope._cost = 0.0
+
+ common_agent_logic(
+ scope,
+ pricing_info,
+ environment,
+ application_name,
+ metrics,
+ capture_message_content,
+ disable_metrics,
+ version,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+ )
+
+ return response
+
+
+def process_agent_receive(
+ message,
+ agent_name,
+ sender_name,
+ agent_instance,
+ 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 receive 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._sender_name = sender_name
+ scope._server_address, scope._server_port = server_address, server_port
+ scope._message = message
+
+ # Extract model from agent instance
+ if hasattr(agent_instance, "llm_config") and isinstance(
+ agent_instance.llm_config, dict
+ ):
+ scope._request_model = agent_instance.llm_config.get("model", "unknown")
+ else:
+ scope._request_model = "unknown"
+ scope._response_model = scope._request_model
+
+ # Set agent-specific attributes
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_MESSAGE_TYPE, "receive")
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_SENDER, sender_name)
+
+ # Content capture for received message
+ if capture_message_content:
+ span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, str(message))
+
+ common_agent_logic(
+ scope,
+ pricing_info,
+ environment,
+ application_name,
+ metrics,
+ capture_message_content,
+ disable_metrics,
+ version,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+ )
+
+
+def process_agent_send(
+ message,
+ agent_name,
+ recipient_name,
+ agent_instance,
+ 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 send 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._recipient_name = recipient_name
+ scope._server_address, scope._server_port = server_address, server_port
+ scope._message = message
+
+ # Extract model from agent instance
+ if hasattr(agent_instance, "llm_config") and isinstance(
+ agent_instance.llm_config, dict
+ ):
+ scope._request_model = agent_instance.llm_config.get("model", "unknown")
+ else:
+ scope._request_model = "unknown"
+ scope._response_model = scope._request_model
+
+ # Set agent-specific attributes
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_MESSAGE_TYPE, "send")
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_RECIPIENT, recipient_name)
+
+ # Content capture for sent message
+ if capture_message_content:
+ span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, str(message))
+
+ common_agent_logic(
+ scope,
+ pricing_info,
+ environment,
+ application_name,
+ metrics,
+ capture_message_content,
+ disable_metrics,
+ version,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+ )
+
+
+def process_groupchat_operation(
+ group_name,
+ participants,
+ messages,
+ sender,
+ max_turns,
+ 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 GroupChat operation and generate Telemetry
+ """
+
+ # Create scope object
+ scope = type("GenericScope", (), {})()
+
+ scope._start_time = start_time
+ scope._end_time = time.time()
+ scope._span = span
+ scope._group_name = group_name
+ scope._participants = participants
+ scope._server_address, scope._server_port = server_address, server_port
+ scope._sender_name = getattr(sender, "name", "Unknown") if sender else "Unknown"
+
+ # Add required model attributes for common_agent_logic
+ scope._request_model = request_model
+ scope._response_model = request_model
+
+ # Set agent name for groupchat
+ scope._agent_name = group_name
+
+ # Set GroupChat-specific attributes
+ span.set_attribute(
+ SemanticConvention.GEN_AI_GROUPCHAT_PARTICIPANTS, ",".join(participants)
+ )
+ span.set_attribute(
+ SemanticConvention.GEN_AI_WORKFLOW_AGENT_COUNT, len(participants)
+ )
+ span.set_attribute(SemanticConvention.GEN_AI_WORKFLOW_EXECUTION_TYPE, "groupchat")
+
+ if max_turns:
+ span.set_attribute(SemanticConvention.GEN_AI_GROUPCHAT_TURN_COUNT, max_turns)
+
+ # Content capture for GroupChat
+ if capture_message_content and messages:
+ span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, str(messages))
+
+ # Use framework operation type for GroupChat
+ common_agent_logic(
+ scope,
+ pricing_info,
+ environment,
+ application_name,
+ metrics,
+ capture_message_content,
+ disable_metrics,
+ version,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK,
+ )
+
+
+def process_speaker_selection(
+ last_speaker,
+ selected_speaker,
+ selector,
+ agents,
+ 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 speaker selection and generate Telemetry
+ """
+
+ # Create scope object
+ scope = type("GenericScope", (), {})()
+
+ scope._start_time = start_time
+ scope._end_time = time.time()
+ scope._span = span
+ scope._last_speaker = last_speaker
+ scope._selected_speaker = selected_speaker
+ scope._server_address, scope._server_port = server_address, server_port
+
+ # Add required model attributes for common_agent_logic
+ scope._request_model = request_model
+ scope._response_model = request_model
+
+ # Set agent name for speaker selection
+ scope._agent_name = "speaker_selection"
+
+ # Set speaker selection attributes
+ span.set_attribute(
+ SemanticConvention.GEN_AI_GROUPCHAT_SPEAKER_SELECTION, selected_speaker
+ )
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_SENDER, last_speaker)
+
+ if selector:
+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE, "selector")
+
+ # Set agent count
+ if agents:
+ span.set_attribute(SemanticConvention.GEN_AI_WORKFLOW_AGENT_COUNT, len(agents))
+
+ # Use agent operation type for speaker selection
+ common_agent_logic(
+ scope,
+ pricing_info,
+ environment,
+ application_name,
+ metrics,
+ capture_message_content,
+ disable_metrics,
+ version,
+ SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+ )
diff --git a/sdk/python/src/openlit/semcov/__init__.py b/sdk/python/src/openlit/semcov/__init__.py
index 6595437a..158d1e30 100644
--- a/sdk/python/src/openlit/semcov/__init__.py
+++ b/sdk/python/src/openlit/semcov/__init__.py
@@ -498,3 +498,13 @@ class SemanticConvention:
# Standard Task Attributes (framework-agnostic)
GEN_AI_TASK_DESCRIPTION = "gen_ai.task.description"
GEN_AI_TASK_EXPECTED_OUTPUT = "gen_ai.task.expected_output"
+
+ GEN_AI_GROUPCHAT_PARTICIPANTS = "gen_ai.groupchat.participants"
+ GEN_AI_GROUPCHAT_SPEAKER_SELECTION = "gen_ai.groupchat.speaker_selection"
+ GEN_AI_GROUPCHAT_MESSAGE_COUNT = "gen_ai.groupchat.message_count"
+ GEN_AI_GROUPCHAT_TURN_COUNT = "gen_ai.groupchat.turn_count"
+
+ GEN_AI_AGENT_RECIPIENT = "gen_ai.agent.recipient"
+ GEN_AI_AGENT_SENDER = "gen_ai.agent.sender"
+ GEN_AI_AGENT_MESSAGE_TYPE = "gen_ai.agent.message_type"
+ GEN_AI_AGENT_REPLY_MODE = "gen_ai.agent.reply_mode"