Metriche basate su log di Application Insights
Le metriche basate su log di Application Insights consentono di analizzare l'integrità delle app monitorate, creare potenti dashboard e configurare avvisi. Ci sono due tipi di metriche:
- Metriche basate su log convertite in background in query Kusto dagli eventi archiviati.
- Le metriche standard vengono archiviate come serie temporali preaggregate.
Poiché le metriche standard vengono preaggregate durante la raccolta, hanno prestazioni migliori in fase di query. Ciò le rende una scelta migliore per i dashboard e gli avvisi in tempo reale. Le metriche basate su log hanno più dimensioni, che le rendono l'opzione migliore per l'analisi dei dati e la diagnostica ad hoc. Usare il selettore dello spazio dei nomi per passare tra le metriche basate su log e quelle standard in Esplora metriche.
Interpretare e usare le query di questo articolo
Questo articolo elenca le metriche con aggregazioni e dimensioni supportate. I dettagli sulle metriche basate su log includono le istruzioni di query Kusto sottostanti. Per praticità, ogni query usa le impostazioni predefinite per la granularità temporale, il tipo di grafico e talvolta la divisione della dimensione, semplificando l'uso della query in Log Analytics senza alcuna necessità di modifica.
Quando si traccia la stessa metrica in Esplora metriche, non esistono impostazioni predefinite: la query viene modificata dinamicamente in base alle impostazioni del grafico:
L'intervallo di tempo selezionato viene convertito in un'ulteriore clausola timestamp... per selezionare solo gli eventi dall'intervallo di tempo selezionato. Ad esempio, un grafico che mostra i dati per le ultime 24 ore, la query include | dove timestamp > ago(24 h).
La granularità temporale selezionata viene inserita nel riepilogo finale ... clausola by bin(timestamp, [time grain]).
Tutte le dimensioni del filtro selezionate vengono convertite in clausole where aggiuntive.
La dimensione Split chart selezionata viene convertita in una proprietà summarize aggiuntiva. Ad esempio, se si divide il grafico in base alla posizione e si traccia usando una granularità di 5 minuti, la clausola summarize viene riepilogata ... per bin(timestamp, 5 m), posizione.
Nota
Se non si ha familiarità con il linguaggio di query Kusto, iniziare copiando e incollando le istruzioni Kusto nel riquadro query di Log Analytics senza apportare alcuna modifica. Fare clic su Esegui per visualizzare il grafico di base. Quando si inizia a comprendere la sintassi del linguaggio di query, è possibile iniziare a apportare piccole modifiche e visualizzare l'impatto della modifica. L'esplorazione dei propri dati è un ottimo modo per iniziare a sfruttare al meglio Log Analytics e Monitoraggio di Azure.
Metriche di disponibilità
Le metriche nella categoria Disponibilità consentono di visualizzare l'integrità dell'applicazione Web come osservato dai punti in tutto il mondo. Configurare i test di disponibilità per iniziare a usare qualsiasi metrica di questa categoria.
Disponibilità (availabilityResults/availabilityPercentage)
La metrica Disponibilità mostra la percentuale delle esecuzioni di test Web che non hanno rilevato problemi. Il valore più basso possibile è 0, che indica che tutte le esecuzioni di test Web non sono riuscite. Il valore 100 indica che tutte le esecuzioni di test Web hanno superato i criteri di convalida.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Percentuale | Media | Percorso di esecuzione, Nome test |
availabilityResults
| summarize sum(todouble(success == 1) * 100) / count() by bin(timestamp, 5m), location
| render timechart
Durata del test di disponibilità (availabilityResults/duration)
La metrica Durata test di disponibilità mostra il tempo necessario per l'esecuzione del test Web. Per i test Web in più passaggi, la metrica riflette il tempo di esecuzione totale di tutti i passaggi.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Millisecondi | Average, Min, Max | Percorso di esecuzione, Nome test, Risultato 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 di disponibilità (availabilityResults/count)
La metrica Test di disponibilità riflette il numero di test Web eseguiti da Monitoraggio di Azure.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Conteggio | Conteggio | Percorso di esecuzione, Nome test, Risultato test |
availabilityResults
| summarize sum(itemCount) by bin(timestamp, 5m)
| render timechart
Metriche del browser
Le metriche del browser vengono raccolte da Application Insights JavaScript SDK da browser utente finali reali. Forniscono informazioni dettagliate dettagliate sull'esperienza degli utenti con l'app Web. Le metriche del browser in genere non vengono campionate, il che significa che forniscono una maggiore precisione dei numeri di utilizzo rispetto alle metriche lato server che potrebbero essere asimmetriche dal campionamento.
Nota
Per raccogliere le metriche del browser, l'applicazione deve essere instrumentata con Application Insights JavaScript SDK.
Tempo di caricamento della pagina del browser (browserTimings/totalDuration)
Tempo compreso tra la richiesta utente e il caricamento di DOM, fogli di stile, script e immagini.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate |
|---|---|---|
| Millisecondi | Average, Min, Max | None |
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
Tempo di elaborazione client (browserTiming/processingDuration)
Tempo compreso tra la ricezione dell'ultimo byte di un documento e il caricamento del DOM. Le richieste asincrone potrebbero essere ancora in fase di elaborazione.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate |
|---|---|---|
| Millisecondi | Average, Min, Max | None |
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
Tempo di connessione di rete di caricamento pagine (browserTimings/networkDuration)
Tempo tra la richiesta utente e la connessione di rete. Include la connessione di trasporto e di ricerca DNS.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate |
|---|---|---|
| Millisecondi | Average, Min, Max | None |
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
Ricezione del tempo di risposta (browserTimings/receiveDuration)
Tempo compreso tra il primo e l'ultimo byte o fino alla disconnessione.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate |
|---|---|---|
| Millisecondi | Average, Min, Max | None |
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
Ora richiesta di invio (browserTimings/sendDuration)
Tempo compreso tra la connessione di rete e la ricezione del primo byte.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate |
|---|---|---|
| Millisecondi | Average, Min, Max | None |
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
Metriche di errore
Le metriche in Errori mostrano problemi con l'elaborazione di richieste, chiamate di dipendenza e eccezioni generate.
Eccezioni del browser (eccezioni/browser)
Questa metrica riflette il numero di eccezioni generate dal codice dell'applicazione in esecuzione nel browser. Nella metrica sono incluse solo le eccezioni rilevate con una trackException() chiamata API di Application Insights.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate | Note |
|---|---|---|---|
| Conteggio | Conteggio | None | La versione basata su log usa l'aggregazione Sum |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Errori di chiamata alle dipendenze (dipendenze/errore)
Numero di chiamate di dipendenza non riuscite.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate | Note |
|---|---|---|---|
| Conteggio | Conteggio | None | La versione basata su log usa l'aggregazione Sum |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Eccezioni (eccezioni/conteggio)
Ogni volta che si registra un'eccezione ad Application Insights, viene eseguita una chiamata al metodo trackException() dell'SDK. La metrica Eccezioni mostra il numero di eccezioni registrate.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate | Note |
|---|---|---|---|
| Conteggio | Conteggio | Nome del ruolo cloud, Istanza del ruolo cloud, Tipo di dispositivo | La versione basata su log usa l'aggregazione Sum |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Richieste non riuscite (richieste/non riuscite)
Numero di richieste server rilevate contrassegnate come non riuscite. Per impostazione predefinita, Application Insights SDK contrassegna automaticamente ogni richiesta del server che ha restituito il codice di risposta HTTP 5xx o 4xx come richiesta non riuscita. È possibile personalizzare questa logica modificando la proprietà success dell'elemento di telemetria della richiesta in un inizializzatore di telemetria personalizzato.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate | Note |
|---|---|---|---|
| Conteggio | Conteggio | Istanza del ruolo cloud, nome del ruolo cloud, traffico reale o sintetico, prestazioni della richiesta, codice di risposta | La versione basata su log usa l'aggregazione Sum |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Eccezioni del server (eccezioni/server)
Questa metrica mostra il numero di eccezioni del server.
| Unità di misura | Aggregazioni supportate | Dimensioni preaggregate | Note |
|---|---|---|---|
| Conteggio | Conteggio | Nome del ruolo cloud, istanza del ruolo cloud | La versione basata su log usa l'aggregazione Sum |
exceptions
| where isempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Contatori delle prestazioni
Usare le metriche nella categoria Contatori delle prestazioni per accedere ai contatori delle prestazioni del sistema raccolti da Application Insights.
Memoria disponibile (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
Frequenza delle eccezioni (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
Tempo di esecuzione della richiesta 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
Frequenza delle richieste 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
Richieste HTTP nella coda dell'applicazione (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
CPU del processo (performanceCounters/processCpuPercentage)
La metrica mostra la quantità totale di capacità del processore utilizzata dal processo che ospita l'app monitorata.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Percentuale | Average, Min, Max | Istanza del ruolo del 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
Nota
L'intervallo della metrica è compreso tra 0 e 100 * n, dove n è il numero di core CPU disponibili. Ad esempio, il valore della metrica del 200% potrebbe rappresentare l'utilizzo completo di due core CPU o metà utilizzo di 4 core CPU e così via. Process CPU Normalized è una metrica alternativa raccolta da molti SDK che rappresenta lo stesso valore, ma la divide per il numero di core CPU disponibili. Di conseguenza, l'intervallo della metrica Process CPU Normalized è compreso tra 0 e 100.
Velocità di I/O del processo (performanceCounters/processIOBytesPerSecond)
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Byte al secondo | Average, Min, Max | Istanza del ruolo del 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
Elaborare byte privati (performanceCounters/processPrivateBytes)
Quantità di memoria non condivisa allocata dal processo monitorato per i dati.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Byte | Average, Min, Max | Istanza del ruolo del 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
Tempo processore (performanceCounters/processorCpuPercentage)
Utilizzo della CPU da parte di tutti i processi in esecuzione nell'istanza del server monitorato.
| Unità di misura | Aggregazioni supportate | Dimensioni supportate |
|---|---|---|
| Percentuale | Average, Min, Max | Istanza del ruolo del cloud |
Nota
La metrica relativa al tempo del processore non è disponibile per le applicazioni ospitate in app Azure Services. Usare la metrica Elaborazione CPU per tenere traccia dell'utilizzo della CPU delle applicazioni Web ospitate in servizio app.
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
Metriche del server
Chiamate di dipendenza (dipendenze/conteggio)
Questa metrica è in relazione al numero di chiamate di dipendenza.
dependencies
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Durata delle dipendenze (dipendenze/durata)
Questa metrica si riferisce alla durata delle chiamate alle dipendenze.
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
Richieste server (richieste/conteggio)
Questa metrica riflette il numero di richieste server in ingresso ricevute dall'applicazione Web.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Tempo di risposta del server (richieste/durata)
Questa metrica riflette il tempo necessario per i server per elaborare le richieste in ingresso.
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
Metriche di utilizzo
Tempo di caricamento della visualizzazione pagina (pageViews/duration)
Questa metrica si riferisce alla quantità di tempo impiegato per il caricamento degli eventi 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
Visualizzazioni pagina (pageViews/count)
Numero di eventi PageView registrati con l'API Application Insights TrackPageView().
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sessioni (sessioni/conteggio)
Questa metrica si riferisce al numero di ID sessione distinti.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Tracce (tracce/conteggio)
Conteggio delle istruzioni di traccia registrate con la chiamata API Di Application Insights TrackTrace().
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Utenti (utenti/conteggio)
Numero di utenti distinti che hanno eseguito l'accesso all'applicazione. L'accuratezza di questa metrica può essere significativamente influenzata usando il campionamento e il filtro dei dati di telemetria.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_Id)
| summarize dcount(user_Id) by bin(timestamp, 1h)
| render barchart
Utenti, autenticati (utenti/autenticati)
Numero di utenti distinti che hanno eseguito l'autenticazione nell'applicazione.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_AuthenticatedId)
| summarize dcount(user_AuthenticatedId) by bin(timestamp, 1h)
| render barchart
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per