SDK de Observabilidade do Agent 365 descontinuado

Importante

Este artigo documenta o Agent 365 Observability SDK descontinuado. Integrações existentes continuam funcionando, mas não use esse SDK para novas integrações. Para novos desenvolvimentos, use o Microsoft OpenTelemetry Distro. Antes de atualizar uma integração existente, revise o guia de migração para o seu idioma:

• Guia de migração da Python
• Guia de migração de JavaScript/TypeScript
• Guia de migração do .NET

Para o modelo de dados subjacente, identidade e autenticação, escopos e consentimento, e limites que se aplicam a todo caminho de integração, veja conceitos de observabilidade do Agent 365.

Note

A observabilidade é uma das camadas de funcionalidade incremental no desenvolvimento do Agente 365 e se aplica a todos os tipos de agente.

Para participar do ecossistema Agent 365, adicione capacidades de Observabilidade do Agent 365 ao seu agente. O Agent 365 Observability se baseia no OpenTelemetry (OTel) e oferece uma estrutura unificada para capturar telemetria de forma consistente e segura em todas as plataformas de agentes. Ao implementar esse componente necessário, você permite que administradores de TI monitorem a atividade do seu agente no centro de administração da Microsoft e permitem que equipes de segurança usem o Defender e o Purview para conformidade e detecção de ameaças.

Principais benefícios

• Visibilidade de ponta a ponta: Capture telemetria abrangente para cada invocação de agente, incluindo sessões, chamadas de ferramentas e exceções, garantindo rastreabilidade total entre as plataformas.
• Habilitação de segurança e conformidade: Alimente logs de auditoria unificados no Defender e no Purview, possibilitando cenários avançados de segurança e relatórios de conformidade para seu agente.
• Flexibilidade multiplataforma: baseie-se nos padrões OTel e dê suporte a diversos runtimes e plataformas como Copilot Studio, Foundry e futuros frameworks de agentes.
• Operational efficiency for admins: fornecer observabilidade centralizada no centro de administração Microsoft 365, reduzindo o tempo de solução de problemas e melhorando a governança com controles de acesso baseados em função para as equipes de TI que gerenciam seu agente.

Agentes com suporte

Os seguintes tipos de agente dão suporte à observabilidade do Agente 365:

• Agentes habilitados para Microsoft Agent 365: use o SDK de observabilidade para instrumentar seu agente.
• Agentes de motor personalizados: use o SDK de observabilidade para instrumentar seu agente.
• Agentes declarativos: há suporte para a observabilidade pronta para uso. Nenhuma implementação do SDK é necessária.

Installation

Use esses comandos para instalar os módulos de observabilidade para as linguagens suportadas pelo Agente 365.

Python

Instale os principais pacotes de observabilidade e runtime. Todos os agentes que usam a Observabilidade do Agente 365 precisam desses pacotes.

pip install microsoft-agents-a365-observability-core
pip install microsoft-agents-a365-runtime

Se o agente usar o pacote Microsoft Agents Hosting, instale o pacote de integração de hospedagem. Ele fornece middleware que preenche automaticamente a bagagem e os escopos a partir do TurnContext, e inclui o armazenamento de tokens para o exportador de observabilidade.

pip install microsoft-agents-a365-observability-hosting

Se o agente usar uma das estruturas de IA com suporte, instale a extensão de instrumentação automática correspondente para capturar automaticamente a telemetria sem código de instrumentação manual. Para obter detalhes de configuração, consulte Instrumentação automática.

# For Semantic Kernel
pip install microsoft-agents-a365-observability-extensions-semantic-kernel

# For OpenAI Agents SDK
pip install microsoft-agents-a365-observability-extensions-openai

# For Microsoft Agent Framework
pip install microsoft-agents-a365-observability-extensions-agent-framework

# For LangChain
pip install microsoft-agents-a365-observability-extensions-langchain

JavaScript

Instale os principais pacotes de observabilidade e runtime. Todos os agentes que usam a Observabilidade do Agente 365 precisam desses pacotes.

npm install @microsoft/agents-a365-observability
npm install @microsoft/agents-a365-runtime

Se o agente usar o pacote de hospedagem de @microsoft/agentes , instale o pacote de integração de hospedagem. Ele fornece middleware que preenche automaticamente a bagagem e os escopos a partir do TurnContext, e inclui o armazenamento de tokens para o exportador de observabilidade.

npm install @microsoft/agents-a365-observability-hosting

Se o agente usar uma das estruturas de IA com suporte, instale a extensão de instrumentação automática correspondente para capturar automaticamente a telemetria sem código de instrumentação manual. Para obter detalhes de configuração, consulte Instrumentação automática.

// For OpenAI Agents SDK
npm install @microsoft/agents-a365-observability-extensions-openai

// For LangChain
npm install @microsoft/agents-a365-observability-extensions-langchain

.NET

Instale o pacote central de observabilidade e tempo de execução. Todos os agentes que usam a Observabilidade do Agente 365 precisam desse pacote.

dotnet add package Microsoft.Agents.A365.Observability.Runtime

Se o agente usar o Microsoft. Agents.A365.Observability.Hosting NuGet package, instale o pacote de integração de hospedagem. Ele fornece um middleware que preenche automaticamente a bagagem do TurnContext e inclui cache de tokens para o exportador de observabilidade.

dotnet add package Microsoft.Agents.A365.Observability.Hosting

Se o agente usar uma das estruturas de IA com suporte, instale a extensão de instrumentação automática correspondente para capturar automaticamente a telemetria sem código de instrumentação manual. Para obter detalhes de configuração, consulte Instrumentação automática.

// For Semantic Kernel
dotnet add package Microsoft.Agents.A365.Observability.Extensions.SemanticKernel

// For OpenAI
dotnet add package Microsoft.Agents.A365.Observability.Extensions.OpenAI

// For Agent Framework
dotnet add package Microsoft.Agents.A365.Observability.Extensions.AgentFramework

Configuration

Use as seguintes configurações para ativar e personalizar a Observabilidade do Agente 365 para seu agente.

Python

Defina a ENABLE_A365_OBSERVABILITY_EXPORTER variável de ambiente para a true observabilidade. No Agent 365 SDK 2.0 e posteriores, o exportador sempre usa a rota service-to-service (S2S) e autentica com o app-only configurado token_resolver. Se você ativar o exportador sem um resolver, o Python mantém o fallback do exportador de console e não envia telemetria para o Agent 365.

from microsoft_agents_a365.observability.core import configure

def token_resolver(agent_id: str, tenant_id: str) -> str | None:
    # Return a validated app-only observability token for this agent and tenant.
    return "<app-only-observability-token>"

configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    token_resolver=token_resolver,
)

O resolver de tokens é excluído do login no console.

Você pode personalizar o comportamento do exportador passando uma Agent365ExporterOptions instância para exporter_options. Quando exporter_options for fornecido, ele terá precedência sobre os parâmetros token_resolver e cluster_category.

from microsoft_agents_a365.observability.core import configure, Agent365ExporterOptions

configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    exporter_options=Agent365ExporterOptions(
        cluster_category="prod",
        token_resolver=token_resolver,
    ),
    suppress_invoke_agent_input=True,
)

A tabela a seguir descreve os parâmetros opcionais para configure().

Parâmetro	Description	Default
logger_name	Nome do logger de Python usado para depuração e saída de log do console.	microsoft_agents_a365.observability.core
exporter_options	Uma Agent365ExporterOptions instância que configura o resolvedor de token e a categoria de cluster juntos.	None
suppress_invoke_agent_input	Quando True, suprime mensagens de entrada em trechos InvokeAgent.	False

A tabela a seguir descreve as propriedades opcionais para Agent365ExporterOptions.

Property	Description	Default
use_s2s_endpoint	Obsoleto e ignorado. O Agent 365 SDK 2.0 e posteriores sempre usa a rota S2S, mesmo quando esse valor é False.	False (ignorado)
max_queue_size	Tamanho máximo da fila para o processador de lote.	2048
scheduled_delay_ms	Atraso em milissegundos entre lotes de exportação.	5000
exporter_timeout_ms	Tempo limite em milissegundos para a operação de exportação.	30000
max_export_batch_size	Tamanho máximo do lote para operações de exportação.	512

JavaScript

Defina a ENABLE_A365_OBSERVABILITY_EXPORTER variável de ambiente para a true observabilidade. No Agent 365 SDK 2.0 e posteriores, o exportador sempre usa a rota S2S e autentica com o resolvedor de token somente de aplicativo configurado. Se você ativar o exportador do Agent 365 sem um resolver, a configuração falha.

import { ObservabilityManager } from '@microsoft/agents-a365-observability';

// Define a token resolver that returns a validated app-only observability token.
const tokenResolver = (agentId, tenantId) => {
    // Your app-only token resolution logic here.
    return "your-token";
};

// Advanced configuration with builder pattern
const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

