Rastrear e observar agentes de IA no Microsoft Foundry (pré-visualização) (clássico)

Aplica-se apenas a:Portal Foundry (clássico). Este artigo não está disponível para o novo portal da Foundry. Saiba mais sobre o novo portal.

Neste artigo, aprende como:

• Compreenda os principais conceitos de rastreamento.
• Rastrear e observar agentes de IA na Foundry.
• Explore novas convenções semânticas com observabilidade multiagente.
• Integre-se com os frameworks populares de agentes.
• Ver rastreios no portal Foundry e no Azure Monitor.
• Ver tópicos de agentes no parque de diversões dos Agentes.

Determinar o motivo das execuções do seu agente é importante para a resolução de problemas e a depuração. No entanto, pode ser difícil para agentes complexos por várias razões:

• Pode haver um grande número de passos envolvidos na geração de uma resposta, tornando difícil acompanhar todos eles.
• A sequência de passos pode variar consoante a entrada do utilizador.
• As entradas e saídas em cada etapa podem ser longas e merecer uma inspeção mais detalhada.
• Cada etapa do tempo de execução de um agente pode também envolver o aninhamento. Por exemplo, um agente pode invocar uma ferramenta, que utiliza outro processo, que depois invoca outra ferramenta. Se notar uma saída estranha ou incorreta numa execução de agente de topo, pode ser difícil determinar exatamente em que momento da execução o problema foi introduzido.

Os resultados de traço resolvem este problema ao permitir-lhe visualizar as entradas e saídas de cada primitiva envolvida numa execução de agente em particular. Os resultados são apresentados pela ordem em que as primitivas são invocadas, facilitando a compreensão e depuração do comportamento do seu agente de IA.

Visão geral dos conceitos-chave de rastreio

Aqui fica uma breve visão geral dos conceitos-chave antes de começar:

Melhores práticas

• Use atributos de amplitude consistente.
• Correlaciona os IDs das execuções de avaliação para análise de qualidade e desempenho.
• Redigir conteúdo sensível. Evite guardar segredos em atributos.

Extensão do OpenTelemetry com observabilidade multiagente

Microsoft está a melhorar a observabilidade multiagente ao introduzir novas convenções semânticas no OpenTelemetry, desenvolvidas em colaboração com o Outshift, o motor de incubação da Cisco. Estas adições, baseadas no OpenTelemetry e no W3C Trace Context, estabelecem práticas padronizadas para rastreio e telemetria em sistemas multi-agente. Facilitam o registo consistente de métricas-chave para qualidade, desempenho, segurança e custo. Esta abordagem sistemática permite uma visibilidade mais abrangente dos fluxos de trabalho multi-agente, incluindo invocações de ferramentas e colaboração. A Microsoft integrou estes avanços nos pacotes Microsoft Foundry, Microsoft Agent Framework, Kernel Semântico e Azure AI para LangChain, LangGraph e o SDK OpenAI Agents. Ao usar o Foundry, os clientes podem obter observabilidade unificada para sistemas agentivos construídos com qualquer um destes frameworks. Saiba mais sobre integrações de rastreamento.

Configurar traçado no Microsoft Foundry SDK

Para completar o chat ou construir agentes com o Foundry, instale:

pip install azure-ai-projects azure-identity

Para traçar instrumentos, instale as seguintes bibliotecas de instrumentação:

pip install azure-monitor-opentelemetry opentelemetry-sdk

Para visualizar trilhas no Foundry, ligue um recurso Application Insights ao seu projeto Foundry.

1. Navegue até Traçado no painel de navegação esquerdo do portal da Foundry.
2. Crie um novo recurso de Application Insights se ainda não tiver um.
3. Ligue o recurso ao seu projeto Foundry.

Rastreamento de instrumentos no seu código

Para rastrear o conteúdo das mensagens de chat, atribua à variável de ambiente AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED o valor verdadeiro, sem distinção entre maiúsculas e minúsculas. Este conteúdo pode conter dados pessoais. Para mais informações, consulte Azure Core Tracing OpenTelemetry biblioteca cliente para Python.

import os
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "true" # False by default

Vamos começar a instrumentar o nosso agente com OpenTelemetry para rastreio, começando a autenticar e ligar ao seu projeto de IA do Azure usando o AIProjectClient.

from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
project_client = AIProjectClient(
    credential=DefaultAzureCredential(),
    endpoint=os.environ["PROJECT_ENDPOINT"],
)

De seguida, recupere a cadeia de ligação do recurso Application Insights ligado ao seu projeto e configure os exportadores OTLP para enviar telemetria para o Azure Monitor.

from azure.monitor.opentelemetry import configure_azure_monitor

