Tracing UI in Azure AI Foundry not displaying internal Tool (Azure AI Search) executions

[tomask736]

Hello,
I would like to see span with Azure AI Search tool call including parameters and other metadata related to this call in Tracing UI.

I have defined Agent as:

"""
Agent class for Azure AI Foundry and Azure AI Search integration.
"""

import logging

from azure.ai.agents.models import AzureAISearchTool

logger = logging.getLogger(__name__)


class AgentManager:
    """
    Agent class that interacts with Azure AI Foundry and Azure AI Search.
    Provides functionality for creating agents and executing search queries.
    """

    def __init__(self, env_cfg, project_client):
        """
        Initialize an AgentManager instance.
        """

        if project_client is None:
            raise ValueError("Project client must be provided.")

        self.project_client = project_client
        self.env_cfg = env_cfg
        self.search_tool = None
        self.agent = None

    def initialize_clients(self):
        """
        Initialize the Azure AI Foundry Project client with AI Search tool.
        """

        search_index_name = self.env_cfg["search_index_name"]
        search_connection_name = self.env_cfg["search_connection_name"]

        logger.info(f"Using Search index: {search_index_name}")

        # Define the Azure AI Search connection ID
        azure_ai_conn_id = self.project_client.connections.get(
            search_connection_name
        ).id
        logger.info(f"Using Azure AI Search connection ID: {azure_ai_conn_id}")

        # Initialize the Azure AI Search tool
        self.search_tool = AzureAISearchTool(
            index_connection_id=azure_ai_conn_id,
            index_name=search_index_name,
        )

    def create_agent(
        self,
        name: str = "SimpleHelpAgent",
        instructions: str = "You are a helpful AI assistant. Answer questions politely and helpfully.",
    ) -> str:
        """
        Create the agent in Azure AI Foundry.

        Returns:
            str: The ID of the created agent
        """
        model_deployment_name_agent = (
            self.env_cfg["model_deployment_name_agent"] or "gpt-4o-mini"
        )
        logger.info(
            f"Using model deployment '{model_deployment_name_agent}' for agent creation."
        )
        agent = self.project_client.agents.create_agent(
            model=model_deployment_name_agent,
            name=name,
            instructions=instructions,
            tools=self.search_tool.definitions,
            tool_resources=self.search_tool.resources,
        )
        self.agent = agent
        logger.info(f"Created agent with ID: {self.agent.id}")
        return self.agent.id

and I would like to get full observability for Agent run.

I have this instrumented code for Agent run:

from __future__ import annotations

import asyncio
import os
import sys
import time
import logging
import uuid
from typing import Optional

from azure.ai.agents.telemetry import AIAgentsInstrumentor
from azure.core.exceptions import AzureError
from azure.identity.aio import AzureCliCredential
from azure.ai.projects.aio import AIProjectClient


from opentelemetry.instrumentation.logging import LoggingInstrumentor
from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.resources import Resource, SERVICE_NAME
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor

from opentelemetry import metrics

# ---------------------------------------------------------------------------
# 🔧 OpenTelemetry & Azure Monitor instrumentation
# ---------------------------------------------------------------------------


# Capture prompt / completion text (disable in prod if needed)
os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "true"

# Patch *logging* BEFORE any log records are emitted, 
# swaps‐in a custom LogRecordFactory that enriches every new LogRecord with the OpenTelemetry context keys:
# otelTraceID, otelSpanID, otelServiceName, otelTraceSampled
LoggingInstrumentor().instrument()


# Standard logging config that embeds trace/span ids in every log line
logging.basicConfig(
    level=logging.DEBUG,
    format=(
        "%(asctime)s %(levelname)s [%(name)s]"
        " [trace_id=%(otelTraceID)s span_id=%(otelSpanID)s] %(message)s"
    ),
    handlers=[logging.StreamHandler()],
)

# Hide noisy HTTP 200/201 logs
logging.getLogger(
    "azure.core.pipeline.policies.http_logging_policy"
).setLevel(logging.WARNING)

logger = logging.getLogger(__name__)

try:
    # Optional: identify the human running this script (mirrors evaluation CLI)
    from tools.user_tools import get_user_identity_async  
except ImportError:  # Not available when sample is copied standalone – that's OK
    get_user_identity_async = None 

# ---------------------------------------------------------------------------
# Helper functions using the async Azure AI Foundry SDK
# ---------------------------------------------------------------------------