Como alternativa às variáveis de ambiente, você pode configurar a observabilidade programaticamente usando um provedor de configuração por meio do método withConfigurationProvider. Se você também usar métodos de construtor individuais (como withExporterOptions ou withClusterCategory), os métodos individuais do construtor têm precedência sobre os valores do provedor de configuração.

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { ObservabilityConfiguration } from '@microsoft/agents-a365-observability';

const configProvider = new ObservabilityConfiguration({
  isObservabilityExporterEnabled: () => true,
  // Set log levels as pipe-separated values (for example, 'info|warn|error')
  observabilityLogLevel: () => 'info|warn|error',
});

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withConfigurationProvider(configProvider)
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

Você pode personalizar o comportamento do exportador passando uma Agent365ExporterOptions instância para withExporterOptions. Essa opção permite controlar o processamento em lote e os tempos de espera. Isso não muda a rota de exportação.

import {
  ObservabilityManager,
  Agent365ExporterOptions,
} from '@microsoft/agents-a365-observability';
import { ClusterCategory } from '@microsoft/agents-a365-runtime';

const exporterOptions = new Agent365ExporterOptions();
exporterOptions.maxQueueSize = 10;

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withClusterCategory(ClusterCategory.prod)
    .withExporterOptions(exporterOptions)
    .withTokenResolver(tokenResolver)
);

builder.start();

A tabela a seguir descreve as propriedades opcionais para Agent365ExporterOptions.

Property	Description	Default
useS2SEndpoint	Obsoleto e ignorado. O SDK Agent 365 2.0 e versões posteriores sempre usa a rota S2S, mesmo quando esse valor é false.	true (ignorado)
maxQueueSize	Tamanho máximo da fila para o processador de lote.	2048
scheduledDelayMilliseconds	Atraso em milissegundos entre lotes de exportação.	5000
exporterTimeoutMilliseconds	Tempo limite em milissegundos para toda a operação de exportação.	90000
httpRequestTimeoutMilliseconds	Tempo limite em milissegundos para cada solicitação HTTP individual para o back-end.	30000
maxExportBatchSize	Tamanho máximo do lote para operações de exportação.	512

Você também pode fornecer um logger personalizado que implemente a ILogger interface (info, warn, error, event). Passe para o Builder usando withCustomLogger.

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withCustomLogger({
      info: (message, ...args) => { /* your logging logic */ },
      warn: (message, ...args) => { /* your logging logic */ },
      error: (message, ...args) => { /* your logging logic */ },
      event: (eventName, success, durationMs, message, details) => { /* your logging logic */ }
    })
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

.NET

Definir EnableAgent365Exporter como true em appsettings.json. No Agent 365 SDK 2.0 e posteriores, o exportador sempre usa a rota S2S e autentica com o resolvedor de token somente de aplicativo configurado. Se você ativar o exportador sem TokenResolver ou ContextualTokenResolver, a construção do exportador falha.

No Program.cs, adicione Agent365ExporterOptions à coleção de serviços. Essa alteração configura o delegado que o exportador de rastreamento usa para recuperar o token.

Adicione dependências relacionadas à observabilidade usando AddA365Tracing().

using Microsoft.Agents.A365.Observability.Runtime;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Exporters;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(sp =>
    {
        return new Agent365ExporterOptions
        {
            TokenResolver = async (agentId, tenantId) =>
            {
                // Return a cached, validated app-only observability token for this agent and tenant.
                var token = await tokenProvider.GetObservabilityTokenAsync(agentId, tenantId);
                return token;
            }
        };
    });

builder.AddA365Tracing();

Você pode personalizar o comportamento do exportador passando um delegado de configuração e tipo de exportador para AddA365Tracing().

builder.AddA365Tracing(
    configure: tracingBuilder =>
    {
        // Use the builder to add extensions (e.g., WithSemanticKernel(), WithOpenAI())
    },
    agent365ExporterType: Agent365ExporterType.Agent365ExporterAsync
);

A tabela a seguir descreve as propriedades opcionais para Agent365ExporterOptions.

Property	Description	Default
UseS2SEndpoint	Descontinuado e ignorado. O Agent 365 SDK 2.0 e posteriores sempre usa a rota S2S, mesmo quando esse valor é false.	false (ignorado)
MaxQueueSize	Tamanho máximo da fila para o processador de lote.	2048
ScheduledDelayMilliseconds	Atraso em milissegundos entre lotes de exportação.	5000
ExporterTimeoutMilliseconds	Tempo limite em milissegundos para a operação de exportação.	30000
MaxExportBatchSize	Tamanho máximo do lote para operações de exportação.	512

Atributos de bagagem

Use BaggageBuilder para definir informações contextuais que se propagam por todos os trechos em uma requisição. O SDK implementa um SpanProcessor que copia todas as entradas de bagagem não vazias para spans recém-iniciados sem sobrescrever atributos existentes.

Python

from microsoft_agents_a365.observability.core import BaggageBuilder

with (
    BaggageBuilder()
    .tenant_id("tenant-123")
    .agent_id("agent-456")
    .conversation_id("conv-789")
    .build()
):
    # Any spans started in this context will receive these as attributes
    pass

Para preencher automaticamente o BaggageBuilder a partir do TurnContext, use a função auxiliar populate no pacote microsoft-agents-a365-observability-hosting. Esse auxiliar extrai automaticamente os detalhes do chamador, agente, inquilino, canal e conversa da atividade.

from microsoft_agents.hosting.core.turn_context import TurnContext
from microsoft_agents_a365.observability.core import BaggageBuilder
from microsoft_agents_a365.observability.hosting.scope_helpers.populate_baggage import populate

builder = BaggageBuilder()
populate(builder, turn_context)

with builder.build():
    # Baggage is auto-populated from the TurnContext activity
    pass

JavaScript

import { BaggageBuilder } from '@microsoft/agents-a365-observability';

// Create and apply baggage context
const baggageScope = new BaggageBuilder()
  // Core identifiers
  .tenantId('tenant-123')
  .agentId('agent-456')
  .conversationId('conv-789')
  .build();

// Execute operations within the baggage context
baggageScope.run(() => {
  // All spans created within this context will inherit the baggage values

  // Invoke another agent
  const agentScope = InvokeAgentScope.start(request, scopeDetails, agentDetails);
  // ... agent logic

  // Execute tools
  const toolScope = ExecuteToolScope.start(request, toolDetails, agentDetails);
  // ... tool logic
});

Para preencher automaticamente o BaggageBuilder a partir do TurnContext, use a função auxiliar fromTurnContext no pacote @microsoft/agents-a365-observability-hosting. Esse auxiliar extrai automaticamente os detalhes do chamador, agente, inquilino, canal e conversa da atividade.

import { BaggageBuilder } from '@microsoft/agents-a365-observability';
import { BaggageBuilderUtils } from '@microsoft/agents-a365-observability-hosting';

const baggageScope = BaggageBuilderUtils.fromTurnContext(new BaggageBuilder(), context)
  .invokeAgentServer(context.activity.serviceUrl, 3978)
  .build();

await baggageScope.run(async () => {
  // Baggage is auto-populated from the TurnContext activity
});

.NET

using Microsoft.Agents.A365.Observability.Runtime.Common;

using var baggageScope = new BaggageBuilder()
    .TenantId("tenant-123")
    .AgentId("agent-456")
    .ConversationId("conv-789")
    .Build();
// Any spans started in this context will receive them as attributes.

Para preencher automaticamente o BaggageBuilder do ITurnContext, use o método de extensão FromTurnContext no pacote Microsoft.Agents.A365.Observability.Hosting. Esse método extrai automaticamente os detalhes do chamador, agente, inquilino, canal e conversa da atividade.

using Microsoft.Agents.A365.Observability.Runtime.Common;
using Microsoft.Agents.A365.Observability.Hosting.Extensions;

using var baggageScope = new BaggageBuilder()
    .FromTurnContext(turnContext)
    .Build();

Middleware de bagagem

Se o agente usar o pacote de integração de hospedagem, registre o middleware de bagagem para preencher automaticamente a bagagem para cada solicitação de entrada. Esta etapa remove a necessidade de chamar BaggageBuilder manualmente em cada manipulador de atividades.

Python

Registre BaggageMiddleware no conjunto middleware do adaptador. Ele extrai automaticamente os detalhes de chamadas, agente, locatário, canal e conversa de cada entrada TurnContext e encapsula a solicitação em um escopo de bagagem.

from microsoft_agents_a365.observability.hosting import BaggageMiddleware

adapter.use(BaggageMiddleware())

Como alternativa, use ObservabilityHostingManager para configurar o middleware de bagagem junto com outros recursos de hospedagem:

from microsoft_agents_a365.observability.hosting import ObservabilityHostingManager, ObservabilityHostingOptions

options = ObservabilityHostingOptions(enable_baggage=True)
ObservabilityHostingManager.configure(adapter.middleware_set, options)

