Observabilité de l’agent

Important

Vous devez faire partie du programme de préversion Frontier pour obtenir un accès anticipé à Microsoft Agent 365. Frontier vous connecte directement avec les dernières innovations ia de Microsoft. Les versions préliminaires Frontier sont soumises aux conditions existantes de vos contrats clients qui régissent les versions préliminaires. Comme ces fonctionnalités sont encore en cours de développement, leur disponibilité et leurs capacités peuvent évoluer au fil du temps.

Pour participer à l’écosystème Agent 365, ajoutez des capacités d’observabilité Agent 365 à votre agent. Agent 365 Observability s’appuie sur OpenTelemetry (OTel) et offre un cadre unifié pour capturer la télémétrie de manière cohérente et sécurisée sur toutes les plateformes agents. En implémentant ce composant requis, vous allez autoriser les administrateurs informatiques à surveiller l'activité de votre agent dans Microsoft centre d'administration et à autoriser les équipes de sécurité à utiliser Defender et Purview pour la conformité et la détection des menaces.

Principaux avantages

Visibilité de bout en bout : Capturez une télémétrie complète pour chaque invocation d’agent, y compris les sessions, appels d’outils et exceptions, vous offrant ainsi une traçabilité complète sur toutes les plateformes.
Activation de la sécurité et de la conformité : alimentez les journaux d’audit unifiés dans Defender et Purview, ce qui permet des scénarios de sécurité avancés et des rapports de conformité pour votre agent.
Flexibilité multiplateforme : Reposez-vous sur les normes OTel et prenez en charge divers environnements d'exécution et plateformes tels que Copilot Studio, Foundry, et les futures infrastructures d'agent.
Efficacité opérationnelle pour les administrateurs : fournissez une observabilité centralisée dans le centre d'administration de Microsoft 365, réduisant le temps de dépannage et améliorant la gouvernance avec des contrôles d'accès basés sur les rôles pour les équipes informatiques qui gèrent votre agent.

Agents pris en charge

Les types d’agents suivants prennent en charge l’observabilité d’Agent 365 :

Agents compatibles avec Microsoft Agent 365 : utilisez le Kit de développement logiciel (SDK) d’observabilité pour instrumenter votre agent.
Agents de moteur personnalisés : utilisez le Kit de développement logiciel (SDK) d’observabilité pour instrumenter votre agent.
Agents déclaratifs : l’observabilité est prise en charge hors de la boîte de dialogue. Aucune implémentation du Kit de développement logiciel (SDK) n’est requise.

Installation

Utilisez ces commandes pour installer les modules d’observabilité pour les langues prises en charge par Agent 365.

Installez les packages d’observabilité et d’exécution de base. Tous les agents qui utilisent l’observabilité de l’agent 365 ont besoin de ces packages.

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

Si votre agent utilise le package Microsoft Agents Hosting, installez le package d’intégration d’hébergement. Il fournit un intergiciel qui remplit automatiquement les bagages et les étendues à partir de TurnContext, et inclut la mise en cache des jetons pour l’exportateur d’observabilité.

pip install microsoft-agents-a365-observability-hosting

Si votre agent utilise l’une des infrastructures IA prises en charge, installez l’extension d’instrumentation automatique correspondante pour capturer automatiquement les données de télémétrie sans code d’instrumentation manuel. Pour plus d’informations sur la configuration, consultez l’instrumentation automatique.

# 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

Installez les packages d’observabilité et d’exécution de base. Tous les agents qui utilisent l’observabilité de l’agent 365 ont besoin de ces packages.

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

Si votre agent utilise le package d’hébergement @microsoft/agents , installez le package d’intégration d’hébergement. Il fournit un intergiciel qui remplit automatiquement les bagages et les étendues à partir de TurnContext, et inclut la mise en cache des jetons pour l’exportateur d’observabilité.

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

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

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

Installez le package d’observabilité et d’exécution de base. Tous les agents qui utilisent Agent 365 Observability ont besoin de ce package.

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

Si votre agent utilise le Microsoft. Agents.A365.Observability.Hosting NuGet package, installez le package d’intégration d’hébergement. Il fournit un intergiciel qui remplit automatiquement les bagages à partir de TurnContext, et inclut la mise en cache des jetons pour l’exportateur d’observabilité.

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

// 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

Utilisez les paramètres suivants pour activer et personnaliser l’observabilité de l’Agent 365 pour votre agent.

Fixer la ENABLE_A365_OBSERVABILITY_EXPORTER variable environnement à true pour l’observabilité. Ce paramètre exporte les journaux vers le service et nécessite qu’un token_resolver soit fourni. Sinon, l’exportateur console est utilisé.

from microsoft_agents_a365.observability.core import configure

def token_resolver(agent_id: str, tenant_id: str) -> str | None:
    # Implement secure token retrieval here
    return "Bearer <token>"

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

Le résolveur de jeton est exclu de la connexion à la console.

Vous pouvez personnaliser le comportement de l’exportateur en passant une Agent365ExporterOptions instance à exporter_options. Quand exporter_options est fourni, il prend le pas sur les paramètres token_resolver et 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,
)

Le tableau suivant décrit les paramètres facultatifs pour configure().