async def resolve_agent_id(client: AIProjectClient, name: str) -> str:
    """Return the ID of the *agent* whose ``name`` matches *name*.

    Raises
    ------
    RuntimeError
        If no agent with the given name exists. The error lists available
        names to aid troubleshooting.
    """
    logger.debug(f"Resolving agent_id for agent name '{name}'")
    agents = [agent async for agent in client.agents.list_agents()]  
    logger.debug(f"Retrieved {len(agents)} agents from project")
    
    for agent in agents:
        logger.debug(f"Examining agent: id={agent.id} name={agent.name}")
        
        if agent.name == name:
            logger.info(f"Resolved agent '{name}' to id '{agent.id}'")
            return agent.id
    
    available = ", ".join(a.name for a in agents) or "<no agents found>"
    logger.error(f"Agent '{name}' not found; available: {available}")
    
    raise RuntimeError(f"Agent '{name}' not found; available: {available}")


async def ask_agent(
    client: AIProjectClient,
    agent_id: str,
    message: str,
    *,
    role: str = "user",
    tracer: trace.Tracer | None = None
) -> Optional[str]:
    """Send *message* to *agent_id* and return the assistant reply or ``None``.

    A child span is created so that prompt, latency, and reply are captured.
    """
    logger.debug(f"ask_agent called with agent_id={agent_id} message={message}")
    
    tracer = tracer or trace.get_tracer(__name__)
    start_ts = time.time()

    with tracer.start_as_current_span("AskAgent") as span:
        span.set_attribute("user.message", message)
        span.add_event("user.message", {"content": message})

        try:
            # Create a fresh thread and post the user message.
            thread = await client.agents.threads.create()
            
            logger.debug(f"Created new thread with id {thread.id}")
            
            await client.agents.messages.create(
                thread_id=thread.id,
                role=role,
                content=message,
            )
            
            logger.debug(f"Posted user message to thread {thread.id}")

            # Create and process a run; fail fast if the model reports an error.
            run = await client.agents.runs.create_and_process(
                thread_id=thread.id,
                agent_id=agent_id,
            )
           
            logger.debug(f"Run created with status '{run.status}'")
            
            if run.status == "failed":
                
                logger.error(f"Run failed: {run.last_error}")
                
                span.record_exception(RuntimeError(str(run.last_error)))
                span.set_status(Status(StatusCode.ERROR, str(run.last_error)))
                raise RuntimeError(run.last_error)
            
            # Add token usage to the counter if available
            usage = getattr(run, "usage", None)
            total_tokens = getattr(usage, "total_tokens", None)
            prompt_tokens = getattr(usage, "prompt_tokens", None)
            completion_tokens = getattr(usage, "completion_tokens", None)

            if None not in (total_tokens, prompt_tokens, completion_tokens):
                logger.debug(
                    "Run completed successfully. Tokens used – Total: %d, Prompt: %d, Completion: %d",
                    total_tokens,
                    prompt_tokens,
                    completion_tokens,
                )
            else:
                logger.debug("Run completed but token usage stats missing: %s", usage)
            
          
           # Read the assistant’s first reply and be sure the iterator is closed
            assistant_response: Optional[str] = None

            async for msg in client.agents.messages.list(thread_id=thread.id):
                logger.debug(f"Read message id={msg.id} role={msg.role}")

                if msg.role == "assistant" and assistant_response is None:
                    # capture the first assistant reply we see
                    assistant_response = "".join(
                        part.text.value
                        for part in msg.content
                        if hasattr(part, "text")
                    )
                    logger.debug(f"Assistant response captured: {assistant_response}")        
          
            latency = time.time() - start_ts
            span.set_attribute("run.latency", latency)
            span.add_event("run.latency", {"content": latency})
            logger.info(f"ask_agent latency {latency:.3f} s")

            span.set_attribute("assistant.message", assistant_response or "<none>")
            span.set_status(Status(StatusCode.OK))
        except Exception as exc:
            span.record_exception(RuntimeError(str(exc)))
            span.set_status(Status(StatusCode.ERROR, str(exc)))
            logger.exception(f"Exception in ask_agent: {exc}")
            raise

    return assistant_response


# ---------------------------------------------------------------------------
# Main CLI entry‑point
# ---------------------------------------------------------------------------