O middleware ignora a configuração de dados adicionais para respostas assíncronas (eventos ContinueConversation) para evitar substituir as informações que a solicitação de origem já estabeleceu.

JavaScript

Registre-se BaggageMiddleware no adaptador. Ele extrai automaticamente os detalhes de chamadas, agente, locatário, canal e conversa de cada entrada TurnContext e encapsula a solicitação em um escopo de bagagem.

import { BaggageMiddleware } from '@microsoft/agents-a365-observability-hosting';

// Option 1: Register middleware directly on the adapter
adapter.use(new BaggageMiddleware());

Como alternativa, use ObservabilityHostingManager para configurar o middleware de bagagem junto com outros recursos de hospedagem:

import { ObservabilityHostingManager } from '@microsoft/agents-a365-observability-hosting';

const manager = new ObservabilityHostingManager();
manager.configure(adapter, { enableBaggage: true });

O middleware ignora a configuração de dados adicionais para respostas assíncronas (eventos ContinueConversation) para evitar substituir as informações que a solicitação de origem já estabeleceu.

.NET

Registre-se BaggageTurnMiddleware no adaptador. Ele extrai automaticamente os detalhes de chamadas, agente, locatário, canal e conversa de cada entrada ITurnContext e encapsula a solicitação em um escopo de bagagem.

using Microsoft.Agents.A365.Observability.Hosting.Middleware;

adapter.Use(new BaggageTurnMiddleware());

O middleware ignora a configuração de dados adicionais para respostas assíncronas (eventos ContinueConversation) para evitar substituir as informações que a solicitação de origem já estabeleceu.

Se você precisar de bagagem de nível HTTP (por exemplo, para definir IDs de locatário e agente antes da execução do pipeline do Bot Framework), registre ObservabilityBaggageMiddleware no pipeline do ASP.NET Core usando o método de extensão UseObservabilityRequestContext. Você deve fornecer uma função de resolvedor que extraia a ID do locatário e a ID do agente do contexto HTTP.

using Microsoft.Agents.A365.Observability.Hosting.Middleware;

app.UseObservabilityRequestContext((httpContext) =>
{
    // Extract tenant and agent IDs from your request context
    var tenantId = GetTenantIdFromContext(httpContext);
    var agentId = GetAgentIdFromContext(httpContext);
    return (tenantId, agentId);
});

Resolvedor de token

Quando você usar o exportador Agent 365 no Agent 365 SDK 2.0 e posteriores, forneça um resolvedor de token que retorne o token de observabilidade final somente de aplicativo para a instância do agente exportador. O exportador sempre envia telemetria para a rota S2S e não recorre para a rota delegada. Uma instância registrada no Agent 365 não precisa da Agent365.Observability.OtelWrite permissão ou consentimento do administrador para exportar nessa rota.

Use a troca Federated Managed Identity (FMI) em duas etapas para obter o token somente de aplicativo:

1. Obtenha um token blueprint client_credentials para api://AzureADTokenExchange/.default com fmi_path definido como o ID do cliente da instância do agente.
2. Obtenha um token agent-instance client_credentials para api://9b975845-388f-4429-889e-eab1ef63949c/.default. Passe o token do passo 1 como client_assertion, e defina client_assertion_type para urn:ietf:params:oauth:client-assertion-type:jwt-bearer.

Para a configuração completa de autenticação, veja Agent 365-enabled using S2S. Para implementações completas de serviço de token, veja os exemplos do Agente 365 para Node.js, Python e .NET.

Seu resolvedor deve:

• Devolva um token exclusivo do app para a instância e o tenant do agente exportador. Nunca devolva a asserção intermediária do blueprint, um token de blueprint, um token de usuário ou um token OBO.
• Valide o token antes de devolvê-lo. Aceite idtyp=app. Se idtyp estiver ausente, aceite apenas um token que tenha uma declaração roles não vazia ou uma declaração oid não vazia igual a sub. Rejeite tokens que tenham uma declaração scp ou outro valor idtyp, tokens expirados e tokens cujo aud não seja 9b975845-388f-4429-889e-eab1ef63949c nem api://9b975845-388f-4429-889e-eab1ef63949c.
• Armazene o token em cache e atualize-o antes que expire. O exportador chama o resolver uma vez para cada identidade de tenant e para cada identidade de agente em cada lote de exportação.

Note

Migrar do SDK 1.x: O SDK 2.0 remove a troca de tokens delegada para exportação de observabilidade. Substitua o código de token delegado no seu agente por um resolvedor exclusivo do aplicativo, como mostrado nos exemplos a seguir. Agentes que permanecem no SDK 1.x e exportam pela rota delegada ainda precisam da permissão delegada Agent365.Observability.OtelWrite e do consentimento do administrador. O a365 setup all comando não configura essa permissão para agentes de blueprint. Para concedê-la, veja Conceder a permissão.

Python

Ligue AgenticTokenCache.refresh_observability_token(agent_id, tenant_id, acquire_app_only_obs_token) no seu token_resolver. O cache passa o escopo de observabilidade /.default para o callback de aquisição e retorna o token em cache.

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.hosting.token_cache_helpers import AgenticTokenCache

cache = AgenticTokenCache()

async def acquire_app_only_obs_token(
    agent_id: str,
    tenant_id: str,
    scopes: list[str],
) -> str:
    # Run the FMI exchange described earlier, validate the token, and return it.
    return "<app-only-observability-token>"

async def token_resolver(agent_id: str, tenant_id: str) -> str:
    return await cache.refresh_observability_token(
        agent_id, tenant_id, acquire_app_only_obs_token
    )

configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    token_resolver=token_resolver,
)

Python também suporta um resolvedor síncrono que retorna um token de um cache thread-safe. Os exemplos do Agent 365 usam esse padrão, o que evita as restrições de executar um resolver assíncrono na thread exportadora.

Para migrar do SDK 1.x, remova a chamada AGENT_APP.auth.exchange_token que solicitou o escopo de observabilidade e a chamada AgenticTokenCache.register_observability que passou um AgenticTokenStruct. No SDK 2.0, register_observability é uma no-op obsoleta.

JavaScript

Usar o withTokenResolver com o AgenticTokenCacheInstance.RefreshObservabilityToken(agentId, tenantId, acquireAppOnlyObsToken). O callback de aquisição recebe (agentId, tenantId, scopes) e retorna o token final de observabilidade somente de aplicativo. Leia o token em cache com AgenticTokenCacheInstance.getObservabilityToken(agentId, tenantId).

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { AgenticTokenCacheInstance } from '@microsoft/agents-a365-observability-hosting';

async function acquireAppOnlyObsToken(
  agentId: string,
  tenantId: string,
  scopes: readonly string[]
): Promise<string> {
  // Run the FMI exchange described earlier, validate the token, and return it.
  return "<app-only-observability-token>";
}

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withTokenResolver(async (agentId, tenantId) => {
      await AgenticTokenCacheInstance.RefreshObservabilityToken(
        agentId, tenantId, acquireAppOnlyObsToken
      );
      return AgenticTokenCacheInstance.getObservabilityToken(agentId, tenantId);
    })
);

builder.start();

Para migrar do SDK 1.x, remova a chamada agentApplication.authorization.exchangeToken que solicitou o escopo de observabilidade e substitua RefreshObservabilityToken(agentId, tenantId, context, authorization, scopes) pela forma com resolvedor no exemplo. O SDK 2.0 remove a sobrecarga delegada: os chamadores TypeScript recebem um erro de compilação, e os chamadores não tipados recebem um registro de erro único e nenhum token.

.NET

Use AddAgenticTracingExporter() para registrar IExporterTokenCache<ObservabilityTokenResolver> e as opções do exportador que leem tokens do cache.

using Microsoft.Agents.A365.Observability.Hosting;

builder.Services.AddAgenticTracingExporter();

Na aplicação do agente, registre um resolvedor somente de aplicativo para o agente e o locatário, chamando RegisterObservability(agentId, tenantId, resolver, scopes). O primeiro registro para um agente e um inquilino prevalece.

using Microsoft.Agents.A365.Observability.Hosting.Caching;
using Microsoft.Agents.A365.Observability.Runtime.Common;
using Microsoft.Agents.Builder;
using Microsoft.Agents.Builder.App;
using Microsoft.Agents.Builder.State;
using System.Threading;
using System.Threading.Tasks;

public class MyAgent : AgentApplication
{
    private readonly IExporterTokenCache<ObservabilityTokenResolver> _agentTokenCache;

    public MyAgent(AgentApplicationOptions options, IExporterTokenCache<ObservabilityTokenResolver> agentTokenCache)
        : base(options)
    {
        _agentTokenCache = agentTokenCache;
    }