Paramètre	Description	Par défaut
`logger_name`	Nom de l’enregistreur d’événements Python utilisé pour le débogage et la sortie du journal de la console.	`microsoft_agents_a365.observability.core`
`exporter_options`	Instance `Agent365ExporterOptions` qui configure ensemble le résolveur de jetons et la catégorie de cluster.	`None`
`suppress_invoke_agent_input`	Lorsque `True`, les messages d’entrée dans les étendues `InvokeAgent` sont supprimés.	`False`

Le tableau suivant décrit les propriétés facultatives pour Agent365ExporterOptions.

Propriété	Description	Par défaut
`use_s2s_endpoint`	Lorsque `True`, le chemin du point de terminaison de service à service est utilisé.	`False`
`max_queue_size`	Taille de file d’attente maximale pour le processeur par lots.	`2048`
`scheduled_delay_ms`	Retard en millisecondes entre les lots d’exportation.	`5000`
`exporter_timeout_ms`	Délai d’expiration en millisecondes pour l’opération d’exportation.	`30000`
`max_export_batch_size`	Taille de lot maximale pour les opérations d’exportation.	`512`

Fixer la ENABLE_A365_OBSERVABILITY_EXPORTER variable environnement à true pour l’observabilité. Ce paramètre exporte les journaux d’activité vers le service et nécessite qu’un résolveur de jeton soit fourni. Sinon, l’exportateur console est utilisé.

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

// Define a token resolver to authenticate with the observability service for exporting logs
const tokenResolver = (agentId, tenantId) => {
    // Your 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();

En guise d’alternative aux variables d’environnement, vous pouvez configurer l’observabilité par programmation à l’aide d’un fournisseur de configuration par le biais withConfigurationProvider de la méthode. Si vous utilisez également des méthodes de générateur individuelles (par exemple withExporterOptionswithClusterCategory), les méthodes de générateur individuelles sont prioritaires sur les valeurs du fournisseur de configuration.

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();

Vous pouvez personnaliser le comportement de l’exportateur en passant une Agent365ExporterOptions instance à withExporterOptions. Cette option vous permet de contrôler le traitement par lots, les délais d’attente et le mode de routage.

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();

Le tableau suivant décrit les propriétés facultatives pour Agent365ExporterOptions.

Propriété	Description	Par défaut
`useS2SEndpoint`	Lorsque `true`, le chemin du point de terminaison de service à service est utilisé.	`false`
`maxQueueSize`	Taille de file d’attente maximale pour le processeur par lots.	`2048`
`scheduledDelayMilliseconds`	Retard en millisecondes entre les lots d’exportation.	`5000`
`exporterTimeoutMilliseconds`	Délai d’expiration en millisecondes pour l’ensemble de l’opération d’exportation.	`90000`
`httpRequestTimeoutMilliseconds`	Délai d’expiration en millisecondes pour chaque requête HTTP individuelle vers le back-end.	`30000`
`maxExportBatchSize`	Taille de lot maximale pour les opérations d’exportation.	`512`

Vous pouvez également fournir un enregistreur personnalisé qui implémente l’interface ILogger (info, warn, error, event). Passez-le au constructeur en utilisant 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();

Définissez EnableAgent365Exporter sur true dans appsettings.json.

Dans Program.cs, ajoutez Agent365ExporterOptions à la collection de services. Cette modification configure le délégué que l’exportateur de trace utilise pour récupérer le jeton.

Ajouter des dépendances liées à l’observabilité en utilisant 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) =>
            {
                // It's recommended to implement caching in your token provider for performance.
                var token = await tokenProvider.GetObservabilityTokenAsync(agentId, tenantId);
                return token;
            }
        };
    });

builder.AddA365Tracing();

Vous pouvez personnaliser le comportement de l’exportateur en passant un délégué de configuration et un type d’exportateur à AddA365Tracing().

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

Le tableau suivant décrit les propriétés facultatives pour Agent365ExporterOptions.

Propriété	Description	Par défaut
`UseS2SEndpoint`	Lorsque `true`, le chemin du point de terminaison de service à service est utilisé.	`false`
`MaxQueueSize`	Taille de file d’attente maximale pour le processeur par lots.	`2048`
`ScheduledDelayMilliseconds`	Retard en millisecondes entre les lots d’exportation.	`5000`
`ExporterTimeoutMilliseconds`	Délai d’expiration en millisecondes pour l’opération d’exportation.	`30000`
`MaxExportBatchSize`	Taille de lot maximale pour les opérations d’exportation.	`512`

Attributs des bagages

Utilisez BaggageBuilder pour définir des informations contextuelles qui transitent par toutes les portées d’une requête. Le kit de développement logiciel (SDK) implémente une SpanProcessor et copie de toutes les entrées de bagages sans avoir à remplacer les attributs existants.

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

Pour remplir automatiquement le BaggageBuilder à partir du TurnContext, utilisez l’outil populate dans le package microsoft-agents-a365-observability-hosting. Cet utilitaire extrait automatiquement l’appelant, l’assistant, le locataire, le canal et les détails de conversation de l’activité.

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

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
});

Pour remplir automatiquement le BaggageBuilder à partir du TurnContext, utilisez l’outil fromTurnContext dans le package @microsoft/agents-a365-observability-hosting. Cet utilitaire extrait automatiquement l’appelant, l’assistant, le locataire, le canal et les détails de conversation de l’activité.

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
});

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.

