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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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é.

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.

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é.

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.

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.

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

Taux d’E/S du processus (performanceCounters/processIOBytesPerSecond)

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.

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.

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

Accéder à toutes vos données directement avec l’API REST Application Insights

L’API REST Application Insights permet la récupération programmatique des métriques basées sur les journaux. Il propose également un paramètre facultatif « ai.include-query-payload » qui, lorsqu’il est ajouté à une chaîne de requête, invite l’API à retourner non seulement les données de la série chronologique, mais également l’instruction Langage de requête Kusto (KQL) utilisée pour l’extraire. Ce paramètre peut être particulièrement bénéfique pour les utilisateurs qui visent à comprendre la connexion entre les événements bruts dans Log Analytics et la métrique basée sur les journaux résultantes.

Pour accéder directement à vos données, transmettez le paramètre « ai.include-query-payload » à l’API Application Insights dans une requête à l’aide de KQL.

api.applicationinsights.io/v1/apps/DEMO_APP/metrics/users/authenticated?api_key=DEMO_KEY&prefer=ai.include-query-payload

Voici un exemple d’instruction KQL de retour pour la métrique « Utilisateurs authentifiés ». (Dans cet exemple, « users/authenticated » est l’ID de métrique.)

output
{
    "value": {
        "start": "2024-06-21T09:14:25.450Z",
        "end": "2024-06-21T21:14:25.450Z",
        "users/authenticated": {
            "unique": 0
        }
    },
    "@ai.query": "union (traces | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (requests | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (pageViews | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (dependencies | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (customEvents | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (availabilityResults | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (exceptions | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (customMetrics | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)), (browserTimings | where timestamp >= datetime(2024-06-21T09:14:25.450Z) and timestamp < datetime(2024-06-21T21:14:25.450Z)) | where notempty(user_AuthenticatedId) | summarize ['users/authenticated_unique'] = dcount(user_AuthenticatedId)"
}