    protected async Task MessageActivityAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken cancellationToken)
    {
        var agentId = turnContext.Activity.Recipient.AgenticAppId;
        var tenantId = turnContext.Activity.Recipient.TenantId;

        _agentTokenCache.RegisterObservability(
            agentId,
            tenantId,
            AcquireAppOnlyObservabilityTokenAsync,
            EnvironmentUtils.GetObservabilityAuthenticationScope());

        using var baggageScope = new BaggageBuilder()
            .TenantId(tenantId)
            .AgentId(agentId)
            .Build();

        // Handle the message.
    }

    private static Task<string?> AcquireAppOnlyObservabilityTokenAsync(
        string agentId,
        string tenantId,
        string[] observabilityScopes)
    {
        // Run the FMI exchange described earlier, validate the token, and return it.
        return Task.FromResult<string?>("<app-only-observability-token>");
    }
}

Se você gerencia uma AgenticTokenCache instância diretamente, chame RefreshObservabilityToken(agentId, tenantId, resolver) para usar o escopo padrão de observabilidade, ou RefreshObservabilityToken(agentId, tenantId, resolver, scopes) para passar escopos explicitamente.

Para migrar do SDK 1.x, substitua IExporterTokenCache<AgenticTokenStruct> e a chamada RegisterObservability que passava um AgenticTokenStruct pelo resolvedor somente do app no exemplo. Não use ExchangeTurnTokenAsync para exportação de observabilidade. No SDK 2.0, a AgenticTokenStruct sobrecarga do método de registro é obsoleta e produz um erro de compilação.

Instrumentação automática

A auto-instrumentação escuta automaticamente os frameworks agenticos (SDKs), sinais de telemetria existentes para rastreios e os encaminha para o serviço de observabilidade do Agente 365. Esse recurso elimina a necessidade de os desenvolvedores escreverem código de monitoramento manualmente, simplifica a configuração e garante um acompanhamento consistente de desempenho.

Importante

A instrumentação automática popula apenas os atributos OTel padrão. Você deve adicionar atributos específicos Microsoft por meio de BaggageBuilder. Para ver quais atributos estão ausentes, valide a saída do span no console com os logs do armazenamento para identificar as diferenças.

Múltiplos SDKs e plataformas suportam auto-instrumentação:

Platform	SDKs/Frameworks suportados
.NET	Kernel semântico, OpenAI, Agent Framework
Python	Kernel semântico, OpenAI, Agent Framework, LangChain
Node.js	OpenAI, LangChain

Note

O suporte à auto-instrumentação varia conforme a plataforma e a implementação do SDK.

Núcleo Semântico

A instrumentação automática exige o uso de um construtor de baggage. Defina o ID do agente e o ID do locatário usando BaggageBuilder.

Python

Instale o pacote.

pip install microsoft-agents-a365-observability-extensions-semantic-kernel

Configurar a observabilidade

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.semantickernel.trace_instrumentor import SemanticKernelInstrumentor

# Configure observability
configure(
    service_name="my-semantic-kernel-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
instrumentor = SemanticKernelInstrumentor()
instrumentor.instrument()

# Your Semantic Kernel code is now automatically traced

JavaScript

não há suporte para Kernel semântico com JavaScript.

.NET

Adicione dependências à coleção de serviços.

using Microsoft.Agents.A365.Observability.Extensions.SemanticKernel;

builder.AddA365Tracing(configure: config => config.WithSemanticKernel());

Defina AgentId e TenantId usando BaggageBuilder. Certifique-se de que o ID que você usa ao criar um ChatCompletionAgent corresponde ao ID do agente que você passa para BaggageBuilder.

using Microsoft.Agents.A365.Observability.Extensions.SemanticKernel;
using Microsoft.Agents.A365.Observability.Runtime.Common;
public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
      
      var chatCompletionAgent = new ChatCompletionAgent
      {
          // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. Should match above.
          Id = <your-agent-id>,
          ...
      };
    }
}

OpenAI

A instrumentação automática exige o uso de um construtor de baggage. Defina o ID do agente e o ID do locatário usando BaggageBuilder.

Python

Instale o pacote.

pip install microsoft-agents-a365-observability-extensions-openai

Configurar a observabilidade

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.openai import OpenAIAgentsTraceInstrumentor

# Configure observability
configure(
    service_name="my-openai-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
instrumentor = OpenAIAgentsTraceInstrumentor()
instrumentor.instrument()

# Your OpenAI Agents code is now automatically traced

JavaScript

Instale o pacote.

npm install @microsoft/agents-a365-observability-extensions-openai

Configurar a observabilidade

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { OpenAIAgentsTraceInstrumentor } from '@microsoft/agents-a365-observability-extensions-openai';

// Configure observability first
const sdk = ObservabilityManager.configure((builder) =>
  builder
    .withService('My Agent Service', '1.0.0')
);

// Create and enable the instrumentor
const instrumentor = new OpenAIAgentsTraceInstrumentor({
  enabled: true,
  tracerName: 'openai-agents-tracer',
  tracerVersion: '1.0.0'
});

sdk.start();

instrumentor.enable();

.NET

Adicione dependências à coleção de serviços.

using Microsoft.Agents.A365.Observability.Extensions.OpenAI;

builder.AddA365Tracing(configure: config => config.WithOpenAI());

Defina AgentId e TenantId usando BaggageBuilder. Para chamadas de ferramenta, inicie um rastreamento usando Trace() em uma instância ChatToolCall.

using Microsoft.Agents.A365.Observability.Extensions.OpenAI;
using Microsoft.Agents.A365.Observability.Runtime.Common;

public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
      
      // NOTE: This will be the agent and tenant ID with which the TokenResolver delegate will be invoked. 
      using var scope = chatToolCall.Trace(agentId: <your-agent-id>, <your-tenant-id>);
    }
}

Estrutura do Agente

A instrumentação automática exige o uso de um construtor de baggage. Defina o ID do agente e o ID do inquilino usando BaggageBuilder.

Python

Instale o pacote.

pip install microsoft-agents-a365-observability-extensions-agent-framework

Configurar a observabilidade

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.agentframework import (
    AgentFrameworkInstrumentor,
)

# Configure observability
configure(
    service_name="AgentFrameworkTracingWithAzureOpenAI",
    service_namespace="AgentFrameworkTesting",
)

# Enable auto-instrumentation
AgentFrameworkInstrumentor().instrument()

JavaScript

O Agent Framework não é suportado com JavaScript.

.NET

Adicione dependências à coleção de serviços.

using Microsoft.Agents.A365.Observability.Extensions.AgentFramework;

builder.AddA365Tracing(configure: config => config.WithAgentFramework());

Defina AgentId e TenantId usando BaggageBuilder.

using Microsoft.Agents.A365.Observability.Runtime.Common;

public class MyAgent : AgentApplication
{
    protected async Task MessageActivityAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken cancellationToken)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
    }
}

Estrutura LangChain

Note

A instrumentação automática para a estrutura LangChain também dá suporte a LangGraph e Deep Agents. A mesma extensão captura automaticamente a telemetria para agentes criados com qualquer um desses frameworks.

Auto-instrumentação requer o uso do baggage builder. Defina o ID do agente e o ID do tenant usando BaggageBuilder.

Python

Instale o pacote.

pip install microsoft-agents-a365-observability-extensions-langchain

Configurar a observabilidade

from microsoft_agents_a365.observability.core.config import configure
from microsoft_agents_a365.observability.extensions.langchain import CustomLangChainInstrumentor