Pour remplir automatiquement le BaggageBuilder à partir du ITurnContext, utilisez la méthode d’extension FromTurnContext dans le package Microsoft.Agents.A365.Observability.Hosting. Cette méthode extrait automatiquement l’appelant, l’assistant, le locataire, le canal et les détails de conversation de l’activité.

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

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

Intergiciels de bagages

Si votre agent utilise le package d’intégration d’hébergement, inscrivez l’intergiciel des bagages pour remplir automatiquement les bagages pour chaque demande entrante. Cette étape supprime la nécessité d’appeler BaggageBuilder manuellement dans chaque gestionnaire d’activités.

Enregistrez BaggageMiddleware dans l'ensemble de middlewares de l'adaptateur. Il extrait automatiquement l’appelant, l’agent, le locataire, le canal et les détails de conversation de chaque entrant TurnContext et encapsule la demande dans une étendue de bagages.

from microsoft_agents_a365.observability.hosting import BaggageMiddleware

adapter.use(BaggageMiddleware())

Vous pouvez également utiliser ObservabilityHostingManager pour configurer le middleware de gestion des bagages avec d'autres fonctionnalités d'hébergement.

from microsoft_agents_a365.observability.hosting import ObservabilityHostingManager, ObservabilityHostingOptions

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

L’intergiciel ignore la configuration des bagages pour les réponses asynchrones (ContinueConversation événements) afin d’éviter de remplacer les bagages que la demande d’origine a déjà définie.

Enregistrez BaggageMiddleware sur l’adaptateur. Il extrait automatiquement l’appelant, l’agent, le locataire, le canal et les détails de conversation de chaque entrant TurnContext et encapsule la demande dans une étendue de bagages.

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

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

Vous pouvez également utiliser ObservabilityHostingManager pour configurer le middleware de gestion des bagages avec d'autres fonctionnalités d'hébergement.

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

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

Enregistrez BaggageTurnMiddleware sur l’adaptateur. Il extrait automatiquement l’appelant, l’agent, le locataire, le canal et les détails de conversation de chaque entrant ITurnContext et encapsule la demande dans une étendue de bagages.

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

adapter.Use(new BaggageTurnMiddleware());

Si vous avez besoin d'un bagage au niveau HTTP (par exemple, pour définir des ID de locataire et d’agent avant l’exécution du pipeline Bot Framework), enregistrez ObservabilityBaggageMiddleware dans le pipeline ASP.NET Core à l’aide de la méthode d’extension UseObservabilityRequestContext. Vous devez fournir une fonction de programme de résolution qui extrait l’ID de locataire et l’ID de l’agent à partir du contexte 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);
});

Programme de résolution de jetons

Lorsque vous utilisez l’exportateur Agent 365, vous devez fournir une fonction de programme de résolution de jeton qui retourne un jeton d’authentification. Lorsque vous utilisez le SDK Observability Agent 365 avec le framework d'hébergement Agent, vous pouvez générer des jetons à l'aide de TurnContext provenant des activités de l’agent.

L’extrait de code suivant montre comment un jeton peut être généré à l’aide du microsoft_agents.hosting.core Kit de développement logiciel (SDK). Le jeton d’authentification généré ici est utilisé pour exporter les étendues vers le service d’ingestion A365. Les agents sont libres de générer eux-mêmes un jeton, par exemple à l’aide de la bibliothèque d’authentification Microsoft (MSAL), mais ils doivent s’assurer que le jeton a l’étendue d’observabilité.

from microsoft_agents.activity import load_configuration_from_env
from microsoft_agents.authentication.msal import MsalConnectionManager
from microsoft_agents.hosting.aiohttp import CloudAdapter
from microsoft_agents.hosting.core import (
    AgentApplication,
    Authorization,
    MemoryStorage,
    TurnContext,
    TurnState,
)
from microsoft_agents_a365.runtime import (
    get_observability_authentication_scope,
)

agents_sdk_config = load_configuration_from_env(environ)

STORAGE = MemoryStorage()
CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config)
ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER)
ADAPTER.use(TranscriptLoggerMiddleware(ConsoleTranscriptLogger()))
AUTHORIZATION = Authorization(STORAGE, CONNECTION_MANAGER, **agents_sdk_config)

AGENT_APP = AgentApplication[TurnState](
    storage=STORAGE, adapter=ADAPTER, authorization=AUTHORIZATION, **agents_sdk_config
)

@AGENT_APP.activity("message", auth_handlers=["AGENTIC"])
async def on_message(context: TurnContext, _state: TurnState):
    aau_auth_token = await AGENT_APP.auth.exchange_token(
                        context,
                        scopes=get_observability_authentication_scope(),
                        auth_handler_id="AGENTIC",
                    )
    # cache this auth token and return via token resolver

Pour un agent créé avec la CLI A365 qui utilise un agent IA et le package Bibliothèque d’hébergement d’observabilité Microsoft Agent 365, utilisez AgenticTokenCache pour gérer automatiquement la mise en cache des jetons. Enregistrez le jeton une fois par assistant et par locataire dans un gestionnaire d’activité, puis passez cache.get_observability_token comme token_resolver dans votre configuration d’observabilité.

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.hosting.token_cache_helpers import (
    AgenticTokenCache,
    AgenticTokenStruct,
)
from microsoft_agents_a365.runtime import get_observability_authentication_scope