connection_string = project_client.telemetry.get_application_insights_connection_string()
configure_azure_monitor(connection_string=connection_string) #enable telemetry collection

Agora, rastreie o seu código onde cria e executa a mensagem de agente e utilizador no seu Azure AI Project, para que possa ver passos detalhados para resolução de problemas ou monitorização.

from opentelemetry import trace
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("example-tracing"):
    agent = project_client.agents.create_agent(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        name="my-assistant",
        instructions="You are a helpful assistant"
    )
    thread = project_client.agents.threads.create()
    message = project_client.agents.messages.create(
        thread_id=thread.id, role="user", content="Tell me a joke"
    )
    run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)

Depois de executar o seu agente, pode começar a visualizar os registos no portal Foundry.

Registar rastros localmente

Para se ligar ao Aspire Dashboard ou a outro backend compatível com OpenTelemetry, instale o exportador do OpenTelemetry Protocol (OTLP). Ao usar este exportador, pode imprimir traços para a consola ou usar um visualizador local como o Aspire Dashboard.

pip install azure-core-tracing-opentelemetry opentelemetry-exporter-otlp opentelemetry-sdk

De seguida, configure o rastreio para a saída da consola:

from azure.core.settings import settings
settings.tracing_implementation = "opentelemetry"

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Setup tracing to console
span_exporter = ConsoleSpanExporter()
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
trace.set_tracer_provider(tracer_provider)

Ou modificar o código anterior, com base no Aspire Dashboard, para rastrear até um visualizador OTLP local.

Agora ativa a instrumentação do Agente e executa o teu Agente:

from azure.ai.agents.telemetry import AIAgentsInstrumentor
AIAgentsInstrumentor().instrument()

# Start tracing
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("example-tracing"):
    agent = project_client.agents.create_agent(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        name="my-assistant",
        instructions="You are a helpful assistant"
    )
    thread = project_client.agents.threads.create()
    message = project_client.agents.messages.create(
        thread_id=thread.id, role="user", content="Tell me a joke"
    )
    run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)

Alternativa: AI Toolkit para VS Code

O AI Toolkit dá-te uma forma simples de rastrear localmente no VS Code. Utiliza um coletor local compatível com OTLP, tornando-o ideal para desenvolvimento e depuração.

O kit de ferramentas suporta frameworks de IA como Foundry Agents Service, OpenAI, Anthropic e LangChain através do OpenTelemetry. Consegues ver traços instantaneamente no VS Code sem precisar de acesso à cloud.

Para instruções detalhadas de configuração e exemplos de código específicos de SDK, veja Rastreamento no AI Toolkit.

Traçar funções personalizadas

Para rastrear as suas funções personalizadas, use o SDK OpenTelemetry para instrumentar o seu código.

1. Configure um fornecedor de traçadores: Inicialize um fornecedor de rastreadores para gerir e criar espaços.
2. Crie spans: Envolve o código que queres traçar com spans. Cada vão representa uma unidade de trabalho e podes aninhar vãos para formar uma árvore de traços.
3. Adicionar atributos: Enriquecer intervalos com atributos para fornecer mais contexto para os dados de rastreio.
4. Configurar um exportador: Enviar os dados de rastreio para um backend para análise e visualização.

Aqui está um exemplo de traçar uma função personalizada:

from opentelemetry import trace
from opentelemetry.trace import SpanKind

# Initialize tracer
tracer = trace.get_tracer(__name__)

def custom_function():
    with tracer.start_as_current_span("custom_function") as span:
        span.set_attribute("custom_attribute", "value")
        # Your function logic here
        print("Executing custom function")

custom_function()

Para instruções detalhadas e uso avançado, consulte a documentação do OpenTelemetry.

Anexar comentários dos utilizadores a registos

Para anexar o feedback dos utilizadores a traços e visualizá-los no portal Foundry, instrumente a sua aplicação para permitir o rastreio e registar o feedback dos utilizadores utilizando as convenções semânticas da OpenTelemetry.

Ao correlacionar as pistas de feedback com as respetivas pistas de pedido de chat usando o ID da resposta ou do thread, pode visualizar e gerir essas pistas no portal Foundry. A especificação da OpenTelemetry permite dados de rastreamento padronizados e enriquecidos, que pode analisar no portal Foundry para otimização de desempenho e insights sobre a experiência do utilizador. Esta abordagem ajuda-o a utilizar todo o poder da OpenTelemetry para melhorar a observabilidade nas suas aplicações.

Para registar o feedback dos utilizadores, siga este formato:

O evento de avaliação de feedback do utilizador é capturado apenas se o utilizador fornecer uma reação à resposta do modelo GenAI. Sempre que possível, associe este evento ao intervalo GenAI que descreve essa resposta.

O organismo do evento de feedback dos utilizadores tem a seguinte estrutura:

Utilização do nome do serviço nos dados de rastreio

Para identificar o seu serviço através de um ID único no Application Insights, utilize a propriedade do nome de serviço OpenTelemetry nos seus dados de rastreamento. Esta propriedade é útil se estiver a registar dados de várias aplicações para o mesmo recurso Application Insights e quiser diferenciá-las.

Por exemplo, digamos que tem duas aplicações: App-1 e App-2, com o rastreamento configurado para registar dados no mesmo recurso Application Insights. Talvez queiras configurar a App-1 para ser avaliada continuamente pela Relevância e a App-2 para ser avaliada continuamente pela Relevância. Pode usar o nome do serviço para filtrar por Application quando monitoriza a sua aplicação no portal Foundry.

Para configurar a propriedade do nome do serviço, adicione-a diretamente no seu código de aplicação seguindo os passos em Usar múltiplos fornecedores de traçadores com diferentes Recursos. Alternativamente, define a variável OTEL_SERVICE_NAME de ambiente antes de implementares a tua aplicação. Para saber mais sobre como trabalhar com o nome do serviço, consulte Variáveis de Ambiente OTEL e Convenções Semânticas de Recursos de Serviço.

Para consultar dados de rastreio para um dado nome de serviço, consulte a cloud_roleName propriedade.

| where cloud_RoleName == "service_name"

Integrações

A Foundry facilita o registo de traços com alterações mínimas ao utilizar as suas integrações de rastreio com Microsoft Agent Framework, Kernel Semântico, LangChain, LangGraph e OpenAI Agent SDK.

Agentes de rastreamento construídos no Microsoft Agent Framework e no Kernel Semântico

O Foundry tem integrações nativas com o Microsoft Agent Framework e o Kernel Semântico. Agentes construídos sobre estes dois frameworks recebem rastreamento pronto a usar em Observabilidade.

• Saiba mais sobre rastreamento e observabilidade em Kernel Semântico e Microsoft Agent Framework.

Permitir o rastreamento para agentes construídos em LangChain e LangGraph

Pode ativar o rastreamento do LangChain, que está em conformidade com os padrões OpenTelemetry, conforme opentelemetry-instrumentation-langchain.

Depois de instalar os pacotes necessários, pode facilmente instrumentar o rastreamento no seu código.

Exemplo: agente LangChain v1 com rastreamento de IA da Azure

Use esta amostra de ponta a ponta para instrumentar um agente LangChain v1 usando o langchain-azure-ai rastreador. Implementa a especificação mais recente do OpenTelemetry (OTel) para que possa visualizar rastreios detalhados na Observabilidade.

Pacotes de instalação

pip install \
  langchain-azure-ai \
  langchain \
  langgraph \
  langchain-openai \
  azure-identity \
  python-dotenv \
  rich

Configurar ambiente

• APPLICATION_INSIGHTS_CONNECTION_STRING: string de conexão da Azure Monitor Application Insights para rastreamento.
• AZURE_OPENAI_ENDPOINT: O seu Azure URL de endpoint OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: O nome de implementação do modelo de chat.
• AZURE_OPENAI_VERSION: Versão da API, por exemplo 2024-08-01-preview.
• Azure credenciais são resolvidas via DefaultAzureCredential (suporta variáveis de ambiente, identidade gerida, login VS Code e mais).

Pode armazenar estes valores num .env ficheiro para desenvolvimento local.

Configuração do traçador

from dotenv import load_dotenv
import os
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Weather information agent",
    id="weather_info_agent_771929",
)

tracers = [azure_tracer]

Configuração do modelo (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
)

Defina ferramentas e prompt

from dataclasses import dataclass
from langchain_core.tools import tool

system_prompt = """You are an expert weather forecaster, who speaks in puns.

You have access to two tools:

- get_weather_for_location: use this to get the weather for a specific location
- get_user_location: use this to get the user's location

If a user asks you for the weather, make sure you know the location.
If you can tell from the question that they mean wherever they are,
use the get_user_location tool to find their location."""

# Mock user locations keyed by user id (string)
USER_LOCATION = {
    "1": "Florida",
    "2": "SF",
}

@dataclass
class UserContext:
    user_id: str

@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

Use o contexto em tempo de execução e defina uma ferramenta de informação de utilizador

from langgraph.runtime import get_runtime
from langchain_core.runnables import RunnableConfig