async def main() -> None:  
    """Main entry point."""
    
    logger.debug("Entering main()")
    
    try:
        endpoint = os.environ["PROJECT_ENDPOINT"].rstrip("/")
        agent_name = os.environ["AGENT_NAME"]
        
        logger.debug(f"Environment variables: PROJECT_ENDPOINT={endpoint} AGENT_NAME={agent_name}")
    except KeyError as err:
        logger.critical(f"Required environment variable missing: {err.args[0]}")
        sys.exit(f"Error: set the {err.args[0]} environment variable.")

    # -------------------------------------------------------------------
    # Authenticate & create the project client
    # -------------------------------------------------------------------
    async with (
        AzureCliCredential() as cred,
        AIProjectClient(endpoint=endpoint, credential=cred) as project_client,
    ):
        logger.debug(f"AIProjectClient created for endpoint {endpoint}")
        # ---------------------------------------------------------------
        # Discover Application Insights for this project and wire up OTel
        # ---------------------------------------------------------------

        app_insights_connection_string = await project_client.telemetry.get_connection_string()  
        logger.debug(f"Telemetry connection string retrieved: {bool(app_insights_connection_string)}")

        if not app_insights_connection_string:
            error_msg = (
                "No Application Insights resource is connected to this project – enable it in the Azure AI Foundry portal."
            )
            logger.critical(error_msg)
            raise RuntimeError(error_msg)

        # Figure out who the end‑user is (best‑effort)
        user_id: str = "unknown"
        if get_user_identity_async is not None:
            try:
                user_id = await get_user_identity_async(cred)  
                
                logger.debug(f"User identity resolved to {user_id}")
            except Exception as exc:  
                logger.warning(f"Failed to resolve user identity: {exc}")

        # Create a resource to describe this process
        resource = Resource.create(
            {
                SERVICE_NAME: "SimpleAgent",
                "enduser.id": user_id,
            }
        )
        
        # Create a tracer provider and configure Azure Monitor	
        trace_provider = TracerProvider(resource=resource)
        configure_azure_monitor(
            connection_string=app_insights_connection_string,
            tracer_provider=trace_provider,
            enable_live_metrics=True,
        )

        logger.debug("Azure Monitor configured and tracer provider registered")

        # Instrument OpenAI *after* the provider is registered
        OpenAIInstrumentor().instrument()
        
        # Instrument Agent
        AIAgentsInstrumentor().instrument(enable_content_recording=True)
        
        logger.debug("OpenAIInstrumentor attached")
        tracer = trace.get_tracer(__name__)

        # ---------------------------------------------------------------
        # Resolve the agent and send the chat message under a parent span
        # ---------------------------------------------------------------
        with tracer.start_as_current_span("ChatSession") as span:
            span.set_attribute("agent.name", agent_name)
            span.set_attribute("cli.user_id", user_id)
           
            invocation_id = str(uuid.uuid4())
            
            span.set_attribute("cli.invocation_id", invocation_id)
            
            logger.info(f"Chat session started (invocation_id={invocation_id})")

            # Resolve agent id for given agent name
            agent_id = await resolve_agent_id(project_client, agent_name)
            
            span.set_attribute("agent.id", agent_id)
            
            logger.debug(f"Agent id resolved: {agent_id}")

            # Define prompt
            prompt = "List development properties between lattitude 0 and 120 degrees."
            
            span.set_attribute("user.message", prompt)
            span.add_event("user.message", {"content": prompt})
            
            logger.info(f"Sending prompt to agent: {prompt}")

            # Obtain answer from agent
            try:
                answer = await ask_agent(project_client, agent_id, prompt, tracer=tracer)
               
                span.set_attribute("assistant.message", answer or "<none>")
                span.set_status(Status(StatusCode.OK))
                logger.info(f"Assistant replied: {answer}")               
            except Exception as exc:  
                span.record_exception(exc)
                span.set_status(Status(StatusCode.ERROR, str(exc)))
                logger.exception(f"Error while chatting with agent: {exc}")
                raise

            print(f"Assistant: {answer or 'no reply'}")
            logger.debug("Chat session completed successfully")
            
            # Force the meter provider to flush before exit
            metrics.get_meter_provider().force_flush()


# ---------------------------------------------------------------------------
# Boot‑strap the asyncio loop
# ---------------------------------------------------------------------------


if __name__ == "__main__":
    try:
        logger.debug("Starting asyncio event loop")
        asyncio.run(main())
    except AzureError as exc:
        logger.exception(f"Azure SDK error: {exc}")
        sys.exit(f"Azure SDK error: {exc}")
    except Exception as exc:  
        logger.critical(f"Unhandled exception: {exc}")
        sys.exit(str(exc))