# Create a shared cache instance
token_cache = AgenticTokenCache()

# Use the cache as your token resolver in configure()
configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    token_resolver=token_cache.get_observability_token,
)

@AGENT_APP.activity("message", auth_handlers=["AGENTIC"])
async def on_message(context: TurnContext, _state: TurnState):
    token_cache.register_observability(
        agent_id="agent-456",
        tenant_id="tenant-123",
        token_generator=AgenticTokenStruct(
            authorization=AGENT_APP.auth,
            turn_context=context,
        ),
        observability_scopes=get_observability_authentication_scope(),
    )

L’extrait de code suivant montre comment un jeton peut être généré à l’aide du @microsoft/agents-hosting Kit de développement logiciel (SDK). Le jeton d’authentification généré ici est utilisé pour exporter les étendues vers le service d’ingestion A365. Les agents sont libres de générer eux-mêmes un jeton, par exemple à l’aide de la bibliothèque d’authentification Microsoft (MSAL), mais ils doivent s’assurer que le jeton a l’étendue d’observabilité.

import {
  TurnState,
  AgentApplication,
  MemoryStorage,
  TurnContext,
} from '@microsoft/agents-hosting';
import { ActivityTypes } from '@microsoft/agents-activity';
import { getObservabilityAuthenticationScope } from '@microsoft/agents-a365-runtime';

interface ConversationState {
  count: number;
}
type ApplicationTurnState = TurnState<ConversationState>;

const storage = new MemoryStorage();

export const agentApplication = new AgentApplication<ApplicationTurnState>({
  authorization: {
    agentic: {}, // We have the type and scopes set in the .env file
  },
  storage,
});

agentApplication.onActivity(
  ActivityTypes.Message,
  async (context: TurnContext, state: ApplicationTurnState) => {
    const aauAuthToken = await agentApplication.authorization.exchangeToken(context, 'agentic', {
      scopes: getObservabilityAuthenticationScope()
    });
    // cache this auth token and return via token resolver
  }
);

Pour un agent créé avec l'interface CLI A365 qui utilise un coéquipier IA et le package @microsoft/agents-a365-observability-hosting, utilisez AgenticTokenCacheInstance pour gérer automatiquement la mise en cache des jetons. Appelez RefreshObservabilityToken une fois par agent et par locataire pendant un gestionnaire d’activités, puis passez AgenticTokenCacheInstance.getObservabilityToken en tant que tokenResolver dans votre configuration d’observabilité.

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

// Use the cache as your token resolver in configure()
const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withTokenResolver((agentId, tenantId) =>
      AgenticTokenCacheInstance.getObservabilityToken(agentId, tenantId)
    )
);

builder.start();

agentApplication.onActivity(
  ActivityTypes.Message,
  async (context: TurnContext, state: ApplicationTurnState) => {
    const agentId = context.activity.recipient?.agenticAppId || '';
    const tenantId = context.activity.recipient?.tenantId || '';

    await AgenticTokenCacheInstance.RefreshObservabilityToken(
      agentId,
      tenantId,
      context,
      agentApplication.authorization,
      getObservabilityAuthenticationScope()
    );
  }
);

L’extrait de code suivant montre comment générer un jeton à l’aide du Microsoft.Agents Kit de développement logiciel (SDK) d’hébergement. Utilisez le jeton d'authentification que vous générez pour exporter les segments vers le service d'ingestion A365. Les agents peuvent générer eux-mêmes un jeton, par exemple à l’aide de la bibliothèque d’authentification Microsoft (MSAL), mais ils doivent s’assurer que le jeton a l’étendue d’observabilité.

Fournissez un résolveur de jetons en enregistrant Agent365ExporterOptions avec un délégué TokenResolver. Le délégué reçoit le agentId et le tenantId et retourne un jeton d’authentification.

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

builder.Services.AddSingleton(sp =>
    {
        return new Agent365ExporterOptions
        {
            TokenResolver = async (agentId, tenantId) =>
            {
                // Implement your token retrieval logic here
                return await GetTokenAsync(agentId, tenantId);
            }
        };
    });

Pour un agent créé avec le CLI A365 qui utilise une IA coéquipière et le package NuGet Microsoft.Agents.A365.Observability.Hosting, utilisez la méthode AddAgenticTracingExporter() pour gérer automatiquement la mise en cache des jetons grâce à l’injection de dépendances.

using Microsoft.Agents.A365.Observability.Hosting;

builder.Services.AddAgenticTracingExporter();

Dans l’application de l’assistant, inscrivez le jeton.

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

public class MyAgent : AgentApplication
{
    private readonly IExporterTokenCache<AgenticTokenStruct> _agentTokenCache;
    private readonly ILogger<MyAgent> _logger;

