Métriques reposant sur un journal d’Application Insights
Les métriques Application Insights reposant sur un journal vous permettent d'analyser l'intégrité de vos applications surveillées, de créer de puissants tableaux de bord, et de configurer des alertes. Il existe deux types de métriques :
- Les métriques reposant sur le journal en arrière-plan sont converties en requêtes Kusto à partir d'événements stockés.
- Les métriques standard sont stockées sous forme de séries chronologiques pré-agrégées.
Comme les métriques standard sont pré-agrégées pendant la collecte, elles offrent de meilleures performances lors des requêtes. Elles constituent donc un meilleur choix pour les tableaux de bord et les alertes en temps réel. Les métriques reposant sur un journal contiennent plus de dimensions, ce qui en fait une meilleure option pour l'analyse des données et les diagnostics ad hoc. Utilisez le sélecteur d'espace de noms pour basculer entre les métriques reposant sur un journal et les métriques standard dans Metrics Explorer.
Interpréter et utiliser les requêtes de cet article
Cet article énumère les métriques contenant des agrégations et des dimensions prises en charge. Les détails sur les métriques reposant sur un journal incluent les instructions de requête Kusto sous-jacentes. Par commodité, chaque requête utilise des valeurs par défaut pour la granularité temporelle, le type de graphique et parfois la dimension de fractionnement, ce qui simplifie l'utilisation de la requête dans Log Analytics sans aucune modification nécessaire.
Lorsque vous tracez la même métrique dans Metrics Explorer, il n'y a aucune valeur par défaut : la requête est ajustée dynamiquement en fonction des paramètres de votre graphique :
La plage de temps sélectionnée est convertie en une clause where timestamp... qui sélectionne uniquement les événements de la plage de temps sélectionnée. Par exemple, dans un graphique affichant les données des dernières 24 heures, la requête inclut | where timestamp > ago(24 h).
La granularité temporelle sélectionnée est placée dans la clause summarize ... by bin(timestamp, [time grain]) finale.
Toutes les dimensions Filtre sélectionnées sont converties en clauses where supplémentaires.
La dimension Split chart (Fractionner le graphique) sélectionnée est convertie en une propriété de résumé supplémentaire. Par exemple, si vous fractionnez votre graphique par emplacement et que vous le tracez en utilisant une granularité temporelle de 5 minutes, la clause summarize est résumée par ... by bin(timestamp, 5 m), location.
Notes
Si vous découvrez le langage de requête Kusto, commencez par copier et coller les instructions Kusto dans le volet de requête Log Analytics sans y apporter de modification. Cliquez sur Exécuter pour afficher le graphique de base. À mesure que vous assimilez la syntaxe du langage de requête, vous pouvez commencer à apporter de petites modifications et voir l'impact de votre changement. Explorer vos propres données est un excellent moyen de tirer pleinement parti de Log Analyticset Azure Monitor.
Métriques de disponibilité
Les métriques de la catégorie Disponibilité vous permettent d’afficher l’intégrité de votre application web telle qu'elle apparaît dans le monde entier. Configurer les tests de disponibilité pour commencer à utiliser les métriques de cette catégorie.
Disponibilité (availabilityResults/availabilityPercentage)
La métrique Disponibilité indique le pourcentage des tests web qui n'ont détecté aucun problème. La valeur la plus basse possible est 0, qui indique que tous les tests web ont échoué. La valeur 100 signifie que tous les tests en ligne ont satisfait aux critères de validation.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Pourcentage | Average | Emplacement d'exécution, Nom du test |
availabilityResults
| summarize sum(todouble(success == 1) * 100) / count() by bin(timestamp, 5m), location
| render timechart
Durée du test de disponibilité (availabilityResults/duration)
La métrique Durée du test de disponibilité indique le temps nécessaire pour exécuter le test web. Pour les tests web à plusieurs étapes, la métrique reflète le temps d'exécution total de toutes les étapes.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Emplacement d'exécution, Nom du test, Résultat du test |
availabilityResults
| where notempty(duration)
| extend availabilityResult_duration = iif(itemType == 'availabilityResult', duration, todouble(''))
| summarize sum(availabilityResult_duration)/sum(itemCount) by bin(timestamp, 5m), location
| render timechart
Test de disponibilité (availabilityResults/count)
La métrique Tests de disponibilité reflète le nombre de tests web exécutés par Azure Monitor.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Count | Count | Emplacement d'exécution, Nom du test, Résultat du test |
availabilityResults
| summarize sum(itemCount) by bin(timestamp, 5m)
| render timechart
Métriques du navigateur
Les métriques du navigateur sont collectées par le Kit de développement logiciel (SDK) JavaScript Application Insights à partir des navigateurs réels des utilisateurs finaux. Elles vous donnent un excellent aperçu de l'expérience de vos utilisateurs avec votre application web. Les métriques du navigateur ne sont généralement pas échantillonnées, ce qui signifie qu’elles offrent une plus grande précision des données d'utilisation par rapport aux métriques côté serveur qui peuvent être biaisées par l'échantillonnage.
Notes
Pour collecter les métriques du navigateur, votre application doit être instrumentée avec le kit SDK JavaScript Application Insights.
Temps de chargement de la page de navigateur (browserTimings/totalDuration)
Temps s’écoulant entre la demande de l’utilisateur et le chargement du DOM, des feuilles de style, des scripts et des images.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Aucun |
browserTimings
| where notempty(totalDuration)
| extend _sum = totalDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Temps de traitement du client (browserTiming/processingDuration)
Temps écoulé entre la réception du dernier octet d’un document et le chargement du modèle DOM. Les demandes asynchrones peuvent encore être en cours de traitement.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Aucun |
browserTimings
| where notempty(processingDuration)
| extend _sum = processingDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum)/sum(_count) by bin(timestamp, 5m)
| render timechart
Temps de connexion au réseau pour le chargement de page (browserTimings/networkDuration)
Temps écoulé entre la requête de l’utilisateur et la connexion réseau. Inclut la connexion de recherche DNS et de transport.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Aucun |
browserTimings
| where notempty(networkDuration)
| extend _sum = networkDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Temps de réception de réponse (browserTimings/receiveDuration)
Temps écoulé entre le premier et le dernier octet, ou jusqu’à la déconnexion.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Aucun |
browserTimings
| where notempty(receiveDuration)
| extend _sum = receiveDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Temps d’envoi de la requête (browserTimings/sendDuration)
Temps écoulé entre la connexion réseau et la réception du premier octet.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées |
|---|---|---|
| Millisecondes | Moyenne, Min, Max | Aucun |
browserTimings
| where notempty(sendDuration)
| extend _sum = sendDuration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render timechart
Métriques d’échec
Les métriques de la catégorie Échecs montrent les problèmes liés au traitement des requêtes, aux appels de dépendances et aux exceptions levées.
Exceptions du navigateur (exceptions/browser)
Cette métrique reflète le nombre d'exceptions levées à partir de votre code d'application exécuté dans le navigateur. Seules les exceptions suivies avec un appel à l’API Application Insights trackException() sont incluses dans la métrique.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées | Notes |
|---|---|---|---|
| Count | Count | None | La version reposant sur un journal utilise l’agrégation Sum |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Échecs d'appel de dépendance (dependencies/failed)
Nombre d’appels de dépendance ayant échoué.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées | Notes |
|---|---|---|---|
| Count | Count | None | La version reposant sur un journal utilise l’agrégation Sum |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceptions (exceptions/count)
Chaque fois que vous consignez une exception dans Application Insights, un appel à la méthode trackException() du SDK est effectué. La métrique Exceptions indique le nombre d'exceptions consignées.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées | Notes |
|---|---|---|---|
| Count | Count | Nom du rôle cloud, Instance de rôle cloud, Type d’appareil | La version reposant sur un journal utilise l’agrégation Sum |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Demandes ayant échoué (requests/failed)
Nombre de requêtes de serveur suivies qui ont été marquées comme ayant échoué. Par défaut, le SDK Application Insights marque automatiquement chaque requête de serveur qui renvoie le code de réponse HTTP 5xx ou 4xx comme une requête ayant échoué. Vous pouvez personnaliser cette logique en modifiant la propriété success (réussite) de l'élément de télémétrie de requête dans un initialisateur de télémétrie personnalisé.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées | Notes |
|---|---|---|---|
| Count | Count | Instance de rôle cloud, Nom du rôle cloud, Trafic réel ou synthétique, Performances de la requête, Code de réponse | La version reposant sur un journal utilise l’agrégation Sum |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Exceptions du serveur (exceptions/server)
Cette métrique indique le nombre d'exceptions du serveur.
| Unité de mesure | Agrégations prises en charge | Dimensions pré-agrégées | Notes |
|---|---|---|---|
| Count | Count | Nom du rôle cloud, Instance de rôle cloud | La version reposant sur un journal utilise l’agrégation Sum |
exceptions
| where isempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Compteurs de performance
Utilisez les métriques de la catégorie Compteurs de performance pour accéder aux compteurs de performance système collectés par Application Insights.
Mémoire disponible (performanceCounters/availableMemory)
performanceCounters
| where ((category == "Memory" and counter == "Available Bytes") or name == "availableMemory")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Taux d’exceptions (performanceCounters/exceptionRate)
performanceCounters
| where ((category == ".NET CLR Exceptions" and counter == "# of Exceps Thrown / sec") or name == "exceptionRate")
| extend performanceCounter_value = iif(itemType == 'performanceCounter',value,todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Durée d’exécution de la requête HTTP (performanceCounters/requestExecutionTime)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Request Execution Time") or name == "requestExecutionTime")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Taux de requêtes HTTP (performanceCounters/requestsPerSecond)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Requests/Sec") or name == "requestsPerSecond")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Requêtes HTTP dans la file d'attente de l'application (performanceCounters/requestsInQueue)
performanceCounters
| where ((category == "ASP.NET Applications" and counter == "Requests In Application Queue") or name == "requestsInQueue")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Processeur de processus (performanceCounters/processCpuPercentage)
La métrique indique la part de la capacité totale du processeur consommée par le processus qui héberge votre application surveillée.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Pourcentage | Moyenne, Min, Max | Instance de rôle cloud |
performanceCounters
| where ((category == "Process" and counter == "% Processor Time Normalized") or name == "processCpuPercentage")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Notes
La plage de la métrique est comprise entre 0 et 100 * n, où n est le nombre de cœurs de processeur disponibles. Par exemple, la valeur métrique de 200 % peut représenter l’utilisation complète de deux cœurs d’UC ou d’une demi-utilisation de 4 cœurs de processeur, et ainsi de suite. La valeur normalisée de l’UC de processus est une autre mesure collectée par de nombreux kits de développement logiciel (SDK) qui représente la même valeur, mais la divise par le nombre de cœurs de processeur disponibles. Par conséquent, la plage de mesures normalisées de l’UC de processus est comprise entre 0 et 100.
Taux d’E/S du processus (performanceCounters/processIOBytesPerSecond)
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Octets par seconde | Moyenne, Min, Max | Instance de rôle cloud |
performanceCounters
| where ((category == "Process" and counter == "IO Data Bytes/sec") or name == "processIOBytesPerSecond")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Octets privés du processus (performanceCounters/processPrivateBytes)
Quantité de mémoire non partagée que le processus surveillé a allouée pour ses données.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Octets | Moyenne, Min, Max | Instance de rôle cloud |
performanceCounters
| where ((category == "Process" and counter == "Private Bytes") or name == "processPrivateBytes")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Temps processeur (performanceCounters/processorCpuPercentage)
Consommation d’UC de tous les processus s'exécutant sur l'instance de serveur surveillée.
| Unité de mesure | Agrégations prises en charge | Dimensions prises en charge |
|---|---|---|
| Pourcentage | Moyenne, Min, Max | Instance de rôle cloud |
Notes
La métrique Temps processeur n'est pas disponible pour les applications hébergées dans Azure App Services. Utilisez la métrique Utilisation de l'UC pour suivre l'utilisation d’UC des applications web hébergées dans App Services.
performanceCounters
| where ((category == "Processor" and counter == "% Processor Time") or name == "processorCpuPercentage")
| extend performanceCounter_value = iif(itemType == "performanceCounter", value, todouble(''))
| summarize sum(performanceCounter_value) / count() by bin(timestamp, 1m)
| render timechart
Indicateurs de performances de serveur
Appels de dépendance (dependencies/count)
Cette métrique est liée au nombre d'appels de dépendance.
dependencies
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Durée de la dépendance (dependencies/duration)
Cette métrique fait référence à la durée des appels de dépendance.
dependencies
| where notempty(duration)
| extend dependency_duration = iif(itemType == 'dependency',duration,todouble(''))
| extend _sum = dependency_duration
| extend _count = itemCount
| extend _sum = _sum*_count
| summarize sum(_sum)/sum(_count) by bin(timestamp, 1m)
| render timechart
Requêtes serveur (requests/count)
Cette métrique reflète le nombre de requêtes de serveur entrantes reçues par votre application web.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Temps de réponse du serveur (requests/duration)
Cette métrique reflète le temps nécessaire aux serveurs pour traiter les demandes entrantes.
requests
| where notempty(duration)
| extend request_duration = iif(itemType == 'request', duration, todouble(''))
| extend _sum = request_duration
| extend _count = itemCount
| extend _sum = _sum*_count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 1m)
| render timechart
Métriques d'utilisation
Temps de chargement de la page consultée (pageViews/duration)
Cette métrique fait référence au temps nécessaire au chargement des événements PageView.
pageViews
| where notempty(duration)
| extend pageView_duration = iif(itemType == 'pageView', duration, todouble(''))
| extend _sum = pageView_duration
| extend _count = itemCount
| extend _sum = _sum * _count
| summarize sum(_sum) / sum(_count) by bin(timestamp, 5m)
| render barchart
Affichages de pages (pageViews/count)
Nombre d'événements PageView consignés avec l'API Application Insights TrackPageView().
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sessions (sessions/count)
Cette métrique fait référence au nombre d'ID de session distincts.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Traces (traces/count)
Nombre d'instructions de suivi consignées avec l'appel à l’API Application Insights TrackTrace().
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Utilisateurs (users/count)
Nombre d’utilisateurs distincts qui ont accédé à votre application. L'utilisation de l'échantillonnage et du filtrage par télémétrie peut avoir une incidence importante sur la précision de cette métrique.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_Id)
| summarize dcount(user_Id) by bin(timestamp, 1h)
| render barchart
Utilisateurs, Authentifié (users/authenticated)
Nombre d’utilisateurs distincts qui se sont authentifiés auprès de votre application.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_AuthenticatedId)
| summarize dcount(user_AuthenticatedId) by bin(timestamp, 1h)
| render barchart