When looking to Tracing UI,
I could see the Azure AI Search to be invoked (based on agent answer and citations), but
I cannot find any notion of Azure AI search tool being executed (tool call, parameters, metadata).

Full metadata from list_messages:

{
name: "list_messages"
context: {
trace_id: "7830cf3bd3e1e39672855d76ea838db1"
span_id: "f3c1f737dd9780fe"
thread_id: undefined
trace_state: undefined
}
kind: "GenAI"
parent_id: "d56935aece76586e"
start_time: "2025-07-02T13:16:08.7093490Z"
end_time: "2025-07-02T13:16:09.411Z"
status: {
status_code: "Ok"
description: "0 undefined"
}
attributes: {
span_type: "GenAI"
gen_ai.system: "az.ai.agents"
gen_ai.operation.name: "list_messages"
gen_ai.thread.id: "thread_zQldbHphQQ78JVrjTGpkMHaW"
_MS.ResourceAttributeId: "3e224021-b981-41cb-a49b-dd8ef56cfeea"
}
events: [
0: {
name: "gen_ai.assistant.message"
timestamp: "2025-07-02T13:16:09.1939170Z"
attributes: {
gen_ai.event.content: {
content: {
text: {
value: "Here are the development properties located between latitude 0 and 120 degrees from the documents: 1. A flat, dream home with lake access, within walking distance of a beach, featuring top of the line appliances, a garden, and two master suites. - Address: 2343 South 117th Street, Burien, WA, 98168 - Latitude: 0 2. An apartment residence, a great starter home, ocean views, located in a culs-de-sac, featuring a home office, wood floors, and granite countertops. - Address: 8108 8th Avenue Southwest, Seattle, WA, 98106 - Latitude: 0 3. A condo, move-in condition, lake front property located in a culs-de-sac, features top of the line appliances, a wall of windows, and vaulted ceilings. - Address: 6414 24th Avenue South, Seattle, WA, 98108 - Latitude: 0 These properties are located at latitude 0, which falls within the requested range (0 to 120 degrees latitude). No properties with latitude between 1 and 120 degrees were found in the results provided.【3:2†source】【3:3†source】【3:4†source】"
annotations: [
0: {
type: "url_citation"
text: "【3:2†source】"
start_index: 982
end_index: 994
url_citation: {
url: "doc_2"
title: "doc_2"
}
}
1: {
type: "url_citation"
text: "【3:3†source】"
start_index: 994
end_index: 1006
url_citation: {
url: "doc_3"
title: "doc_3"
}
}
2: {
type: "url_citation"
text: "【3:4†source】"
start_index: 1006
end_index: 1018
url_citation: {
url: "doc_4"
title: "doc_4"
}
}
]
}
}
role: "assistant"
}
_MS.ResourceAttributeId: "3e224021-b981-41cb-a49b-dd8ef56cfeea"
gen_ai.system: "az.ai.agents"
gen_ai.thread.id: "thread_zQldbHphQQ78JVrjTGpkMHaW"
gen_ai.agent.id: "asst_q2MxkZdN1ezLVyEHtaWl24wn"
gen_ai.thread.run.id: "run_4578Gxd0zWsSHJB3wamJ7QHs"
gen_ai.message.id: "msg_T0WxliVqkChzrRY5chgWbwHn"
}
}
1: {
name: "gen_ai.user.message"
timestamp: "2025-07-02T13:16:09.1949150Z"
attributes: {
gen_ai.event.content: {
content: {
text: {
value: "List development properties between lattitude 0 and 120 degrees."
}
}
role: "user"
}
_MS.ResourceAttributeId: "3e224021-b981-41cb-a49b-dd8ef56cfeea"
gen_ai.system: "az.ai.agents"
gen_ai.thread.id: "thread_zQldbHphQQ78JVrjTGpkMHaW"
gen_ai.message.id: "msg_wp3Ne1wxhsetl52fVQ8DxYH7"
}
}
]
external_event_data_uris: undefined
span_json_uri: undefined
links: undefined
resource: undefined
}

Am I looking to the wrong place or do I need to add any specific code snippet to make this work ?

I would like to see span with Azure AI Search tool call including parameters and other metadata related to this call.

I have read https://github.com/orgs/azure-ai-foundry/discussions/15 and examined provided sample script there, but I am not sure if that works only for custom tool or could be used also internal Azure AI Foundry tools such as Azure AI Search.

Thank you,
Tomas

[nicholasdbrady]

@santiagxf / @farzad528, can you help here?