    public MyAgent(AgentApplicationOptions options, IExporterTokenCache<AgenticTokenStruct> agentTokenCache, ILogger<MyAgent> logger)
        : base(options)
    {
        _agentTokenCache = agentTokenCache ?? throw new ArgumentNullException(nameof(agentTokenCache));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    protected async Task MessageActivityAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken cancellationToken)
    {
        using var baggageScope = new BaggageBuilder()
            .TenantId(turnContext.Activity.Recipient.TenantId)
            .AgentId(turnContext.Activity.Recipient.AgenticAppId)
            .Build();

        try
        {
            _agentTokenCache.RegisterObservability(
                turnContext.Activity.Recipient.AgenticAppId,
                turnContext.Activity.Recipient.TenantId,
                new AgenticTokenStruct(
                    userAuthorization: UserAuthorization,
                    turnContext: turnContext,
                    authHandlerName: "AGENTIC"
                ),
                EnvironmentUtils.GetObservabilityAuthenticationScope()
            );
        }
        catch (Exception ex)
        {
            _logger.LogWarning($"Error registering for observability: {ex.Message}");
        }
    }
}

Instrumentation automatique

L’instrumentation automatique écoute automatiquement les signaux de télémétrie existants des frameworks agentiques (SDK) pour les traces et les transfère au service d’observabilité Agent 365. Cette fonctionnalité élimine le besoin pour les développeurs d’écrire manuellement du code de surveillance, simplifie la configuration et assure un suivi cohérent des performances.

Plusieurs SDK et plateformes prennent en charge l’auto-instrumentation :

Plateforme	Kits de développement logiciel (SDK) / Frameworks pris en charge
.NET	Noyau sémantique, OpenAI, Agent Framework
Python	Noyau sémantique, OpenAI, Agent Framework, LangChain
Node.js	OpenAI, LangChain

Note

La prise en charge de l’instrumentation automatique varie selon l’implémentation de la plateforme et du SDK.

Noyau Sémantique

L’instrumentation automatique nécessite l’utilisation du générateur de bagages. Définissez l’ID de l’agent et l’ID du locataire en utilisant BaggageBuilder.

Installez le package .

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

Configurez l’observabilité.

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

Ajoutez des dépendances à la collection de services.

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

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

On peut définir AgentId et TenantId en utilisant BaggageBuilder. Assurez-vous que l’identifiant que vous utilisez lors de la création d’un ChatCompletionAgent correspond à l’identifiant de l’agent que vous transmettez à 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

L’instrumentation automatique nécessite l’utilisation du générateur de bagages. Définissez l’ID de l’agent et l’ID du locataire en utilisant BaggageBuilder.

Installez le package .

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

Configurez l’observabilité.

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

Installez le package .

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

Configurez l’observabilité.

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();

Ajoutez des dépendances à la collection de services.

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

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

On peut définir AgentId et TenantId en utilisant BaggageBuilder. Pour les appels d’outils, lancez une trace en utilisant Trace() sur une ChatToolCall instance.

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>);
    }
}

Cadre d’agent

L’instrumentation automatique nécessite l’utilisation du générateur de bagages. Définissez l’ID de l’agent et l’ID du locataire en utilisant BaggageBuilder.

Installez le package .

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

Configurez l’observabilité.

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()

Ajoutez des dépendances à la collection de services.

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

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

On peut définir AgentId et TenantId en utilisant 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();
    }
}

Cadre LangChain

L’instrumentation automatique nécessite l’utilisation du générateur de bagages. Définissez l’ID de l’agent et l’ID du locataire en utilisant BaggageBuilder.

Installez le package .

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

Configurez l’observabilité.

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

Installez le package .

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

Configurez l’observabilité.

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

Instrumentation manuelle

Utilisez le SDK d’observabilité de l’agent 365 pour comprendre le fonctionnement interne de l’agent. Le Kit de développement logiciel (SDK) fournit des étendues que vous pouvez démarrer : InvokeAgentScope, ExecuteToolScope, InferenceScope, et OutputScope.

Invocation de l’agent

Cette étendue doit être utilisée au début du processus de votre assistant. En utilisant la portée de l’agent invoke, vous pouvez capturer des propriétés comme l’agent en cours d’invocation, les données utilisateur de l’agent, et plus encore.

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(...)

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();
}

Si votre agent utilise le paquet @microsoft/agents-a365-observability-hosting, vous pouvez utiliser ScopeUtils.populateInvokeAgentScopeFromTurnContext pour créer l’étendue avec les détails de l’agent, les détails de l’appelant et les informations de canal dérivées automatiquement du 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();
}

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; }
}

Exécution de l’outil

Les exemples suivants montrent comment ajouter un suivi d'observabilité à l'exécution des outils de votre agent. Ce suivi capture la télémétrie à des fins de surveillance et d’audit.

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)

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();
}

Si votre agent utilise le paquet @microsoft/agents-a365-observability-hosting, utilisez ScopeUtils.populateExecuteToolScopeFromTurnContext pour créer la portée avec les détails de l'agent automatiquement dérivés du 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();
}

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.\"}");

Inférence

Les exemples suivants montrent comment instrumenter les appels d’inférence de modèle IA avec le suivi de l’observabilité pour capturer l’utilisation des jetons, les détails du modèle et les métadonnées de réponse.

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)

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();
}

Si votre agent utilise le @microsoft/agents-a365-observability-hosting package, vous pouvez utiliser ScopeUtils.populateInferenceScopeFromTurnContext pour créer l’étendue avec les détails de l’agent automatiquement dérivés du 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();
}

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);

