Loggbaserade mått för Application Insights
Med Application Insights-loggbaserade mått kan du analysera hälsotillståndet för dina övervakade appar, skapa kraftfulla instrumentpaneler och konfigurera aviseringar. Det finns två typer av mått:
- Loggbaserade mått bakom scenen översätts till Kusto-frågor från lagrade händelser.
- Standardmått lagras som föraggregerade tidsserier .
Eftersom standardmått föraggregeras under samlingen har de bättre prestanda vid frågetillfället. Detta gör dem till ett bättre val för instrumentpaneler och i realtidsaviseringar. Loggbaserade mått har fler dimensioner, vilket gör dem till det överlägsna alternativet för dataanalys och ad hoc-diagnostik. Använd namnområdesväljaren för att växla mellan loggbaserade och standardmått i Metrics Explorer.
Tolka och använda frågor från den här artikeln
Den här artikeln innehåller mått med sammansättningar och dimensioner som stöds. Informationen om loggbaserade mått innehåller de underliggande Kusto-frågeinstruktionerna. För enkelhetens skull använder varje fråga standardvärden för tidskornighet, diagramtyp och ibland delningsdimension, vilket förenklar användningen av frågan i Log Analytics utan att behöva ändras.
När du ritar samma mått i Metrics Explorer finns det inga standardvärden – frågan justeras dynamiskt baserat på diagraminställningarna:
Det valda tidsintervallet översätts till ytterligare en tidsstämpel... -sats för att endast välja händelserna från det valda tidsintervallet. Till exempel ett diagram som visar data för de senaste 24 timmarna innehåller frågan | där tidsstämpel > sedan(24 h).
Den valda tidskornigheten placeras i den slutliga sammanfattningen ... efter bin(tidsstämpel, [tidsintervall]) -sats.
Alla valda filterdimensioner översätts till ytterligare where-satser .
Den valda dimensionen Dela diagram översätts till en extra sammanfattningsegenskap. Om du till exempel delar upp diagrammet efter plats och ritar med 5 minuters tidskornighet sammanfattas sammanfattningssatsen ... efter bin(tidsstämpel, 5 m), plats.
Kommentar
Om du är nybörjare på Kusto-frågespråket börjar du med att kopiera och klistra in Kusto-instruktioner i Log Analytics-frågefönstret utan att göra några ändringar. Klicka på Kör för att se grundläggande diagram. När du börjar förstå syntaxen för frågespråket kan du börja göra små ändringar och se effekten av din ändring. Att utforska dina egna data är ett bra sätt att börja inse den fulla kraften i Log Analytics och Azure Monitor.
Tillgänglighetsmått
Med mått i kategorin Tillgänglighet kan du se hälsotillståndet för ditt webbprogram enligt vad som observerats från platser runt om i världen. Konfigurera tillgänglighetstesterna så att de börjar använda mått från den här kategorin.
Tillgänglighet (availabilityResults/availabilityPercentage)
Måttet Tillgänglighet visar procentandelen av webbtestkörningarna som inte identifierade några problem. Det lägsta möjliga värdet är 0, vilket anger att alla webbtestkörningar har misslyckats. Värdet 100 innebär att alla webbtestkörningar klarade valideringskriterierna.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Procent | Genomsnitt | Körningsplats, testnamn |
availabilityResults
| summarize sum(todouble(success == 1) * 100) / count() by bin(timestamp, 5m), location
| render timechart
Varaktighet för tillgänglighetstest (availabilityResults/duration)
Måttet för varaktighet för tillgänglighetstest visar hur lång tid det tog för webbtestet att köras. För webbtester i flera steg återspeglar måttet den totala körningstiden för alla steg.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Körningsplats, Testnamn, Testresultat |
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
Tillgänglighetstester (availabilityResults/count)
Måttet Tillgänglighetstester visar antalet webbtester som körs av Azure Monitor.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Antal | Antal | Körningsplats, Testnamn, Testresultat |
availabilityResults
| summarize sum(itemCount) by bin(timestamp, 5m)
| render timechart
Webbläsarmått
Webbläsarmått samlas in av Application Insights JavaScript SDK från verkliga slutanvändarens webbläsare. De ger bra insikter om användarnas upplevelse av din webbapp. Webbläsarmått samplas vanligtvis inte, vilket innebär att de ger högre precision för användningssiffrorna jämfört med mått på serversidan som kan skeva genom sampling.
Kommentar
För att samla in webbläsarmått måste ditt program instrumenteras med Application Insights JavaScript SDK.
Inläsningstid för webbläsarsidan (browserTimings/totalDuration)
Tid från användarbegäran tills DOM, formatmallar, skript och bilder läses in.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Ingen |
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
Tid för klientbearbetning (browserTiming/processingDuration)
Tid mellan att ta emot det sista bytet av ett dokument tills DOM läses in. Async-begäranden kan fortfarande bearbetas.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Ingen |
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
Tid för nätverksanslutning för sidinläsning (browserTimings/networkDuration)
Tid mellan användarbegäran och nätverksanslutning. Innehåller DNS-sökning och transportanslutning.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Ingen |
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
Ta emot svarstid (browserTimings/receiveDuration)
Tid mellan första och sista byte eller till frånkoppling.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Ingen |
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
Skicka begärandetid (browserTimings/sendDuration)
Tid mellan nätverksanslutning och mottagning av första byte.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner |
|---|---|---|
| Millisekunder | Genomsnitt, Min, Max | Ingen |
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
Felmått
Måtten i Fel visar problem med bearbetning av begäranden, beroendeanrop och undantag som genereras.
Webbläsarfel (undantag/webbläsare)
Det här måttet visar antalet undantag som genereras från programkoden som körs i webbläsaren. Endast undantag som spåras med ett trackException() Application Insights API-anrop ingår i måttet.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner | Kommentar |
|---|---|---|---|
| Antal | Antal | Ingen | Loggbaserad version använder summaaggregering |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Beroendeanropsfel (beroenden/misslyckade)
Antalet misslyckade beroendeanrop.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner | Kommentar |
|---|---|---|---|
| Antal | Antal | Ingen | Loggbaserad version använder summaaggregering |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Undantag (undantag/antal)
Varje gång du loggar ett undantag till Application Insights anropas metoden trackException() för SDK:n. Måttet Undantag visar antalet loggade undantag.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner | Kommentar |
|---|---|---|---|
| Antal | Antal | Molnrollnamn, Molnrollinstans, Enhetstyp | Loggbaserad version använder summaaggregering |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Misslyckade begäranden (begäranden/misslyckade)
Antalet spårade serverbegäranden som har markerats som misslyckade. Som standard markerar Application Insights SDK automatiskt varje serverbegäran som returnerade HTTP-svarskoden 5xx eller 4xx som en misslyckad begäran. Du kan anpassa den här logiken genom att ändra lyckade egenskaper för telemetriobjekt för begäran i en anpassad telemetriinitierare.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner | Kommentar |
|---|---|---|---|
| Antal | Antal | Molnrollinstans, molnrollnamn, verklig eller syntetisk trafik, prestandabegäran, svarskod | Loggbaserad version använder summaaggregering |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Server-undantag (undantag/server)
Det här måttet visar antalet serverfel.
| Måttenhet | Sammansättningar som stöds | Föraggregerade dimensioner | Kommentar |
|---|---|---|---|
| Antal | Antal | Molnrollnamn, molnrollinstans | Loggbaserad version använder summaaggregering |
exceptions
| where isempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Prestandaräknare
Använd mått i kategorin Prestandaräknare för att komma åt systemprestandaräknare som samlas in av Application Insights.
Tillgängligt minne (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
Undantagsfrekvens (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
Körningstid för HTTP-begäran (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
HTTP-begärandefrekvens (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
HTTP-begäranden i programkön (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
Process-CPU (performanceCounters/processCpuPercentage)
Måttet visar hur mycket av den totala processorkapaciteten som förbrukas av den process som är värd för din övervakade app.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Procent | Genomsnitt, Min, Max | Instans av molntjänstroll |
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
Kommentar
Måttintervallet är mellan 0 och 100 * n, där n är antalet tillgängliga CPU-kärnor. Måttvärdet på 200 % kan till exempel representera full användning av två CPU-kärnor eller en halv användning av 4 CPU-kärnor och så vidare. Process-CPU Normalized är ett alternativt mått som samlas in av många SDK:er som representerar samma värde men delar det med antalet tillgängliga CPU-kärnor. Därför är intervallet för måttet Process CPU Normalized 0 till 100.
Process-I/O-hastighet (performanceCounters/processIOBytesPerSecond)
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Byte per sekund | Genomsnitt, Min, Max | Instans av molntjänstroll |
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
Bearbeta privata byte (performanceCounters/processPrivateBytes)
Mängden icke-delat minne som den övervakade processen allokerade för sina data.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Byte | Genomsnitt, Min, Max | Instans av molntjänstroll |
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
Processortid (performanceCounters/processorCpuPercentage)
CPU-förbrukning av alla processer som körs på den övervakade serverinstansen.
| Måttenhet | Sammansättningar som stöds | Dimensioner som stöds |
|---|---|---|
| Procent | Genomsnitt, Min, Max | Instans av molntjänstroll |
Kommentar
Måttet för processortid är inte tillgängligt för de program som finns i Azure App Services. Använd måttet Bearbeta CPU för att spåra CPU-användningen av webbprogram som finns i 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
Servermått
Beroendeanrop (beroenden/antal)
Det här måttet är i förhållande till antalet beroendeanrop.
dependencies
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Beroendevaraktighet (beroenden/varaktighet)
Det här måttet refererar till varaktigheten för beroendeanrop.
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
Serverbegäranden (begäranden/antal)
Det här måttet visar antalet inkommande serverbegäranden som togs emot av webbappen.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Serversvarstid (begäranden/varaktighet)
Det här måttet återspeglar den tid det tog för servrarna att bearbeta inkommande begäranden.
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
Användningsstatistik
Inläsningstid för sidvisning (pageViews/varaktighet)
Det här måttet refererar till hur lång tid det tog för PageView-händelser att läsas in.
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
Sidvisningar (pageViews/count)
Antalet PageView-händelser som loggats med Api:et TrackPageView() Application Insights.
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sessioner (sessioner/antal)
Det här måttet refererar till antalet distinkta sessions-ID:er.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Spårningar (spårningar/antal)
Antalet spårningsinstruktioner som loggats med Api-anropet TrackTrace() Application Insights.
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Användare (användare/antal)
Antalet distinkta användare som har åtkomst till ditt program. Noggrannheten för det här måttet kan påverkas avsevärt med hjälp av telemetrisampling och filtrering.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_Id)
| summarize dcount(user_Id) by bin(timestamp, 1h)
| render barchart
Användare, autentiserade (användare/autentiserade)
Antalet distinkta användare som autentiserades till ditt program.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_AuthenticatedId)
| summarize dcount(user_AuthenticatedId) by bin(timestamp, 1h)
| render barchart