@tool
def get_user_info(config: RunnableConfig) -> str:
    """Retrieve user information based on user ID."""
    runtime = get_runtime(UserContext)
    user_id = runtime.context.user_id
    return USER_LOCATION[user_id]

Crie o agente

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver
from dataclasses import dataclass

@dataclass
class WeatherResponse:
    conditions: str
    punny_response: str

checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    prompt=system_prompt,
    tools=[get_user_info, get_weather],
    response_format=WeatherResponse,
    checkpointer=checkpointer,
)

Executa o agente com rastreamento

from rich import print

def main():
    config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
    context = UserContext(user_id="1")

    r1 = agent.invoke(
        {"messages": [{"role": "user", "content": "what is the weather outside?"}]},
        config=config,
        context=context,
    )
    print(r1.get("structured_response"))

    r2 = agent.invoke(
        {"messages": [{"role": "user", "content": "Thanks"}]},
        config=config,
        context=context,
    )
    print(r2.get("structured_response"))

if __name__ == "__main__":
    main()

Quando ativa langchain-azure-ai, todas as operações LangChain v1 (chamadas LLM, invocações de ferramentas, passos do agente) são rastreadas usando as convenções semânticas mais recentes do OpenTelemetry. Eles aparecem na Observabilidade, ligados ao seu recurso Application Insights.

Exemplo: agente LangGraph com rastreamento de IA do Azure

Este exemplo mostra um agente LangGraph simples instrumentado com langchain-azure-ai para emitir rastreios compatíveis com OpenTelemetry para etapas de grafo, chamadas de ferramentas e invocações de modelo.

Pacotes de instalação

pip install \
  langchain-azure-ai \
  langgraph==1.0.0a4 \
  langchain==1.0.0a10 \
  langchain-openai \
  azure-identity \
  python-dotenv

Configurar ambiente

• APPLICATION_INSIGHTS_CONNECTION_STRING: string de conexão da Azure Monitor Application Insights para rastreamento.
• AZURE_OPENAI_ENDPOINT: O seu Azure URL de endpoint OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: O nome de implementação do modelo de chat.
• AZURE_OPENAI_VERSION: Versão da API, por exemplo 2024-08-01-preview.

Pode armazenar estes valores num .env ficheiro para desenvolvimento local.

Configuração do traçador

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer

load_dotenv(override=True)

azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=os.getenv("OTEL_RECORD_CONTENT", "true").lower() == "true",
    name="Music Player Agent",
)

Ferramentas

from langchain_core.tools import tool

@tool
def play_song_on_spotify(song: str):
    """Play a song on Spotify"""
    # Integrate with Spotify API here.
    return f"Successfully played {song} on Spotify!"

@tool
def play_song_on_apple(song: str):
    """Play a song on Apple Music"""
    # Integrate with Apple Music API here.
    return f"Successfully played {song} on Apple Music!"

tools = [play_song_on_apple, play_song_on_spotify]

Configuração do Modelo (Azure OpenAI)

import os
import azure.identity
from langchain_openai import AzureChatOpenAI

token_provider = azure.identity.get_bearer_token_provider(
    azure.identity.DefaultAzureCredential(),
    "https://ai.azure.com/.default",
)

model = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    azure_ad_token_provider=token_provider,
).bind_tools(tools, parallel_tool_calls=False)

Construir o fluxo de trabalho LangGraph

from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver

tool_node = ToolNode(tools)

def should_continue(state: MessagesState):
    messages = state["messages"]
    last_message = messages[-1]
    return "continue" if getattr(last_message, "tool_calls", None) else "end"

def call_model(state: MessagesState):
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": [response]}

workflow = StateGraph(MessagesState)
workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END,
    },
)
workflow.add_edge("action", "agent")

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

Correr com rastreamento

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "1"}, "callbacks": [azure_tracer]}
input_message = HumanMessage(content="Can you play Taylor Swift's most popular song?")

for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()

Ao ativar langchain-azure-ai, a execução do LangGraph emite spans compatíveis com OpenTelemetry para chamadas de modelo, invocações de ferramentas e transições de grafo. Estes traços fluem para o Application Insights e aparecem na Observabilidade.

Exemplo: Configuração do LangChain 0.3 com rastreamento do Azure AI

Esta configuração mínima mostra como ativar o traçado Azure IA numa aplicação LangChain 0.3 usando o traçador langchain-azure-ai e AzureChatOpenAI.

Pacotes de instalação

pip install \
  "langchain>=0.3,<0.4" \
  langchain-openai \
  langchain-azure-ai \
  python-dotenv

Configurar ambiente

