Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Utilisez Microsoft Foundry Toolkit pour Visual Studio Code pour collecter des traces locales ou afficher les données de télémétrie pour les agents déployés dans Microsoft Foundry. Une trace regroupe les opérations enregistrées pour une requête. Chaque opération est un span avec des informations temporelles, un état, ainsi que les attributs et événements éventuels fournis par l’instrumentation.
Cet article traite d’abord de la collecte locale, puis du traçage dans le cloud pour les agents déployés. Choisissez la source de données qui correspond à votre enquête :
| Approach | Utilisez-le pour | Données et responsabilités |
|---|---|---|
| Inspecteur d’agent | Envoyez une requête locale, inspectez la réponse en temps réel et les événements des outils, ou mettez le code en pause à un point d’arrêt. | Le serveur fournit des événements de protocole et des diagnostics de développement. Cette approche ne nécessite pas de collecteur OTLP et ne crée pas d’historique de traces dans le cloud. |
| Suivi local | Comparez les spans de modèle, d’outil et d’agent enregistrés pendant le développement. | Votre application exporte les données de télémétrie vers le collecteur local du Toolkit. Vous configurez l’instrumentation et gérez les données locales stockées. |
| Traçage de l’agent hébergé | Analysez les demandes gérées par un agent déployé sur Foundry. | Les traces résident dans la ressource Application Insights connectée du projet. L’accès, la rétention et les frais suivent la configuration des ressources Azure. |
Un agent hébergé exécute votre code personnalisé dans Foundry Agent Service. Foundry gère l’hébergement, mais vous restez responsable du code et des dépendances. Le suivi ne remplace pas la création et le déploiement de l’agent.
Prerequisites
- Visual Studio Code avec la version publique actuelle de l’extension Foundry Toolkit. Consultez Install Foundry Toolkit.
- Une application que vous pouvez exécuter localement, avec ses connexions au modèle et aux outils configurées.
- Pour le premier exemple, une application Python basée sur Microsoft Agent Framework et l’environnement Python sélectionné. Pour d’autres kits sdk, utilisez la configuration Python ou JavaScript et TypeScript.
- Pour le suivi cloud, un agent déployé et une ressource Application Insights connectée à son projet Foundry, ou l’autorisation de s’y connecter ou d’en créer une.
- Pour les requêtes dans le cloud, le rôle Log Analytics Reader sur la ressource Application Insights connectée. Pour les tables protégées, attribuez également le rôle Lecteur de données de surveillance privilégié. Consultez les prérequis du traçage Foundry.
La collecte locale ne nécessite pas d’autorisations Application Insights ni d’autorisations de télémétrie cloud. Les appels au modèle et l’exécution d’outils peuvent toujours utiliser des services distants et entraîner des frais.
Collectez des traces locales
Le collecteur local reçoit des données de télémétrie sur OpenTelemetry Protocol (OTLP). Il n’instrumente pas automatiquement une application. Votre framework ou une bibliothèque d’instrumentation doit créer des spans et les exporter vers le collecteur.
Configuration du SDK et de la langue
Les SDK avec instrumentation intégrée nécessitent encore un exportateur. D’autres SDK utilisent un package d’instrumentation séparé.
| Kit de développement logiciel (SDK) ou cadre de développement | Python | JavaScript et TypeScript (Node.js) |
|---|---|---|
| Infrastructure de l’agent Microsoft | Instrumentation OpenTelemetry intégrée. | Aucune aide dédiée à la configuration du Toolkit. |
| SDK Azure AI pour l’inférence (préversion) | instrumentation du SDK Azure. | instrumentation du SDK Azure. |
| Foundry Projects SDK | Instrumentation côté client (version préliminaire). | Instrumentez le client OpenAI ou Kit de développement logiciel (SDK) Azure sous-jacent. |
| Kit de développement logiciel (SDK) Agents SDK Foundry classic | outil d’instrumentation Kit de développement logiciel (SDK) Azure. | Aucune aide dédiée à la configuration du Toolkit. |
| Anthropic | Instrumentation OpenLLMetry. | Instrumentation Traceloop. |
| Google GenAI (Gemini) | Instrumentation OpenTelemetry de Google GenAI. | Aucune instruction dédiée à la configuration du Toolkit. |
| LangChain | Instrumenteur OpenLLMetry. | Instrumentation Traceloop. |
| SDK OpenAI, y compris les clients Azure OpenAI | OpenLLMetry instrumentor. | Instrumentation de Traceloop. |
| Kit de développement logiciel (SDK) Des agents OpenAI | Processeur de traces OpenLLMetry. | Aucune instruction dédiée pour la configuration de la boîte à outils. |
« Aucune instructions de configuration du Toolkit dédiées » signifie qu’il n’existe ici aucune procédure de configuration spécifique au kit de développement logiciel (SDK) pour cette langue, et non que le collecteur rejette ses données de télémétrie. Le collecteur accepte les données OTLP. L’outil d’instrumentation détermine quelles opérations et quels détails des messages sont capturés.
Ces exemples utilisent des options d’instrumentation sélectionnées, et non une liste exhaustive de bibliothèques compatibles. L’instrumentation OpenLLMetry et Traceloop sont des bibliothèques non-Microsoft.
Configurer l’instrumentation
Utilisez cette procédure avec une application Python Agent Framework existante. Gardez l’agent et le collecteur dans le même environnement local pour cette démonstration.
Sélectionnez Foundry Toolkit dans la barre d’activités, puis Outils de développement>Moniteur>Traçage.
Sélectionnez Démarrer le collecteur avant d’exécuter votre application.
Dans l'environnement Python de l'application, installez l'exportateur gRPC s'il n'est pas déjà déclaré dans vos dépendances :
python -m pip install opentelemetry-exporter-otlp-proto-grpcRéférence : exportateurs OTLP Python d’OpenTelemetry.
Configurez OpenTelemetry une seule fois au démarrage de l’application, avant de compiler ou d’exécuter l’agent :
import os os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:4317" os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = "grpc" from agent_framework.observability import configure_otel_providers configure_otel_providers(enable_sensitive_data=False)Référence : observabilité d’Agent Framework.
Si votre application ou votre bibliothèque d’hébergement a déjà configuré des fournisseurs OpenTelemetry, configurez les exportateurs déjà en place au lieu d’ajouter une nouvelle configuration de fournisseur. Les variables spécifiques au signal
OTEL_EXPORTER_OTLP_*_ENDPOINTpeuvent remplacer le point de terminaison de base. Recherchez les paramètres de trace, de journal ou de métrique existants qui pointent ailleurs.Exécutez l’application avec son point d’entrée normal et envoyez une requête qui exerce l’agent. Laissez la requête se terminer et donnez le temps à l’exportateur d’envoyer des données de télémétrie avant d’arrêter le processus.
Dans Tracing, sélectionnez Actualiser, puis sélectionnez la nouvelle trace pour inspecter ses spans.
Agent Framework instrumente les clients de modèles, les agents et les opérations de workflow. D’autres infrastructures peuvent nécessiter une bibliothèque d’instrumentation. La compatibilité OTLP permet au collecteur de recevoir des données, tandis que les attributs émis et les conventions sémantiques d’IA générative déterminent ce que le visualiseur affiche.
Pour un autre Kit de développement logiciel (SDK) ou un autre langage, utilisez la configuration ci-dessous au lieu de la configuration de l’Agent Framework. Démarrez d’abord le collecteur, configurez l’instrumentation avant de créer des clients, puis exécutez votre application et actualisez la liste de traces.
Points de terminaison du collecteur
Mettre en correspondance le protocole d’exportateur au point de terminaison de collecteur. Le Toolkit écoute sur localhost avec les valeurs par défaut suivantes :
| Exportateur | Point de terminaison |
|---|---|
| OTLP gRPC | http://localhost:4317 |
| Exportateur de trace HTTP OTLP | http://localhost:4318/v1/traces |
| Exportateur de journaux HTTP OTLP | http://localhost:4318/v1/logs |
Certains exportateurs HTTP acceptent http://localhost:4318 et ajoutent le chemin du signal eux-mêmes. Suivez la configuration de votre exportateur plutôt que d’ajouter le chemin deux fois. Certaines bibliothèques d’instrumentation envoient du contenu de message en tant qu’enregistrements de journal, de sorte que l’exportation de spans seules peut ne pas fournir de détails d’entrée et de sortie.
Ces ports ne sont pas liés au serveur HTTP de l’agent et aux ports du débogueur. Dans un conteneur ou un environnement de développement distant, localhost fait référence à cet environnement. Établissez la connexion appropriée au collecteur plutôt que de supposer qu’elle fait référence à votre ordinateur.
Configuration du SDK Python
Les exemples suivants supposent que votre application a déjà son SDK du modèle, ses informations d’identification et sa configuration de modèle. Installez les dépendances partagées et le package supplémentaire pour votre Kit de développement logiciel (SDK) à partir du tableau suivant :
python -m pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
Référence : OpenTelemetry Python SDK, exportateurs OTLP.
Ajoutez cette configuration commune une fois au démarrage de l’application, puis l’instrumentation d’une des lignes du tableau. Ne la combinez pas avec la configuration du fournisseur d’une autre bibliothèque.
import os
os.environ["TRACELOOP_TRACE_CONTENT"] = "false"
os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "false"
os.environ["AZURE_TRACING_GEN_AI_CONTENT_RECORDING_ENABLED"] = "false"
from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
OTLPSpanExporter,
)
provider = TracerProvider(
resource=Resource.create({"service.name": "my-agent"})
)
provider.add_span_processor(BatchSpanProcessor(
OTLPSpanExporter(endpoint="http://localhost:4318/v1/traces")
))
trace.set_tracer_provider(provider)
Référence : TracerProvider et span processors, OTLPSpanExporter.
Installez le paquet dans la rangée de votre choix avec python -m pip install <package>. Les exemples OpenAI, Anthropic, LangChain et les exemples séparés d’OpenAI Agents utilisent une instrumentation OpenLLMetry non-Microsoft. Les versions du SDK et les API de modèle peuvent produire des détails différents.
| SDK | Module supplémentaire | Instrumentation après la configuration commune |
|---|---|---|
| OpenAI, y compris les clients Azure OpenAI | opentelemetry-instrumentation-openai |
from opentelemetry.instrumentation.openai import OpenAIInstrumentorOpenAIInstrumentor().instrument() |
| Anthropic | opentelemetry-instrumentation-anthropic |
from opentelemetry.instrumentation.anthropic import AnthropicInstrumentorAnthropicInstrumentor().instrument() |
| LangChain | opentelemetry-instrumentation-langchain |
from opentelemetry.instrumentation.langchain import LangchainInstrumentorLangchainInstrumentor().instrument() |
| Google GenAI | opentelemetry-instrumentation-google-genai |
os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "NO_CONTENT"from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentorGoogleGenAiSdkInstrumentor().instrument() |
| Suivi côté client de Foundry Projects (préversion) |
azure-core-tracing-opentelemetry, aux côtés de azure-ai-projects |
os.environ["AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING"] = "true"from azure.ai.projects.telemetry import AIProjectInstrumentorAIProjectInstrumentor().instrument(enable_content_recording=False) |
| SDK des agents Foundry Classic |
azure-core-tracing-opentelemetry, aux côtés de azure-ai-agents |
os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"from azure.ai.agents.telemetry import AIAgentsInstrumentorAIAgentsInstrumentor().instrument() |
| SDK Azure AI Inference (préversion) |
azure-core-tracing-opentelemetry, parallèlement à azure-ai-inference |
os.environ["AZURE_SDK_TRACING_IMPLEMENTATION"] = "opentelemetry"from azure.ai.inference.tracing import AIInferenceInstrumentorAIInferenceInstrumentor().instrument() |
Pour les projets Foundry, suivez les recommandations de traçage côté client et créez votre client OpenAI après l’instrumentation. Cette aide diffère du classic Agents SDK. N’instrumentez pas les mêmes appels OpenAI avec à la fois AIProjectInstrumentor et un instrumenteur OpenAI distinct.
Pour le OpenAI Agents SDK, installez opentelemetry-instrumentation-openai-agents et ajoutez ce code après l’installation partagée :
from agents import set_trace_processors
from opentelemetry.instrumentation.openai_agents import OpenAIAgentsInstrumentor
set_trace_processors([])
OpenAIAgentsInstrumentor().instrument()
Référence : Instrumentation des agents OpenAI, traçage des agents OpenAI.
Cet exemple remplace les processeurs de trace existants avant d’ajouter le processeur OpenTelemetry. Sans ce remplacement, le Kit de développement logiciel (SDK) peut également exporter des traces vers son back-end par défaut. Si vous utilisez des processeurs existants, passez en revue les destinations de suivi avant de les modifier. Maintenez le traçage du SDK activé afin que le processeur OpenTelemetry reçoive des événements.
Une fois qu’une application éphémère a terminé d’effectuer ses requêtes, appelez provider.force_flush() avant de se fermer pour envoyer les spans mis en mémoire tampon. Pour vous aider à adapter ces extraits de code, utilisez le Tracing Code Gen tool du Toolkit.
Exporter les enregistrements du journal des messages
Certains instrumenteurs émettent du contenu de message en tant qu’enregistrements de journal OpenTelemetry plutôt que comme attributs de span. Si vous choisissez d’enregistrer ce contenu dans un test de développement contrôlé, ajoutez cette configuration une fois en même temps que le fournisseur de trace Python précédent :
from opentelemetry import _logs
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
logger_provider = LoggerProvider(resource=provider.resource)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(
OTLPLogExporter(endpoint="http://localhost:4318/v1/logs")
))
_logs.set_logger_provider(logger_provider)
Référence : OpenTelemetry Python SDK de journalisation, OTLPLogExporter.
Appelez logger_provider.force_flush() avant de quitter une application de courte durée. Un exportateur de logs n’active pas la capture de contenu par lui-même. Suivez les paramètres de contenu de votre instrumentor et les instructions de gestion des données.
Configuration du SDK JavaScript et TypeScript
Pour les applications Node.js, partagez un fournisseur de trace et inscrivez l’instrumentation pour votre SDK. Cet exemple utilise CommonJS et la configuration du fournisseur JavaScript 2.x OpenTelemetry. Les applications TypeScript compilées en CommonJS peuvent utiliser le même ordre d’initialisation.
Votre application doit déjà avoir son kit SDK de modèle, ses informations d’identification et sa configuration de modèle. Installez les dépendances partagées et l’instrumenteur OpenAI :
npm install @opentelemetry/api @opentelemetry/sdk-trace-node \
@opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-proto \
@opentelemetry/instrumentation @traceloop/instrumentation-openai
Référence : exportateurs JavaScript OpenTelemetry, instrumentation OpenAI.
Créez tracing.cjs :
const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const {
OTLPTraceExporter
} = require('@opentelemetry/exporter-trace-otlp-proto');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { OpenAIInstrumentation } = require('@traceloop/instrumentation-openai');
const provider = new NodeTracerProvider({
spanProcessors: [
new BatchSpanProcessor(new OTLPTraceExporter({
url: 'http://localhost:4318/v1/traces'
}))
]
});
provider.register();
registerInstrumentations({
instrumentations: [new OpenAIInstrumentation({ traceContent: false })]
});
module.exports = provider;
Référence : NodeTracerProvider, instrumentation OpenAI.
Chargez ce fichier avant d’importer ou de require votre SDK de modèle. Par exemple, exécutez node --require ./tracing.cjs app.cjs pour une application CommonJS. Pour un autre SDK, remplacez le package OpenAI, l’importation et l’entrée d’enregistrement par la ligne correspondante :
| SDK | Module d’instrumentation | Entrée d’importation et d’enregistrement |
|---|---|---|
| OpenAI, y compris les clients Azure OpenAI | @traceloop/instrumentation-openai |
const { OpenAIInstrumentation } = require('@traceloop/instrumentation-openai');new OpenAIInstrumentation({ traceContent: false }) |
| Anthropic | @traceloop/instrumentation-anthropic |
const { AnthropicInstrumentation } = require('@traceloop/instrumentation-anthropic');new AnthropicInstrumentation({ traceContent: false }) |
| LangChain | @traceloop/instrumentation-langchain |
const { LangChainInstrumentation } = require('@traceloop/instrumentation-langchain');new LangChainInstrumentation({ traceContent: false }) |
| opérations d’Kit de développement logiciel (SDK) Azure, y compris Azure AI Inference | @azure/opentelemetry-instrumentation-azure-sdk |
const { createAzureSdkInstrumentation } = require('@azure/opentelemetry-instrumentation-azure-sdk');createAzureSdkInstrumentation() |
Les packages Traceloop sont des packages d’instrumentation non Microsoft. Pour une application Foundry Projects, instrumentez le client qui effectue la demande de modèle. L'instrumentation du SDK Azure ne remplace pas l'instrumentation OpenAI pour les appels effectués via un client OpenAI.
Pour les modules ECMAScript natifs, suivez la configuration ESM d’OpenTelemetry. Le chargement de l’instrumentation après le sdk cible peut laisser les appels non instrumentés. À l’arrêt, attendez provider.shutdown() une fois les requêtes terminées pour exporter les spans mis en mémoire tampon.
Important
Ces exemples désactivent la capture de contenu de message pour les instrumenteurs GenAI répertoriés. Ce n’est pas une garantie générale de caviardage. Passez en revue les autres exportateurs, la journalisation du SDK, les attributs de span et l’instrumentation personnalisée avant de partager des données. Consultez la documentation de l’instrumenteur associé pour connaître les paquets et les API pris en charge.
Inspecter et gérer les traces locales
Utilisez l’arborescence des spans pour suivre la requête de l’orchestration de l’agent vers les opérations de modèle et d’outil.
- Sélectionnez un span lent ou en échec.
- Inspectez sa durée et son statut.
- Ouvrez Input + Output pour les messages enregistrés, lorsqu’ils sont fournis par l’instrumentation, ou les métadonnées pour les attributs d’étendue.
Les exemples conservent la capture de contenu sensible désactivée. Les données de minutage sans messages peuvent être le résultat attendu.
Pour un test contrôlé de développement d’Agent Framework, définissez enable_sensitive_data=True dans sa configuration existante pour enregistrer le contenu pris en charge des invites, des réponses et des outils. Restaurez-le False lorsque le test est terminé. D’autres instrumentors ont leurs propres paramètres de contenu.
Caution
L’enregistrement de contenu peut capturer des données personnelles, des secrets, des arguments d’outil et des résultats. Utilisez des données de test non sensibles et réduisez ou réactez le contenu avant d’entrer des données de télémétrie. N’activez pas uniquement l’enregistrement de contenu de production pour remplir une vue d’entrée et de sortie vide.
Les traces collectées persistent dans une base de données SQLite locale nommée traces.db, dans le tracing sous-répertoire de votre dossier d’accueil .aitk utilisateur. La fermeture de la visionneuse ne les supprime pas.
Sélectionnez Arrêter le collecteur pour arrêter la collection locale. Votre agent et ses appels de modèle continuent à s’exécuter. Pour supprimer des enregistrements locaux, sélectionnez les traces dans la liste, puis sélectionnez Supprimer.
Le stockage local est distinct d’Application Insights. La suppression de traces locales ne supprime pas les données de télémétrie cloud et l’effacement d’une conversation dans Inspector ne supprime aucun des deux stockages.
Afficher les traces de l’agent hébergé
Après le déploiement, utilisez les traces cloud pour examiner l’agent s’exécutant dans Foundry plutôt que votre processus local. Le Kit de ressources interroge la ressource Application Insights connectée du projet. Il ne charge pas votre base de données de trace locale.
Vérifiez les prérequis cloud avant de commencer. L’accès à l’agent seul n’accorde pas l’autorisation d’interroger les données de télémétrie.
Se connecter à Application Insights et inspecter une requête
Utilisez l’onglet Traces de l’agent pour connecter Application Insights et rechercher une requête d’un agent déployé.
Dans la barre latérale Foundry Toolkit, ouvrez Mes ressources>. Sélectionnez l’onglet Agent hébergé , puis sélectionnez le nom de l’agent.
Sélectionnez Traces. Si le projet n’a aucune ressource connectée, sélectionnez Activer App Insights.
Dans Les paramètres App Insights, sélectionnez un nom de ressource Application Insights existant. Vous pouvez également choisir de créer une ressource et de renseigner les champs requis de la ressource et de l’espace de travail. Sélectionnez Envoyer et attendez la confirmation.
Cela modifie la connexion Application Insights partagée du projet, et non pas une préférence d’espace de travail local. La création de ressources et la collecte de données de télémétrie peuvent entraîner des frais Azure. Confirmez le projet et la ressource prévus avant d’envoyer.
Revenez à Playground et envoyez une demande de test à l’agent déployé.
Laissez le temps d’ingestion, puis rouvrez Traces. Utilisez l’intervalle de temps, Rechercher par ID de conversation, État ou Filtre Durée pour localiser la requête.
Sélectionnez une trace, puis un span, pour passer en revue les métadonnées et l’entrée + sortie, lorsque le contenu est disponible.
Pour inspecter les opérations associées à une conversation, sélectionnez son ID de conversation dans la liste de traces. La vue de conversation affiche une arborescence d’opérations et des métadonnées.
La connexion d’Application Insights active le suivi côté serveur de Foundry. La visibilité sur vos appels de modèle, les appels d’outils et le code personnalisé dépend également de la bibliothèque d’hébergement et de l’instrumentation du framework. Consultez Configurer le suivi dans Foundry pour la collection côté service et l’instrumentation de client supplémentaire.
La requête de détail de trace du Toolkit couvre actuellement les sept derniers jours. Il s’agit d’une fenêtre de requête, et non d’un paramètre de rétention. Pour les données plus anciennes, utilisez le portail Foundry ou Azure Monitor, sous réserve de la configuration de rétention de l'espace de travail connecté.
Données, accès, conservation et coût
Déterminez où la télémétrie doit aller avant d’activer la capture de contenu ou de connecter une ressource cloud. La même requête peut générer des spans locaux, des données de télémétrie cloud et des données envoyées aux fournisseurs de modèles ou d’outils.
| Source de données | Responsibilities |
|---|---|
| Traces locales | Protégez l’accès à la base de données locale et aux données copiées. L’arrêt du collecteur n’arrête pas les autres exportateurs configurés dans votre application. |
| Traces du cloud | Application Insights et Log Analytics contrôlent les frais d’accès, de durée de conservation et de télémétrie. Les filtres de Toolkit ne modifient pas ces politiques. |
| Appels de modèle et d’outil | La collection locale n’empêche pas les requêtes de quitter votre ordinateur. Passez en revue la gestion des données de chaque service connecté, y compris les outils non Microsoft. |
Utilisez les conseils de suivi Foundry pour la sécurité et la confidentialité et la conservation et le coût des données. Pour l’identité de production, l’isolation réseau et l’accès en aval, suivez la sécurité et la gestion des données de l’agent hébergé. Ne traitez pas les identifiants locaux comme les autorisations de l’agent déployé.
Troubleshooting
| Problème | Que vérifier |
|---|---|
| Le suivi n’est pas disponible dans la barre latérale. | Vérifiez que l’extension actuelle est installée et activée dans l’environnement où vous l’exécutez. Le suivi local nécessite le chargement de son composant SQLite natif. |
| Le collecteur ne démarre pas. | Recherchez un autre processus utilisant le port 4317 ou 4318 et passez en revue la sortie du Toolkit. Évitez les processus de collecte concurrents sur les mêmes ports. |
| Une requête locale réussit, mais aucune trace n’apparaît. | Vérifiez que l’instrumentation s’exécute avant la requête, que le collecteur est en cours d’exécution et que l’exportateur utilise le protocole et le point de terminaison appropriés. Vérifiez les remplacements de point de terminaison, les erreurs d’exportation et les données de télémétrie mises en mémoire tampon, puis sélectionnez Actualiser. |
| Les spans s’affichent sans messages. | Vérifiez les paramètres d’enregistrement du contenu et les attributs pris en charge. Certaines bibliothèques nécessitent également un exportateur de logs. Le contenu manquant ne signifie pas nécessairement que la collecte a échoué. |
| Les traces du cloud sont vides. | Confirmez le projet et la connexion Application Insights, générez du nouveau trafic, élargissez la plage de temps et tenez compte du délai d’ingestion. |
| Les requêtes cloud échouent avec une erreur d’autorisation. | Vérifiez l’accès en lecture à Application Insights et Log Analytics, y compris les tables protégées, à l’aide des prérequis du service. |
| Une trace plus ancienne n’a aucun détail dans le Toolkit. | La requête détaillée couvre sept jours. Interrogez les enregistrements conservés plus anciens dans Foundry ou Azure Monitor. |