# Configure observability
configure(
    service_name="my-langchain-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
CustomLangChainInstrumentor()

# Your LangChain code is now automatically traced

JavaScript

Instale o pacote.

npm install @microsoft/agents-a365-observability-extensions-langchain

Configurar a observabilidade

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { LangChainTraceInstrumentor } from '@microsoft/agents-a365-observability-extensions-langchain';
import * as LangChainCallbacks from '@langchain/core/callbacks/manager';

// Configure observability first
const sdk = ObservabilityManager.configure((builder) =>
  builder
    .withService('My Agent Service', '1.0.0')
);

sdk.start();

// Enable LangChain auto-instrumentation
LangChainTraceInstrumentor.instrument(LangChainCallbacks);

// Your LangChain code is now automatically traced

.NET

Não há suporte para LangChain com .NET.

Instrumentação manual

Use o SDK de observabilidade do Agente 365 para entender o funcionamento interno do agente. O SDK fornece escopos que você pode iniciar: InvokeAgentScope, ExecuteToolScope, InferenceScope, e OutputScope.

Invocação do agente

Use esse escopo no início do processo do seu agente. Usando o escopo do agente de invocação, você pode capturar propriedades como o agente atual que está sendo invocado, dados do usuário do agente, entre outros.

Python

from microsoft_agents_a365.observability.core import (
    InvokeAgentScope,
    InvokeAgentScopeDetails,
    AgentDetails,
    CallerDetails,
    UserDetails,
    Channel,
    Request,
    ServiceEndpoint,
)

agent_details = AgentDetails(
    agent_id="agent-456",
    agent_name="My Agent",
    agent_description="An AI agent powered by Azure OpenAI",
    agentic_user_id="auid-123",
    agentic_user_email="agent@contoso.com",
    agent_blueprint_id="blueprint-789",
    tenant_id="tenant-123",
)

scope_details = InvokeAgentScopeDetails(
    endpoint=ServiceEndpoint(hostname="myagent.contoso.com", port=443),
)

request = Request(
    content="User asks a question",
    session_id="session-42",
    conversation_id="conv-xyz",
    channel=Channel(name="msteams"),
)

caller_details = CallerDetails(
    user_details=UserDetails(
        user_id="user-123",
        user_email="jane.doe@contoso.com",
        user_name="Jane Doe",
    ),
)

with InvokeAgentScope.start(request, scope_details, agent_details, caller_details):
    # Perform agent invocation logic
    response = call_agent(...)

JavaScript

import {
  InvokeAgentScope,
  InvokeAgentScopeDetails,
  AgentDetails,
  CallerDetails,
  UserDetails,
  Channel,
  Request,
  ServiceEndpoint,
} from '@microsoft/agents-a365-observability';

// Use the same agentDetails instance across all scopes in a request
const agentDetails: AgentDetails = {
  agentId: 'agent-456',
  agentName: 'Email Assistant',
  agentDescription: 'An AI agent powered by Azure OpenAI',
  agentAuid: 'auid-123',
  agentEmail: 'agent@contoso.com',
  agentBlueprintId: 'blueprint-789',
  tenantId: 'tenant-123',
};

const scopeDetails: InvokeAgentScopeDetails = {
  endpoint: { host: 'myagent.contoso.com', port: 443 } as ServiceEndpoint,
};

// Use the same request instance across all scopes in a request
const request: Request = {
  content: 'Please help me organize my emails',
  sessionId: 'session-42',
  conversationId: 'conv-xyz',
  channel: { name: 'msteams' } as Channel,
};

// Optional: Caller details (human user, or agent-to-agent)
const callerDetails: CallerDetails = {
  userDetails: {
    userId: 'user-123',
    userEmail: 'jane.doe@contoso.com',
    userName: 'Jane Doe',
  } as UserDetails,
};

const scope = InvokeAgentScope.start(request, scopeDetails, agentDetails, callerDetails);

try {
  await scope.withActiveSpanAsync(async () => {
    // Record input messages
    scope.recordInputMessages(['Please help me organize my emails', 'Focus on urgent items']);

    // Your agent invocation logic here
    const response = await invokeAgent(request.content);

    // Record output messages
    scope.recordOutputMessages(['I found 15 urgent emails', 'Here is your organized inbox']);
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Se o agente usar o @microsoft/agents-a365-observability-hosting pacote, você poderá usar ScopeUtils.populateInvokeAgentScopeFromTurnContext para criar o escopo com detalhes do agente, detalhes do chamador e informações de canal derivadas automaticamente do TurnContext.

import { InvokeAgentScopeDetails, AgentDetails, ServiceEndpoint } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const agentDetails: AgentDetails = { agentId: 'agent-456' };
const scopeDetails: InvokeAgentScopeDetails = {
  endpoint: { host: 'myagent.contoso.com', port: 443 } as ServiceEndpoint,
};

const scope = ScopeUtils.populateInvokeAgentScopeFromTurnContext(
  agentDetails,
  scopeDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    // Agent details, caller details, and channel are auto-populated from context
    const response = await invokeAgent(context.activity.text);
    scope.recordOutputMessages([response]);
  });
} finally {
  scope.dispose();
}

.NET

using System;
using System.Threading.Tasks;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
        var agentDetails = new AgentDetails(
            agentId: "agent-456",
            agentName: "MyAgent",
            agentDescription: "Handles user requests.",
            agenticUserId: "auid-123",
            agenticUserEmail: "agent@contoso.com",
            agentBlueprintId: "blueprint-789",
            tenantId: "tenant-123"
        );

        var scopeDetails = new InvokeAgentScopeDetails(
            endpoint: new Uri("https://myagent.contoso.com")
        );

        var request = new Request(
            content: userInput,
            sessionId: "session-abc",
            channel: new Channel("msteams"),
            conversationId: "conv-xyz"
        );

        var callerDetails = new CallerDetails(
            userDetails: new UserDetails(
                userId: "user-123",
                userEmail: "jane.doe@contoso.com",
                userName: "Jane Doe"
            )
        );

        // Start the scope
        using var scope = InvokeAgentScope.Start(
            request: request,
            scopeDetails: scopeDetails,
            agentDetails: agentDetails,
            callerDetails: callerDetails
        );

        // Record input messages
        scope.RecordInputMessages(new[] { userInput });

        // ... your agent logic here ...

        var output = $"Processed: {userInput}";
        scope.RecordOutputMessages(new[] { output });

        return new AgentResponse { Content = output };
    }
}

public class AgentResponse
{
    public string Content { get; set; }
}

Execução da ferramenta

Os exemplos a seguir mostram como adicionar rastreamento de observabilidade à execução da ferramenta do seu agente. Esse rastreamento captura telemetria para fins de monitoramento e auditoria.

Python

