Python: [Bug]: AzureAIClient.configure_azure_monitor does not preserve a single Foundry trace

[MatteoSava]

Description

In agent-framework-core==1.0.0rc5 and agent-framework-azure-ai==1.0.0rc5, the default Azure AI observability setup does not produce end-to-end trace continuity in Azure AI Foundry.

This is not a new regression only in rc5. We first observed and reproduced this during internal evaluation at my company in December 2025, and the same behavior is still present in python-1.0.0rc5 released on March 20, 2026.

The user-visible problem is that a single logical agent run that triggers multiple Responses API calls is split into multiple unrelated trace IDs in Azure AI Foundry instead of appearing as one coherent trace tree.

That makes Foundry observability effectively broken for this path:

• one run does not appear as one trace
• each Responses call looks like an independent server-side trace
• debugging a single run across multiple model calls becomes much harder

This issue is specifically about the default non-streaming Azure AI path. Streaming appears to have a separate root cause.

Code Sample

Error Messages / Stack Traces

Package Versions

agent-framework-core: 1.0.0rc5, agent-framework-azure-ai: 1.0.0rc5

Python Version

Python 3.12

Additional Context

Likely root cause

AzureAIClient.configure_azure_monitor() instruments Azure Monitor and the Agent Framework's own spans, but it does not instrument the httpx transport that the OpenAI Python SDK uses internally. The relevant rc5 code paths are:

• python/packages/azure-ai/agent_framework_azure_ai/_client.py#L242-L328
• python/packages/azure-ai/agent_framework_azure_ai/_client.py#L683-L685

The effective flow today is:

1. configure_azure_monitor() calls azure.monitor.opentelemetry.configure_azure_monitor(…)
2. It then calls agent_framework.observability.enable_instrumentation(…)
3. RawAzureAIClient._initialize_client() later creates the OpenAI client via self.project_client.get_openai_client()
4. That client uses httpx.AsyncClient under the hood
5. Because httpx is uninstrumented, outbound Responses requests never propagate the active trace context to Foundry

This is why local/in-process spans may still appear coherent while Foundry server-side traces are fragmented across separate trace IDs.

How we worked around it in our codebase

In our codebase, we restored non-streaming Foundry trace continuity by explicitly instrumenting httpx after the normal MAF / Azure Monitor setup.

Our workaround is effectively:

await client.configure_azure_monitor(...)

from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor

HTTPXClientInstrumentor().instrument()

This workaround solved the trace fragmentation for the non-streaming path in our repo, but it should not be required from every consumer when AzureAIClient.configure_azure_monitor() is presented as the supported observability setup path.

[TaoChenOSU]

Hey @MatteoSava,

Could you share your code and the traces you observed?

What you said here "single logical agent run that triggers multiple Responses API calls is split into multiple unrelated trace IDs in Azure AI Foundry instead of appearing as one coherent trace tree." is unexpected. You should see an end-to-end trace per agent invocation from Microsoft Agent Framework.

[MatteoSava]

Hey @TaoChenOSU,

You can replicate the issue with any minimal tool-call implementation. For precision, we're using Foundry V2, that might be why you didn't manage to reproduce it.

The script below, without HTTPXClientInstrumentor, creates a separate server-side trace in Foundry for each Responses API call instead of grouping them under a single tree. You can uncomment the two httpx lines to see how the fix forces a single trace ID on Foundry.

import asyncio
from typing import Annotated
from pydantic import Field
from agent_framework import Agent
from agent_framework.azure import AzureAIClient
from azure.identity.aio import DefaultAzureCredential


DB = {
    "engineering": "ENG-001",
    "ENG-001": {"headcount": 42, "manager_id": "MGR-042", "cost_center": "CC-7700"},
    "MGR-042": {"name": "Laura Bianchi", "title": "VP Engineering"},
    ("ENG-001", "2026"): {"budget_eur": 2_400_000, "approved": True},
}

def lookup_id(name: Annotated[str, Field(description="Department name")]) -> str:
    """Step 1: resolve name → internal ID."""
    return DB.get(name.lower(), "not found")

def get_details(dept_id: Annotated[str, Field(description="Dept ID e.g. ENG-001")]) -> str:
    """Step 2: get department details (needs ID from step 1)."""
    import json; return json.dumps(DB.get(dept_id, "not found"))

def get_manager(mgr_id: Annotated[str, Field(description="Manager ID e.g. MGR-042")]) -> str:
    """Step 3a: get manager info (needs manager_id from step 2)."""
    import json; return json.dumps(DB.get(mgr_id, "not found"))

def get_budget(dept_id: Annotated[str, Field(description="Dept ID")],
               year: Annotated[str, Field(description="Fiscal year")]) -> str:
    """Step 3b: get budget (needs dept ID from step 1)."""
    import json; return json.dumps(DB.get((dept_id, year), "not found"))


async def main() -> None:
    async with DefaultAzureCredential() as cred, AzureAIClient(credential=cred) as client:
        await client.configure_azure_monitor(enable_live_metrics=True)

        # ── Uncomment these 2 lines to fix trace fragmentation ──
        # from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
        # HTTPXClientInstrumentor().instrument()

        agent = Agent(
            client=client,
            name="dept-agent",
            instructions=(
                "Follow these steps IN ORDER, do NOT skip or guess IDs:\n"
                "1. lookup_id to get the dept ID\n"
                "2. get_details with that ID\n"
                "3. get_manager AND get_budget (you can call both)\n"
                "4. Summarize everything"
            ),
            tools=[lookup_id, get_details, get_manager, get_budget],
        )

        # Single run → 4+ Responses API.
        # BUG: without httpx instrumentation each call creates
        #      a separate server-side trace in Azure AI Foundry.
        result = await agent.run(
            "Full report on Engineering for FY2026: details, manager, budget."
        )
        print(result)

asyncio.run(main())

[TaoChenOSU]

We are still creating the full end-to-end trace if you query in the connected AppInsights instance:

Let me talk to the Foundry team on why it's not showing in the portal.