Sortie

Utilisez cette étendue pour les scénarios asynchrones où InvokeAgentScope, ExecuteToolScopeou InferenceScope ne peut pas capturer les données de sortie de manière synchrone. Démarrez OutputScope comme étendue enfant pour enregistrer les messages de sortie finaux une fois l’étendue parente terminée.

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

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();

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

Valider localement

Pour vérifier que vous avez correctement intégré le Kit de développement logiciel (SDK) d’observabilité, examinez les journaux de console générés par votre agent et vos journaux d’activité à partir du Kit de développement logiciel (SDK) d’observabilité.

Définissez la variable d’environnement ENABLE_A365_OBSERVABILITY_EXPORTER sur false. Ce réglage exporte les spans (traces) vers la console.

Pour examiner les échecs d’exportation, activez la journalisation détaillée en définissant ENABLE_A365_OBSERVABILITY_EXPORTERtrue et en configurant la journalisation de débogage au démarrage de votre application :

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)

Messages de journal clés :

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.

Définissez la variable d’environnement ENABLE_A365_OBSERVABILITY_EXPORTER sur false. Ce réglage exporte les spans (traces) vers la console.

Pour examiner les échecs d’exportation, définissez des variables d’environnement dans .env ou dans le shell.

# Enable the Agent365 exporter
ENABLE_A365_OBSERVABILITY_EXPORTER=true

# Enable verbose logging
A365_OBSERVABILITY_LOG_LEVEL=info|warn|error

Passez en revue la sortie de la console pour les messages tels que :

[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

Si vous le souhaitez, utilisez un enregistreur d’événements personnalisé pour capturer des événements d’exportation vers un fichier :

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 });
  }
});

Définissez EnableAgent365Exporter sur false dans appsettings.json. Ce réglage exporte les spans (traces) vers la console.

Pour examiner les échecs d’exportation, configurez la journalisation détaillée dans appsettings.json:

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

Ou définissez des variables d’environnement :

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

Messages de journal clés :

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

Si vous n’inscrivez pas de ILoggerFactory dans DI, l’exportateur revient automatiquement à un journaliseur de console.

Affichage des journaux exportés

Pour afficher les données de télémétrie de l’agent dans Microsoft Purview ou Microsoft Defender, vérifiez que les conditions suivantes sont remplies :

Microsoft Purview : l’audit doit être activé pour votre organisation. Pour obtenir des instructions, consultez Activer ou désactiver l’audit.
Microsoft Defender : la chasse avancée doit être configurée pour accéder à la table CloudAppEvents. Pour plus d’informations, consultez la table CloudAppEvents dans le schéma de repérage avancé.

Validation pour la publication en boutique

Important

Pour une validation réussie de la boutique, votre agent doit implémenter les périmètres InvokeAgentScope, InferenceScope et ExecuteToolScope. Ces trois étendues sont requises pour la publication.

Avant de publier, utilisez les journaux de console pour valider votre intégration d’observabilité pour l’agent en implémentant les étendues requises invoke agent, execute tool, inference, et output. Ensuite, comparez les journaux de votre agent avec les listes d’attributs suivantes pour vérifier que tous les attributs requis sont présents. Capturez les attributs dans chaque étendue ou via le générateur de contexte, et incluez des attributs optionnels à votre discrétion.

Pour plus d’informations sur les exigences de publication en magasin, consultez les directives de validation des magasins.

Attributs `InvokeAgentScope`

La liste suivante résume les attributs de télémétrie requis et optionnels enregistrés lorsque vous démarrez un 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"
    }

Attributs `ExecuteToolScope`

La liste suivante résume les attributs de télémétrie requis et optionnels enregistrés lorsque vous démarrez un 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"
    }

Attributs `InferenceScope`

La liste suivante résume les attributs de télémétrie requis et optionnels enregistrés lorsque vous démarrez un 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"
    }

Attributs `OutputScope`

La liste suivante résume les attributs de télémétrie requis et optionnels enregistrés lorsque vous démarrez un OutputScope. Utilisez cette étendue pour les scénarios asynchrones où l’étendue parente ne peut pas capturer les données de sortie de manière synchrone.

"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"
    }

Testez votre agent avec l’observabilité

Après avoir implémenté l’observabilité dans votre agent, testez-la pour vous assurer qu’elle capture correctement les données de télémétrie. Suivez le guide de test pour configurer votre environnement. Ensuite, concentrez-vous principalement sur la section Afficher les journaux d’observation pour valider votre implémentation d’observabilité fonctionne comme prévu.

Vérification :

Accédez à https://admin.cloud.microsoft/#/agents/all.
Sélectionnez votre agent > Activité
Vous voyez des sessions et des appels d’outils

Résolution des problèmes

Cette section décrit les problèmes courants lors de la mise en œuvre et de l’utilisation de l’observabilité.

Conseil / Astuce

Le Guide de dépannage de l’Agent 365 contient des recommandations générales de dépannage, les meilleures pratiques et des liens vers du contenu de dépannage pour chaque étape du cycle de développement de l’Agent 365.

Les données d’observabilité n’apparaissent pas

Symptômes :