• APPLICATION_INSIGHTS_CONNECTION_STRING: Cadeia de conexão do Application Insights para monitorização.
• AZURE_OPENAI_ENDPOINT: Azure URL do endpoint OpenAI.
• AZURE_OPENAI_CHAT_DEPLOYMENT: Nome de implementação do modelo de chat.
• AZURE_OPENAI_VERSION: Versão da API, por exemplo 2024-08-01-preview.
• AZURE_OPENAI_API_KEY: chave de API do Azure OpenAI.

Traçador e configuração do modelo

import os
from dotenv import load_dotenv
from langchain_azure_ai.callbacks.tracers import AzureAIOpenTelemetryTracer
from langchain_openai import AzureChatOpenAI

load_dotenv(override=True)

# Tracer: emits spans conforming to updated OTel spec
azure_tracer = AzureAIOpenTelemetryTracer(
    connection_string=os.environ.get("APPLICATION_INSIGHTS_CONNECTION_STRING"),
    enable_content_recording=True,
    name="Trip Planner Orchestrator",
    id="trip_planner_orchestrator_v3",
)
tracers = [azure_tracer]

# Model: Azure OpenAI with callbacks for tracing
llm = AzureChatOpenAI(
    azure_deployment=os.environ.get("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_version=os.environ.get("AZURE_OPENAI_VERSION"),
    temperature=0.2,
    callbacks=tracers,
)

Anexe callbacks=[azure_tracer] às suas cadeias, ferramentas ou agentes para garantir que as operações do LangChain 0.3 são rastreadas e visíveis na Observabilidade.

Ativar o rastreio para agentes construídos no OpenAI Agents SDK

Instale os pacotes necessários:

pip install opentelemetry-sdk opentelemetry-instrumentation-openai-agents azure-monitor-opentelemetry-exporter

Use este trecho de código para configurar o rastreamento OpenTelemetry para o SDK de Agentes OpenAI e instrumentar o quadro de trabalho. Exporta para Azure Monitor se APPLICATION_INSIGHTS_CONNECTION_STRING estiver definido; caso contrário, volta para a consola.

import os
from opentelemetry import trace
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

# Configure tracer provider + exporter
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "openai-agents-app"),
})
provider = TracerProvider(resource=resource)

conn = os.getenv("APPLICATION_INSIGHTS_CONNECTION_STRING")
if conn:
    from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
    provider.add_span_processor(
        BatchSpanProcessor(AzureMonitorTraceExporter.from_connection_string(conn))
    )
else:
    provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

trace.set_tracer_provider(provider)

# Instrument the OpenAI Agents SDK
OpenAIAgentsInstrumentor().instrument(tracer_provider=trace.get_tracer_provider())

# Example: create a session span around your agent run
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("agent_session[openai.agents]"):
    # ... run your agent here
    pass

Ver trilhos no portal da Fundição

No seu projeto, vá a Rastreio para filtrar os seus registos como desejares.

Ao selecionar um rastreio, pode percorrer cada intervalo e identificar problemas enquanto observa como a sua aplicação responde. Este processo ajuda-o a depurar e identificar problemas na sua aplicação.

Ver rastreios no Azure Monitor

Se registou traços usando o excerto de código anterior, está pronto para visualizar os seus traços no Azure Monitor Application Insights. Pode abrir o Application Insights a partir de Gerir a fonte de dados e usar a vista de detalhes de transações de ponta a ponta para investigar mais detalhadamente.

Para mais informações sobre como enviar traços de inferência do Azure AI para o Azure Monitor e criar um recurso do Azure Monitor, consulte a documentação do OpenTelemetry do Azure Monitor.

Ver resultados da discussão no ambiente de teste Foundry Agents

O playground de Agentes no portal Foundry permite-te ver resultados de threads e sequências que os teus agentes produzem. Para ver os resultados das threads, selecione Thread logs numa thread ativa. Também pode, opcionalmente, selecionar Métricas para permitir avaliações automáticas do desempenho do modelo em várias dimensões da qualidade da IA e do Risco e segurança.

Depois de selecionar os registos de tópicos, reveja:

• Detalhes do tópico
• Informação sobre a corrida
• Passos de execução ordenados e chamadas de ferramentas
• Entradas e saídas entre utilizador e agente
• Métricas de avaliação ligadas (se ativadas)

Conteúdo relacionado

• Python samples contendo código de Python totalmente executável para rastreamento usando clientes síncronos e assíncronos.
• Exemplos de Python para agentes de monitorização com monitorização de consola e Azure Monitor
• exemplos JavaScript contendo código JavaScript totalmente executável para rastreamento através de clientes síncronos e assíncronos.
• C# Samples contendo código C# totalmente executável para fazer inferência usando métodos síncronos e assíncronos.