from microsoft_agents_a365.observability.core import (
    ExecuteToolScope,
    ToolCallDetails,
    Request,
    ServiceEndpoint,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

tool_details = ToolCallDetails(
    tool_name="summarize",
    tool_type="function",
    tool_call_id="tc-001",
    arguments="{'text': '...'}",
    description="Summarize provided text",
    endpoint=ServiceEndpoint(hostname="tools.contoso.com", port=8080),
)

with ExecuteToolScope.start(request, tool_details, agent_details) as scope:
    result = run_tool(tool_details)
    scope.record_response(result)

JavaScript

import { ExecuteToolScope, ToolCallDetails } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

const toolDetails: ToolCallDetails = {
  toolName: 'email-search',
  arguments: JSON.stringify({ query: 'from:boss@company.com', limit: 10 }),
  toolCallId: 'tool-call-456',
  description: 'Search emails by criteria',
  toolType: 'function',
  endpoint: {
    host: 'tools.contoso.com',
    port: 8080,  // Will be recorded since not 443
    protocol: 'https'
  },
};

const scope = ExecuteToolScope.start(request, toolDetails, agentDetails);

try {
  return await scope.withActiveSpanAsync(async () => {
    // Execute the tool
    const result = await searchEmails(toolDetails.arguments);

    // Record the tool execution result
    scope.recordResponse(result);

    return result;
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Se o agente usar o pacote @microsoft/agents-a365-observability-hosting, use ScopeUtils.populateExecuteToolScopeFromTurnContext para criar o escopo com os detalhes do agente derivados automaticamente do TurnContext.

import { ToolCallDetails } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const toolDetails: ToolCallDetails = {
  toolName: 'email-search',
  arguments: JSON.stringify({ query: 'from:boss@company.com' }),
  toolCallId: 'tool-call-456',
  toolType: 'function',
};

const scope = ScopeUtils.populateExecuteToolScopeFromTurnContext(
  toolDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    const result = await searchEmails(toolDetails.arguments);
    scope.recordResponse(JSON.stringify(result));
  });
} finally {
  scope.dispose();
}

.NET

using System;
using System.Threading.Tasks;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

var toolCallDetails = new ToolCallDetails(
    toolName: "summarize",
    arguments: "{\"text\": \"...\"}",
    toolCallId: "tc-001",
    description: "Summarize provided text",
    toolType: "function",
    endpoint: new Uri("https://tools.contoso.com:8080")
);

using var scope = ExecuteToolScope.Start(
    request: request,
    details: toolCallDetails,
    agentDetails: agentDetails
);

// ... your tool logic here ...

scope.RecordResponse("{\"summary\": \"The text was summarized.\"}");

Inferência

Os exemplos a seguir mostram como instrumentar chamadas de inferência de modelos de IA com rastreamento de observabilidade para capturar o uso de tokens, detalhes do modelo e metadados de resposta.

Python

from microsoft_agents_a365.observability.core import (
    InferenceScope,
    InferenceCallDetails,
    InferenceOperationType,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

inference_details = InferenceCallDetails(
    operationName=InferenceOperationType.CHAT,
    model="gpt-4o-mini",
    providerName="azure-openai",
    inputTokens=123,
    outputTokens=456,
    finishReasons=["stop"],
)

with InferenceScope.start(request, inference_details, agent_details) as scope:
    completion = call_llm(...)
    scope.record_output_messages([completion.text])
    scope.record_input_tokens(completion.usage.input_tokens)
    scope.record_output_tokens(completion.usage.output_tokens)

JavaScript

import { InferenceScope, InferenceDetails, InferenceOperationType } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

const inferenceDetails: InferenceDetails = {
  operationName: InferenceOperationType.CHAT,
  model: 'gpt-4o-mini',
  providerName: 'azure-openai',
};

const scope = InferenceScope.start(request, inferenceDetails, agentDetails);

try {
  return await scope.withActiveSpanAsync(async () => {
    // Record input messages
    scope.recordInputMessages(['Summarize the following emails for me...']);

    // Call the LLM
    const response = await callLLM();

    // Record detailed telemetry with granular methods
    scope.recordOutputMessages(['Here is your email summary...']);
    scope.recordInputTokens(145);
    scope.recordOutputTokens(82);
    scope.recordFinishReasons(['stop']);

    return response.text;
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Se o agente usar o @microsoft/agents-a365-observability-hosting pacote, você poderá usar ScopeUtils.populateInferenceScopeFromTurnContext para criar o escopo com detalhes do agente derivados automaticamente do TurnContext.

import { InferenceDetails, InferenceOperationType } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const inferenceDetails: InferenceDetails = {
  operationName: InferenceOperationType.CHAT,
  model: 'gpt-4o-mini',
  providerName: 'azure-openai',
};

const scope = ScopeUtils.populateInferenceScopeFromTurnContext(
  inferenceDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    const response = await callLLM();
    scope.recordOutputMessages([response.text]);
    scope.recordInputTokens(response.usage.inputTokens);
    scope.recordOutputTokens(response.usage.outputTokens);
  });
} finally {
  scope.dispose();
}

.NET

using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

var inferenceDetails = new InferenceCallDetails(
    operationName: InferenceOperationType.Chat,
    model: "gpt-4o-mini",
    providerName: "Azure OpenAI",
    inputTokens: 123,
    outputTokens: 456,
    finishReasons: new[] { "stop" }
);

using var scope = InferenceScope.Start(
    request: request,
    details: inferenceDetails,
    agentDetails: agentDetails
);

// ... your inference logic here ...

scope.RecordOutputMessages(new[] { "AI response message" });
scope.RecordInputTokens(123);
scope.RecordOutputTokens(456);

Saída

Use este escopo para cenários assíncronos onde InvokeAgentScope, ExecuteToolScope ou InferenceScope não possam capturar dados de saída sincronamente. Comece OutputScope como um intervalo filho para registrar as mensagens de saída finais após a conclusão do escopo pai.

Python

from microsoft_agents_a365.observability.core import (
    OutputScope,
    Response,
    SpanDetails,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

# Get the parent context from the originating scope
parent_context = invoke_scope.get_context()

response = Response(messages=["Here is your organized inbox with 15 urgent emails."])

with OutputScope.start(
    request,
    response,
    agent_details,
    span_details=SpanDetails(parent_context=parent_context),
):
    # Output messages are recorded automatically from the response
    pass

JavaScript

import { OutputScope, OutputResponse, SpanDetails } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

// Get the parent context from the originating scope
const parentContext = invokeScope.getSpanContext();

const response: OutputResponse = {
  messages: ['Here is your organized inbox with 15 urgent emails.'],
};

const scope = OutputScope.start(
  request,
  response,
  agentDetails,
  undefined, // userDetails
  { parentContext } as SpanDetails
);

// Output messages are recorded automatically from the response
scope.dispose();

.NET

using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

// Get the parent context from the originating scope
var parentContext = invokeScope.GetActivityContext();

var response = new Response(new[] { "Here is your organized inbox with 15 urgent emails." });

using var scope = OutputScope.Start(
    request: request,
    response: response,
    agentDetails: agentDetails,
    spanDetails: new SpanDetails(parentContext: parentContext)
);
// Output messages are recorded automatically from the response

Valide localmente

Para verificar se você integrou com sucesso com o SDK de observabilidade, examine os logs do console gerados pelo seu agente e os logs do SDK de observabilidade.

Python

Defina a variável de ambiente ENABLE_A365_OBSERVABILITY_EXPORTER como false. Essa configuração exporta os spans (traces) para o console.

Para investigar falhas de exportação, habilite o log detalhado definindo ENABLE_A365_OBSERVABILITY_EXPORTER para true e configure o log de depuração na inicialização do aplicativo:

import logging

logging.basicConfig(level=logging.DEBUG)
logging.getLogger("microsoft_agents_a365.observability.core").setLevel(logging.DEBUG)

# Or target only the exporter:
logging.getLogger(
    "microsoft_agents_a365.observability.core.exporters.agent365_exporter"
).setLevel(logging.DEBUG)

Mensagens importantes de log:

DEBUG  Token resolved for agent {agentId} tenant {tenantId}
DEBUG  Exporting {n} spans to {url}
DEBUG  HTTP 200 - correlation ID: abc-123
ERROR  Token resolution failed: {error}
ERROR  HTTP 401 exporting spans - correlation ID: abc-123
INFO   No spans with tenant/agent identity found; nothing exported.

JavaScript

Defina a variável de ambiente ENABLE_A365_OBSERVABILITY_EXPORTER como false. Essa configuração exporta os spans (traces) para o console.

Para investigar falhas de exportação, defina variáveis de ambiente no .env ou no shell:

# Enable the Agent365 exporter
ENABLE_A365_OBSERVABILITY_EXPORTER=true

# Enable verbose logging
A365_OBSERVABILITY_LOG_LEVEL=info|warn|error

Examine a saída do console para mensagens como:

[INFO]  [Agent365Exporter] Exporting 245 spans
[INFO]  [Agent365Exporter] Partitioned into 3 identity groups (2 spans skipped)
[INFO]  [Agent365Exporter] Token resolved successfully via tokenResolver
[EVENT] export-group succeeded in 98ms {"tenantId":"...","agentId":"...","correlationId":"abc-123"}
[ERROR] [Agent365Exporter] Failed with status 401, correlation ID: abc-123
[WARN]  export-partition-span-missing-identity: 5 spans skipped due to missing tenant or agent ID

Opcionalmente, use um logger personalizado para capturar eventos de exportação para um arquivo:

import { setLogger, ExporterEventNames } from '@microsoft/agents-a365-observability';

setLogger({
  info: (msg, ...args) => myLogger.info(msg, ...args),
  warn: (msg, ...args) => myLogger.warn(msg, ...args),
  error: (msg, ...args) => myLogger.error(msg, ...args),
  event: (eventType: ExporterEventNames, isSuccess: boolean, durationMs: number,
          message?: string, details?: Record<string, string>) => {
    myLogger.info({ eventType, isSuccess, durationMs, message, ...details });
  }
});

.NET

Definir EnableAgent365Exporter como false em appsettings.json. Essa configuração exporta os spans (traces) para o console.

Para investigar falhas de exportação, configure o log detalhado em appsettings.json:

{
  "EnableAgent365Exporter": "True",
  "Logging": {
    "LogLevel": {
      "Microsoft.Agents.A365.Observability": "Debug"
    }
  }
}

Ou defina variáveis de ambiente:

EnableAgent365Exporter=True
A365_OBSERVABILITY_DOMAIN_OVERRIDE=https://your-test-endpoint.example.com
A365_OBSERVABILITY_SCOPE_OVERRIDE=https://api.powerplatform.com/.default

Mensagens importantes de log:

info: Agent365ExporterCore: Obtained token for agent {agentId} tenant {tenantId}.
info: Agent365ExporterCore: Sending {count} spans to {requestUri} for agent {agentId} tenant {tenantId}.
info: Agent365ExporterCore: HTTP {statusCode} exporting spans. 'x-ms-correlation-id': '{correlationId}'.
error: Agent365Exporter: Exception exporting spans: {exception}
warn: Agent365ExporterCore: No token obtained for agent {agentId} tenant {tenantId}. Skipping export.

Note

Se você não registrar um ILoggerFactory no DI, o exportador reverterá automaticamente para um console logger.

Exibindo logs exportados

Para visualizar a telemetria do agente no Microsoft Purview ou Microsoft Defender, certifique-se de atender aos seguintes requisitos:

• Microsoft Purview: a auditoria deve ser ativada para sua organização. Para obter instruções, consulte Ativar ou desativar a auditoria.
• Microsoft Defender: a busca avançada deve ser configurada para acessar a tabela CloudAppEvents. Para obter detalhes, consulte a tabela CloudAppEvents no esquema de busca avançado.

Validar para publicação em lojas

Importante

Para validação bem-sucedida da loja, seu agente deve implementar os escopos InvokeAgentScope, InferenceScope e ExecuteToolScope. Esses três escopos são necessários para publicação.

Antes de publicar, use logs de console para validar sua integração de observabilidade para o agente, implementando os escopos necessários invoke agent, execute tool, inference, e output. Depois, compare os logs do seu agente com as seguintes listas de atributos para verificar se todos os atributos necessários estão presentes. Capture atributos em cada escopo ou através do criador de contexto, e inclua atributos opcionais segundo seu critério.

Para mais informações sobre os requisitos de publicação em loja, consulte as diretrizes de validação da loja.

atributos de InvokeAgentScope

A lista a seguir resume os atributos de telemetria necessários e opcionais registrados quando você inicia um InvokeAgentScope.

"attributes": {
        "error.type": "Optional",
        "microsoft.a365.agent.blueprint.id": "Required",
        "gen_ai.agent.description": "Optional",
        "gen_ai.agent.id": "Required",
        "gen_ai.agent.name": "Required",
        "microsoft.a365.agent.platform.id": "Optional",
        "microsoft.agent.user.email": "Required",
        "microsoft.agent.user.id": "Required",
        "gen_ai.agent.version": "Optional",
        "microsoft.a365.caller.agent.blueprint.id": "Optional",
        "microsoft.a365.caller.agent.id": "Optional",
        "microsoft.a365.caller.agent.name": "Optional",
        "microsoft.a365.caller.agent.platform.id": "Optional",
        "microsoft.a365.caller.agent.user.email": "Optional",
        "microsoft.a365.caller.agent.user.id": "Optional",
        "microsoft.a365.caller.agent.version": "Optional",
        "client.address": "Required",
        "user.id": "Required",
        "user.name": "Optional",
        "user.email": "Required",
        "microsoft.channel.link": "Optional",
        "microsoft.channel.name": "Required",
        "gen_ai.conversation.id": "Required",
        "microsoft.conversation.item.link": "Optional",
        "gen_ai.input.messages": "Required",
        "gen_ai.operation.name": "Required",
        "gen_ai.output.messages": "Required",
        "server.address": "Required",
        "server.port": "Required",
        "microsoft.session.id": "Optional",
        "microsoft.session.description": "Optional",
        "microsoft.tenant.id": "Required"
    }

atributos de ExecuteToolScope

A lista a seguir resume os atributos de telemetria necessários e opcionais registrados quando você inicia um ExecuteToolScope.

"attributes": {
        "error.type": "Optional",
        "microsoft.a365.agent.blueprint.id": "Required",
        "gen_ai.agent.description": "Optional",
        "gen_ai.agent.id": "Required",
        "gen_ai.agent.name": "Required",
        "microsoft.a365.agent.platform.id": "Optional",
        "microsoft.agent.user.email": "Required",
        "microsoft.agent.user.id": "Required",
        "gen_ai.agent.version": "Optional",
        "client.address": "Required",
        "user.id": "Required",
        "user.name": "Optional",
        "user.email": "Required",
        "microsoft.channel.link": "Optional",
        "microsoft.channel.name": "Required",
        "gen_ai.conversation.id": "Required",
        "microsoft.conversation.item.link": "Optional",
        "gen_ai.operation.name": "Required",
        "gen_ai.tool.call.arguments": "Required",
        "gen_ai.tool.call.id": "Required",
        "gen_ai.tool.call.result": "Required",
        "gen_ai.tool.description": "Optional",
        "gen_ai.tool.name": "Required",
        "gen_ai.tool.type": "Required",
        "server.address": "Optional",
        "server.port": "Optional",
        "microsoft.session.id": "Optional",
        "microsoft.session.description": "Optional",
        "microsoft.tenant.id": "Required"
    }

atributos de InferenceScope

A lista a seguir resume os atributos de telemetria necessários e opcionais registrados quando você inicia um InferenceScope.

"attributes": {
        "error.type": "Optional",
        "microsoft.a365.agent.blueprint.id": "Required",
        "gen_ai.agent.description": "Optional",
        "gen_ai.agent.id": "Required",
        "gen_ai.agent.name": "Required",
        "microsoft.a365.agent.platform.id": "Optional",
        "microsoft.a365.agent.thought.process": "Optional",
        "microsoft.agent.user.email": "Required",
        "microsoft.agent.user.id": "Required",
        "gen_ai.agent.version": "Optional",
        "client.address": "Required",
        "user.id": "Required",
        "user.name": "Optional",
        "user.email": "Required",
        "microsoft.channel.link": "Optional",
        "microsoft.channel.name": "Required",
        "gen_ai.conversation.id": "Required",
        "microsoft.conversation.item.link": "Optional",
        "gen_ai.input.messages": "Required",
        "gen_ai.operation.name": "Required",
        "gen_ai.output.messages": "Required",
        "gen_ai.provider.name": "Required",
        "gen_ai.request.model": "Required",
        "gen_ai.response.finish_reasons": "Optional",
        "gen_ai.usage.input_tokens": "Optional",
        "gen_ai.usage.output_tokens": "Optional",
        "server.address": "Optional",
        "server.port": "Optional",
        "microsoft.session.description": "Optional",
        "microsoft.session.id": "Optional",
        "microsoft.tenant.id": "Required"
    }

atributos de OutputScope

A lista a seguir resume os atributos de telemetria necessários e opcionais registrados quando você inicia um OutputScope. Use esse escopo para cenários assíncronos em que o escopo pai não pode capturar dados de saída de forma síncrona.

"attributes": {
        "microsoft.a365.agent.blueprint.id": "Required",
        "gen_ai.agent.description": "Optional",
        "gen_ai.agent.id": "Required",
        "gen_ai.agent.name": "Required",
        "microsoft.a365.agent.platform.id": "Optional",
        "microsoft.agent.user.email": "Required",
        "microsoft.agent.user.id": "Required",
        "gen_ai.agent.version": "Optional",
        "client.address": "Required",
        "user.id": "Required",
        "user.name": "Optional",
        "user.email": "Required",
        "microsoft.channel.link": "Optional",
        "microsoft.channel.name": "Required",
        "gen_ai.conversation.id": "Required",
        "microsoft.conversation.item.link": "Optional",
        "gen_ai.operation.name": "Required",
        "gen_ai.output.messages": "Required",
        "microsoft.session.id": "Optional",
        "microsoft.session.description": "Optional",
        "microsoft.tenant.id": "Required"
    }

Teste seu agente com observabilidade

Depois de implementar a observabilidade em seu agente, teste-a para garantir que ela capture a telemetria corretamente. Siga o guia de testes para configurar seu ambiente. Em seguida, concentre-se principalmente na seção Exibir logs de observabilidade para validar se sua implementação de observabilidade está funcionando conforme o esperado.

Verificação:

• Vá para: https://admin.cloud.microsoft/#/agents/all
• Selecione sua agente > Atividade
• Você vê sessões e invocações de ferramentas

Troubleshooting

Esta seção descreve problemas comuns ao implementar e utilizar observabilidade.

Problema	Description
Os dados de observabilidade não são exibidos	Nenhuma telemetria é visível porque a exportação não está habilitada, a configuração está incorreta ou a resolução do token falha.
ID do locatário ou do agente ausente – trechos ignorados	Spans são descartados antes da exportação quando os atributos de identidade necessários para o particionamento estão ausentes.
Falha de resolução de token – exportação ignorada ou não autorizada	A exportação falha quando o resolver não retorna um token ou encontra uma exceção.
HTTP 401 Não Autorizado	A autenticação é bem-sucedida do ponto de vista sintático, mas o token é inválido para a ingestão devido ao escopo, tipo ou expiração.
HTTP 403 Proibido	O acesso é negado devido a lacunas na licença do locatário, falta de registro no Agent 365 ou falta de permissão de observabilidade quando é necessária.
HTTP 403 Proibido – Incompatibilidade da ID do agente	A solicitação é rejeitada quando a identidade do agente na URL não corresponde à identidade representada pelo token.
Erros HTTP 429 ou 5xx – Erros transitórios	A limitação temporária ou falhas no serviço interrompem a exportação e podem exigir ajustes nas tentativas de repetição.
Tempo limite de exportação	Os lotes de telemetria ultrapassam os limites de tempo configurados devido à latência da rede ou ao tempo de resposta do ponto de extremidade.
A exportação é bem-sucedida, mas a telemetria não aparece no Defender ou no Purview	A ingestão é concluída, mas a visibilidade nas etapas posteriores sofre atraso ou é bloqueada devido a pré-requisitos do produto.

Dica

O Guia de Solução de Problemas do Agente 365 contém recomendações de resolução de problemas de alto nível, melhores práticas e links para conteúdo de solução de problemas para cada parte do ciclo de desenvolvimento do Agente 365.

Os dados de observabilidade não aparecem

Sintomas:

• O agente está correndo
• Sem telemetria no centro administrativo
• Não consigo ver a atividade dos agentes

Causa raiz:

• A observabilidade não é ativada
• Erros de configuração
• Problemas do resolvedor de tokens

Soluções: Tente os seguintes passos para resolver o problema:

• Verificar se o exportador de observabilidade está habilitado

  Você deve habilitar explicitamente o exportador do Agente 365. Quando desabilitado, o SDK volta para um exportador de console e a telemetria não é enviada ao serviço. Para obter detalhes de configuração, consulte Configuração.

• Verifique a configuração do resolver de tokens

  O exportador requer um resolvedor de token válido que retorne um token de observabilidade somente do aplicativo a cada solicitação de exportação. Se o resolver estiver ausente, não retornar nenhum token ou gerar uma exceção, a exportação não envia uma solicitação. Certifique-se de que seu código implemente o resolvedor de tokens. Para obter detalhes, consulte Resolvedor de tokens.

• Verifique se há erros nos logs

  Habilite o log detalhado e use o comando az webapp log tail para buscar nos logs por erros relacionados à observabilidade. Para obter detalhes sobre como habilitar o logging para cada plataforma, consulte Validar localmente.

  # Look for observability-related errors
  az webapp log tail --name <your-app-name> --resource-group <your-resource-group> | Select-String "observability"
  

• Verificar exportação de telemetria

  Confirme que a telemetria foi gerada e exportada conforme esperado.

  • Adicione um exportador de console e verifique se a telemetria é gerada localmente. Para obter detalhes sobre como usar o exportador de console e validar a saída, consulte Validar localmente.

ID do locatário ou ID do agente ausente – intervalos ignorados

Sintomas: O sistema descarta silenciosamente intervalos e nunca os exporta. Alguns SDKs registram uma contagem de spans ignorados ou uma mensagem como "Nenhum span com a identificação de locatário/agente encontrada". Outros os descartam sem logar.

Solução:

• Antes da exportação, as partições do SDK abrangem a identidade do locatário e do agente. O sistema descarta segmentos que não têm uma ID de locatário ou uma ID de agente e nunca os envia para o serviço.
• Verifique se BaggageBuilder está configurado com a ID do locatário e a ID do agente antes de criar intervalos. Esses valores se propagam por meio do contexto OpenTelemetry e são anexados a todos os intervalos criados dentro do escopo da bagagem. Para a API específica da plataforma, consulte atributos de bagagem.
• Confirme se a TurnContext atividade tem um destinatário válido com a identidade do agente, caso você use o middleware de bagagem ou o auxiliar de contexto do pacote de integração de hospedagem para preencher essas IDs.

Falha no processamento de token – exportação ignorada ou não autorizada

Sintomas: O resolver de tokens retorna null, retorna um token vazio ou lança um erro. A exportação falha sem enviar uma solicitação, e o exportador não recorre à rota delegada.

Solução:

• Forneça um resolver que retorne o token final de observabilidade somente de aplicativo para a instância e o tenant do agente exportador.
• Verifique se a ID do locatário correta e a ID do agente são usadas para BaggageBuilder, porque esses valores são passados para o resolvedor de token.
• Verifique o comportamento de inicialização específico da linguagem. Node.js falha na configuração quando o exportador Agent 365 está ativado sem um resolvedor, .NET falha na construção do exportador e Python retorna ao exportador do console quando nenhum resolvedor está configurado.
• Verifique se seu resolver valida o token antes de devolvê-lo. Deve rejeitar tokens delegados com um claim scp e tokens emitidos para o público errado.

HTTP 401 Não Autorizado

Sintomas: A exportação falha com HTTP 401. O exportador não tenta novamente esse erro.

Solução:

• Verifique se o claim aud do token é 9b975845-388f-4429-889e-eab1ef63949c ou api://9b975845-388f-4429-889e-eab1ef63949c.
• Verifique se o resolvedor de tokens não está retornando um token de usuário delegado, um token com uma reivindicação scp, um token para um público incorreto ou um token expirado.
• Confirme que o resolvedor retorna o token agente final de instância, e não a asserção intermediária do blueprint.

HTTP 403 Proibido

Sintomas: A exportação falha com HTTP 403. O exportador não tenta novamente esse erro.

Causa raiz: Um erro HTTP 403 pode ter causas diferentes. Verifique as resoluções a seguir na ordem correta.

Solução:

• Missing license — verifique se seu locatário tem uma das seguintes licenças atribuídas no Centro de administração do Microsoft 365:

  • Teste - Microsoft 365 E7
  • Microsoft 365 E7
  • Microsoft Agent 365 Frontier

• A instância do agente não está registrada — A rota S2S aceita um token somente de aplicativo sem a função Agent365.Observability.OtelWrite apenas de uma instância de agente registrada no Agent 365. Caso contrário, retorna HTTP 403 insufficient_scope. Para agentes blueprint, a365 setup all registra a instância do agente. Para tentar novamente um registro falhado, execute a365 setup all --agent-registration-only. Criar uma identidade Microsoft Entra, por si só, não registra a instância do agente.

• O token não é exclusivo de aplicativos — Verifique se o token não inclui uma claim scp. A rota S2S requer um token somente de aplicativo.

• Identidade não registrada não possui o papel do aplicativo — Identidades não registradas, incluindo os registros padrão de aplicativos que os agentes do motor personalizado usam, precisam do Agent365.Observability.OtelWrite papel do aplicativo. Para concedê-la, veja Conceder a permissão.

• Agente SDK 1.x na rota delegada — A rota delegada precisa da permissão delegada Agent365.Observability.OtelWrite e do consentimento do administrador, que a365 setup all não configura para agentes de blueprint. Atualize para o SDK 2.0 ou conceda a permissão.

• O ID do agente não corresponde ao token — Veja HTTP 403 Forbidden - Incompatibilidade no ID do agente.

HTTP 403 Proibido — incompatibilidade no ID do agente

Sintomas: A exportação falha com HTTP 403 e uma mensagem do servidor semelhante a 403 Forbidden, com falhas agent-ID-mismatch ao chamar os endpoints de rastreamento do Agent 365.

Causa principal: Esse erro ocorre quando você usa o ID do cliente do blueprint em vez do ID do cliente da instância do agente ao configurar os detalhes do agente. A ID do agente na URL de exportação não corresponde à identidade autorizada pelo token, portanto, o ponto de extremidade de rastreamento rejeita a solicitação.

Solução:

• Verifique se a ID do locatário foi adicionada à lista de locatários permitidos do Agente 365.
• Defina os detalhes do agente usando o ID do cliente da instância do agente (não o ID do cliente do blueprint).
• Verifique a URL de exportação gerada — ela é registrada se você habilitar o logger. Confirme se o ID do agente na URL corresponde ao ID do cliente da instância de agente.
• Para habilitar o registro de diagnóstico para cada SDK, consulte Validar localmente.

Erros HTTP 429 ou 5xx – Erros transitórios

Sintomas: A exportação falha com um código de status HTTP transitório, como 429 ou 5xx.

Solução:

• Esses erros geralmente são transitórios e resolvidos por conta própria. Os SDKs Python e JavaScript realizam tentativas automáticas novamente em códigos de status HTTP 408, 429 e 5xx até três vezes com recuo exponencial. O SDK do .NET não tenta novamente automaticamente.
• Se os erros persistirem, verifique o painel de integridade do serviço.
• Considere reduzir a frequência de exportação aumentando o atraso agendado entre lotes ou aumentando o tamanho máximo do lote de exportação. Para obter opções de configuração por plataforma, consulte a Agent365ExporterOptions tabela em Configuração.

Tempo limite de exportação

Sintomas: Tempo limite de tentativas de exportação.

Solução:

• Verifique a conectividade de rede com o endpoint de observabilidade.
• Os padrões de tempo limite variam de acordo com a plataforma. O tempo limite de solicitação HTTP padrão é de 30 segundos. Alguns SDKs também têm um tempo limite global separado do exportador que abrange todo o ciclo de exportação, incluindo novas tentativas. Para obter as propriedades exatas e os padrões por plataforma, consulte a Agent365ExporterOptions tabela em Configuração.
• Se os tempos limite ocorrerem com frequência, aumente o valor de tempo limite relevante nas opções do exportador.

A exportação é bem-sucedida, mas a telemetria não aparece no Defender ou no Purview

Symptoms: Os logs indicam uma exportação bem-sucedida, mas a telemetria não está visível no Microsoft Defender ou Microsoft Purview.

Solução:

• Verifique se você atende aos pré-requisitos para exibir logs exportados. Para o Purview, a auditoria deve ser ativada. Para Defender, você deve configurar a busca avançada. Para obter mais informações, consulte Visualização de logs exportados.
• A telemetria pode levar vários minutos para ser atualizada após uma exportação bem-sucedida. Aguarde até que os dados apareçam antes de investigar mais.

Para saber mais sobre como testar a observabilidade, confira:

• Guia de testes - Veja os registros de observabilidade
• Configuração de observabilidade

Conteúdo relacionado

• Conceitos de observabilidade do Agente 365 – Fluxo de dados, modelos de identidade, autenticação, escopos e limites que se aplicam a cada caminho de integração.
• Referência de atributo de observabilidade do Agente 365 – esquema de atributo de intervalo canônico ao qual cada intervalo ingerido pelo Agente 365 deve estar em conformidade.
• Microsoft OpenTelemetry Distro – O SDK unificado recomendado para novas integrações.