L’agent est en fuite
Pas de télémétrie dans le centre administratif
Impossible de voir l’activité des agents

Cause racine :

L’observabilité n’est pas activée
Erreurs de configuration
Problèmes de résolution de jetons

Solutions : Essayez les étapes suivantes pour résoudre le problème :

Vérifier que l’exportateur d’observabilité est activé

Vous devez activer explicitement l’exportateur Agent 365. En cas de désactivation, le SDK revient à un exportateur de console et la télémétrie n’est pas envoyée au service. Pour plus d’informations sur la configuration, consultez Configuration.
Vérifier la configuration du résolveur de jeton

L’exportateur requiert un programme de résolution de jeton valide qui retourne un jeton porteur pour chaque demande d’exportation. Si le programme de résolution de jeton est manquant ou retourne null, l’exportation est ignorée sans notification. Assurez-vous que votre code implémente correctement le résolveur de jetons. Pour plus d’informations, consultez résolveur de jeton.
Vérifier les erreurs dans les journaux

Activez la journalisation détaillée et utilisez la commande pour rechercher des erreurs liées à l’observabilitéaz webapp log tail. Pour plus d’informations sur l’activation de la journalisation par plateforme, consultez Valider localement.
```
# Look for observability-related errors
az webapp log tail --name <your-app-name> --resource-group <your-resource-group> | Select-String "observability"
```
Vérifier l’exportation de télémétrie

Confirmez que la télémétrie est générée et exportée comme prévu.
- Ajoutez un exportateur de console et vérifiez si la télémétrie est générée localement. Pour plus d’informations sur l’utilisation de l’exportateur de console et la validation de la sortie, consultez Valider localement.

ID de locataire ou ID d’agent manquant : sections ignorées

Symptômes: Le système supprime silencieusement les étendues et ne les exporte jamais. Certains SDK consigneront un nombre d’étendues ignorées ou un message tel que « Aucune étendue avec l’identité de locataire/agent trouvée ». D’autres les supprimeront sans les enregistrer.

Résolution :

Avant l'exportation, le Kit de développement logiciel (SDK) partitionne les intervalles selon l'identité du locataire et de l'agent. Le système supprime les portées qui n’ont pas d’ID de locataire ou d’ID d’agent et ne les envoie jamais au service.
Vérifiez que BaggageBuilder soit configuré avec l’ID de locataire et l’ID de l’agent avant de créer des spans. Ces valeurs se propagent via le contexte OpenTelemetry et s’attachent à toutes les traces créées dans le contexte du baggage. Pour obtenir l’API spécifique à la plateforme, consultez les attributs de bagages.
Vérifiez que l’activité TurnContext a un destinataire valide avec l’identité de l’agent si vous utilisez l’intergiciel de bagages ou tournez l’assistance de contexte à partir du package d’intégration d’hébergement pour remplir ces ID.

Échec de résolution de jeton : exportation ignorée ou non autorisée

Symptômes: Le programme de résolution de jeton retourne null ou lève une erreur. Selon le Kit de développement logiciel (SDK), l’exportation est ignorée entièrement ou la requête est envoyée sans en-tête d’autorisation et échoue avec HTTP 401.

Résolution :

Le programme de résolution de jeton est requis lors de l’initialisation. S’il est manquant, l’exportateur génère une erreur au démarrage. Vérifiez qu’un programme de résolution de jeton est fourni et retourne un jeton porteur valide.
Vérifiez que l’ID de locataire et l’ID d’agent appropriés sont utilisés pour BaggageBuilder, car ces valeurs sont passées au programme de résolution de jeton.
Pour les agents hébergés Azure, vérifiez que l’identité managée dispose de l’autorisation API requise pour l’étendue d’observabilité.

HTTP 401 Non autorisé

Symptômes: L’exportation échoue avec HTTP 401. L’exportateur ne réessaye pas cette erreur.

Résolution :

Vérifiez que l’audience du jeton correspond à l’étendue du point de terminaison d’observabilité.
Vérifiez que le résolveur de jetons ne retourne pas de jeton d'utilisateur délégué, un jeton pour un public incorrect ou un jeton expiré.

HTTP 403 Interdit

Symptômes: L’exportation échoue avec HTTP 403. L’exportateur ne réessaye pas cette erreur.

Cause: Une erreur HTTP 403 peut avoir des causes différentes. Vérifiez les résolutions suivantes dans l’ordre.

Résolution :

Licence manquante — Vérifiez que votre client dispose de l'une des licences suivantes attribuées dans le Centre d'administration Microsoft 365 :
- Test - Microsoft 365 E7
- Microsoft 365 E7
- Microsoft Agent 365 Frontier
Autorisation manquante Agent365.Observability.OtelWrite : si vous avez récemment mis à niveau vos packages d’observabilité, vous devez accorder cette autorisation. Consultez la note importante ci-dessous.

Important

Les agents existants mis à niveau vers ces versions de package nécessitent une étape supplémentaire

