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 (#811)
Patcherc2eda51ecf56
diff --git a/sdk/python/.pylintrc b/sdk/python/.pylintrcindex 61ab3967..f5cffa4f 100644--- a/sdk/python/.pylintrc+++ b/sdk/python/.pylintrc@@ -7,7 +7,7 @@ max-locals=30max-args=25# Maximum number of positional arguments (see R0917).-max-positional-arguments=16+max-positional-arguments=20# Maximum allowed line lengthmax-line-length=135diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.tomlindex 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__.pyindex 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 = Trueif (os.getenv("OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT", "").lowerdiff --git a/sdk/python/src/openlit/instrumentation/ag2/__init__.py b/sdk/python/src/openlit/instrumentation/ag2/__init__.pyindex 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.metadatafrom opentelemetry.instrumentation.instrumentor import BaseInstrumentorfrom 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 methodspassdiff --git a/sdk/python/src/openlit/instrumentation/ag2/ag2.py b/sdk/python/src/openlit/instrumentation/ag2/ag2.pyindex 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_portfrom 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 responsereturn 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 wrapperdiff --git a/sdk/python/src/openlit/instrumentation/ag2/async_ag2.py b/sdk/python/src/openlit/instrumentation/ag2/async_ag2.pyindex 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_portfrom 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 responsereturn 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 wrapperdiff --git a/sdk/python/src/openlit/instrumentation/ag2/utils.py b/sdk/python/src/openlit/instrumentation/ag2/utils.pyindex 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 = spanscope._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_modelscope._system_message = system_messagescope._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__.pyindex 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"