Cette étape s’applique uniquement si vous mettez à niveau un agent existant. Les nouvelles installations d’agent ne nécessitent pas cette étape. Si vous effectuez une mise à niveau vers une de ces versions de package ou une version ultérieure, vous devez accorder la nouvelle autorisation Agent365.Observability.OtelWrite à votre identité (Managed Identity ou inscription d'application). Sans cette autorisation, l’exportation de télémétrie échoue avec HTTP 403.

Plateforme	Version minimale nécessitant cette étape
.NET	`0.3-beta`
Node.JS	`0.2.0-preview.1`
Python	`0.3.0`

Accordez l’autorisation à l’aide de l’une des options suivantes.

Option A — Agent 365 CLI (nécessite a365.config.json et a365.generated.config.json dans votre répertoire de configuration, un compte Administrateur général et Agent 365 CLI v1.1.139-preview ou version ultérieure)

a365 setup admin --config-dir "<path-to-config-dir>"

Cette commande accorde toutes les autorisations manquantes, y compris les nouvelles étendues d’observabilité.

Option B — Entra Portal (aucun fichier de configuration requis ; nécessite l’accès administrateur général à l’inscription de l’application blueprint)

Accédez au portail Entra>inscriptions d'applications> sélectionnez votre application Blueprint.
Accédez aux autorisations d’API>Ajouter une autorisation>APIs que mon organisation utilise> recherchez9b975845-388f-4429-889e-eab1ef63949c.
Sélectionnez Autorisations déléguées> pour vérifier Agent365.Observability.OtelWrite>Ajouter des autorisations.
Répétez l’étape 2 à 3, cette fois,sélectionnez Autorisations > vérifier Agent365.Observability.OtelWrite>Ajouter des autorisations.
Cliquez sur Accorder le consentement de l’administrateur et confirmez.

Les deux Agent365.Observability.OtelWrite (délégués) et Agent365.Observability.OtelWrite (Application) doivent afficher l’état Granted .

HTTP 429 / 5xx — Erreurs temporaires

Symptômes: L’exportation échoue avec un code d’état HTTP temporaire tel que 429 ou 5xx.

Résolution :

Ces erreurs sont généralement temporaires et résolues par elles-mêmes. Les SDK Python et JavaScript tentent de nouveau automatiquement sur les codes d’état HTTP 408, 429 et 5xx jusqu’à trois fois avec une temporisation exponentielle. Le sdk .NET ne réessaye pas automatiquement.
Si les erreurs persistent, consultez le tableau de bord d’intégrité du service.
Envisagez de réduire la fréquence d’exportation en augmentant le délai planifié entre les lots ou en augmentant la taille maximale du lot d’exportation. Pour connaître les options de configuration par plateforme, consultez le Agent365ExporterOptions tableau dans Configuration.

Délai d’expiration de l’exportation

Symptômes: Les tentatives d’exportation expirent.

Résolution :

Vérifiez la connectivité réseau au point de terminaison d’observabilité.
Les valeurs par défaut du délai d’expiration varient selon la plateforme. Le délai d’expiration de la requête HTTP par défaut est de 30 secondes. Certains kits SDK ont également un délai d’expiration global d’exportation distinct qui couvre l’ensemble du cycle d’exportation, y compris les nouvelles tentatives. Pour connaître les propriétés exactes et les valeurs par défaut par plateforme, consultez la Agent365ExporterOptions table dans Configuration.
Si des délais d’expiration se produisent fréquemment, augmentez la valeur de délai d’expiration appropriée dans vos options d’exportation.

L'exportation réussit, mais la télémétrie n'apparaît pas dans Defender ou Purview

Symptoms : Les journaux indiquent une exportation réussie, mais la télémétrie n'est pas visible dans Microsoft Defender ou Microsoft Purview.

Résolution :

Vérifiez que vous remplissez les conditions préalables à l’affichage des journaux exportés. Pour Purview, l’audit doit être activé. Pour Defender, vous devez configurer la chasse avancée. Pour en savoir plus, consultez Consulter les journaux exportés.
La télémétrie peut prendre plusieurs minutes pour se mettre à jour après une exportation réussie. Attendez que les données apparaissent avant d’examiner plus en détail.

Pour en savoir plus sur les tests d’observabilité, consultez :

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-27

Observabilité de l’agent

Principaux avantages

Agents pris en charge

Installation

Configuration

Attributs des bagages

Intergiciels de bagages

Programme de résolution de jetons

Instrumentation automatique

Noyau Sémantique

OpenAI

Cadre d’agent

Cadre LangChain

Instrumentation manuelle

Invocation de l’agent

Exécution de l’outil

Inférence

Sortie

Valider localement

Affichage des journaux exportés

Validation pour la publication en boutique

Attributs InvokeAgentScope

Attributs ExecuteToolScope

Attributs InferenceScope

Attributs OutputScope

Testez votre agent avec l’observabilité

Résolution des problèmes

Les données d’observabilité n’apparaissent pas

ID de locataire ou ID d’agent manquant : sections ignorées

Échec de résolution de jeton : exportation ignorée ou non autorisée

HTTP 401 Non autorisé

HTTP 403 Interdit

HTTP 429 / 5xx — Erreurs temporaires

Délai d’expiration de l’exportation

L'exportation réussit, mais la télémétrie n'apparaît pas dans Defender ou Purview

Commentaires

Ressources supplémentaires

Attributs `InvokeAgentScope`

Attributs `ExecuteToolScope`

Attributs `InferenceScope`

Attributs `OutputScope`