Protokollbasierte Metriken von Application Insights
Mit den protokollbasierten Metriken von Application Insights können Sie die Integrität Ihrer überwachten Apps analysieren, leistungsstarke Dashboards erstellen und Warnungen konfigurieren. Es gibt zwei Arten von Metriken:
- Protokollbasierte Metriken im Hintergrund werden aus gespeicherten Ereignissen in Kusto-Abfragen übersetzt.
- Standardmetriken werden als vorab aggregierte Zeitreihe gespeichert.
Da Standardmetriken während der Erfassung vorab aggregiert werden, weisen sie zum Abfragezeitpunkt eine bessere Leistung auf. Dies macht sie zu einer besseren Wahl für Dashboarding und Echtzeitwarnungen. Die protokollbasierten Metriken verfügen über mehr Dimensionen, was sie zur überlegenen Option für die Datenanalyse und Ad-hoc-Diagnosen macht. Verwenden Sie die Namespace-Auswahl, um im Metrik-Explorer zwischen protokollbasierten Metriken und Standardmetriken zu wechseln.
Interpretieren und Verwenden von Abfragen aus diesem Artikel
Dieser Artikel listet Metriken mit unterstützten Aggregationen und Dimensionen auf. Zu den Details der protokollbasierten Metriken gehören die zugrunde liegenden Kusto-Abfrageanweisungen. Zur Vereinfachung verwendet jede Abfrage Standardwerte für Zeitgranularität, Diagrammtyp und manchmal auch Teilungsdimensionen, was die Verwendung der Abfrage in Log Analytics vereinfacht, ohne dass Änderungen erforderlich sind.
Wenn Sie die gleiche Metrik im Metrik-Explorer darstellen, gibt es keine Standardwerte – die Abfrage wird dynamisch entsprechend Ihren Diagrammeinstellungen angepasst:
Der ausgewählte Zeitbereich wird in eine zusätzliche where timestamp-Klausel übersetzt, um nur die Ereignisse aus dem ausgewählten Zeitbereich auszuwählen. Bei einem Diagramm, in dem die Daten der letzten 24 Stunden angezeigt werden, enthält die Abfrage | where timestamp > ago(24 h).
Die ausgewählte Zeitgranularität wird in die endgültige summarize ... by bin(timestamp, [time grain])-Klausel aufgenommen.
Alle ausgewählten Filter-Dimensionen werden in zusätzliche where-Klauseln übersetzt.
Die ausgewählte Teilungsdiagramm-Dimension wird in eine zusätzliche Zusammenfassungseigenschaft übersetzt. Wenn Sie beispielsweise Ihr Diagramm nach Standort aufteilen und mit einer Zeitgranularität von 5 Minuten grafisch darstellen, wird die summarize-Klausel in der Form ... by bin(timestamp, 5 m), location zusammengefasst.
Hinweis
Wenn Sie noch nicht mit der Kusto-Abfragesprache vertraut sind, müssen Sie zunächst die Kusto-Anweisungen kopieren und in den Log Analytics-Abfragebereich einfügen, ohne Änderungen vorzunehmen. Klicken Sie auf Ausführen, um das grundlegende Diagramm anzuzeigen. Wenn Sie mit der Syntax der Abfragesprache vertraut sind, können Sie damit beginnen, kleine Änderungen vorzunehmen und die Auswirkung Ihrer Änderung anzuzeigen. Das Untersuchen Ihrer eigenen Daten ist eine gute Möglichkeit, um die volle Leistungsfähigkeit von Log Analytics und Azure Monitor zu erkennen.
Verfügbarkeitsmetriken
Metriken der Kategorie „Verfügbarkeit“ ermöglichen es Ihnen, die Integrität Ihrer Webanwendung so anzuzeigen, wie sie an Punkten auf der ganzen Welt zu beobachten ist. Konfigurieren Sie die Verfügbarkeitstests, damit Sie Metriken aus dieser Kategorie verwenden können.
Verfügbarkeit (availabilityResults/availabilityPercentage)
Die Metrik Verfügbarkeit zeigt den Prozentsatz der Webtestläufe, bei denen keine Probleme erkannt wurden. Der kleinstmögliche Wert ist 0 und gibt an, dass bei allen Webtestläufen Fehler aufgetreten sind. Der Wert 100 bedeutet, dass alle Webtestläufe die Überprüfungskriterien erfüllt haben.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Prozentwert | Average | Ausführungsort, Testname |
availabilityResults
| summarize sum(todouble(success == 1) * 100) / count() by bin(timestamp, 5m), location
| render timechart
Verfügbarkeitstestdauer (availabilityResults/duration)
Die Metrik Verfügbarkeitstestdauer gibt an, wie lange die Ausführung des Webtests gedauert hat. Bei den mehrstufigen Webtests spiegelt die Metrik die gesamte Ausführungszeit aller Stufen wider.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Ausführungsort, Testname, Testergebnis |
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
Verfügbarkeitstests (availabilityResults/count)
Die Metrik Verfügbarkeitstests spiegelt die Anzahl der von Azure Monitor ausgeführten Webtests wider.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Anzahl | Anzahl | Ausführungsort, Testname, Testergebnis |
availabilityResults
| summarize sum(itemCount) by bin(timestamp, 5m)
| render timechart
Browsermetriken
Browsermetriken werden vom Application Insights JavaScript SDK aus echten Endbenutzerbrowsern gesammelt. Sie bieten nützliche Einblicke in die Erfahrungen der Benutzer mit Ihrer Webanwendung. Für Browsermetriken werden in der Regel keine Stichproben verwendet, was bedeutet, dass sie eine höhere Genauigkeit der Nutzungszahlen bieten als serverseitige Metriken, die durch die Verwendung von Stichproben verzerrt sein können.
Hinweis
Um Browsermetriken zu erfassen, muss Ihre Anwendung mit dem Application Insights JavaScript SDK ausgestattet sein.
Browser-Seitenladezeit (browserTimings/totalDuration)
Zeit ab der Benutzeranforderung, bis DOM, Stylesheets, Skripts und Bilder geladen werden.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Keine |
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
Clientverarbeitungszeit (browserTiming/processingDuration)
Zeit zwischen dem Empfang des letzten Byte eines Dokuments und dem Laden des DOM. Asynchrone Anforderungen werden möglicherweise immer noch verarbeitet.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Keine |
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
Netzwerkverbindungszeit zum Laden der Seite (browserTimings/networkDuration)
Zeit zwischen Benutzeranforderung und Netzwerkverbindung. Umfasst DNS-Suche und Transportverbindung.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Keine |
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
Empfängt Antwortzeit (browserTimings/receiveDuration)
Zeit zwischen dem ersten und letzten Byte, oder bis zur Verbindungstrennung.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Keine |
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
Anforderungszeit senden (browserTimings/sendDuration)
Zeit zwischen der Netzwerkverbindung und dem Empfang des ersten Byte.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen |
|---|---|---|
| Millisekunden | Durchschnitt, Minimum, Maximum | Keine |
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
Fehlermetriken
Die Metriken der Kategorie Fehler zeigen Probleme bei der Verarbeitung von Anforderungen, Abhängigkeitsaufrufen und ausgelösten Ausnahmen.
Browserausnahmen (exceptions/browser)
Diese Metrik spiegelt die Anzahl der ausgelösten Ausnahmen von Ihrem Anwendungscode im Browser wider. Nur Ausnahmen, die mit einem trackException() Application Insights API-Aufruf verfolgt werden, sind in der Metrik enthalten.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen | Notizen |
|---|---|---|---|
| Anzahl | Anzahl | Keine | Protokollbasierte Version verwendet Sum-Aggregation |
exceptions
| where notempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Fehler bei Abhängigkeitsaufrufen (dependencies/failed)
Die Anzahl fehlerhafter Abhängigkeitsaufrufe.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen | Notizen |
|---|---|---|---|
| Anzahl | Anzahl | Keine | Protokollbasierte Version verwendet Sum-Aggregation |
dependencies
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Ausnahmen (exceptions/count)
Jedes Mal, wenn Sie eine Ausnahme bei Application Insights protokollieren, erfolgt ein Aufruf der trackException()-Methode des SDK. Die Metrik „Ausnahmen“ zeigt die Anzahl der protokollierten Ausnahmen an.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen | Notizen |
|---|---|---|---|
| Anzahl | Anzahl | Cloudrollenname, Cloudrolleninstanz, Gerätetyp | Protokollbasierte Version verwendet Sum-Aggregation |
exceptions
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Fehlerhafte Anforderungen (requests/failed)
Die Anzahl der verfolgten Serveranforderungen, die als fehlgeschlagen markiert wurden. Standardmäßig markiert das Application Insights SDK automatisch jede Serveranforderung, die den HTTP-Antwortcode 5xx oder 4xx zurückgegeben hat, als fehlerhafte Anforderung. Sie können diese Logik anpassen, indem Sie die Eigenschaft Erfolg des Anforderungstelemetrieelements in einem benutzerdefinierten Telemetrieinitialisierer ändern.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen | Notizen |
|---|---|---|---|
| Anzahl | Anzahl | Cloudrolleninstanz, Cloudrollenname, Echter oder synthetischer Datenverkehr, Anforderungsleistung, Antwortcode | Protokollbasierte Version verwendet Sum-Aggregation |
requests
| where success == 'False'
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Serverausnahmen (exceptions/server)
Diese Metrik zeigt die Anzahl der Serverausnahmen.
| Unit of measure | Unterstützte Aggregationen | Vorab aggregierte Dimensionen | Notizen |
|---|---|---|---|
| Anzahl | Anzahl | Cloudrollenname, Cloudrolleninstanz | Protokollbasierte Version verwendet Sum-Aggregation |
exceptions
| where isempty(client_Browser)
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Leistungsindikatoren
Verwenden Sie Metriken in der Kategorie Leistungsindikatoren, um auf die von Application Insights erfassten Systemleistungsindikatoren zuzugreifen.
Verfügbarer Speicher (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
Ausnahmerate (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
Ausführungszeit der HTTP-Anforderung (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-Anforderungsrate (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-Anforderungen in der Anwendungswarteschlange (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
Prozess-CPU (performanceCounters/processCpuPercentage)
Die Metrik zeigt, wie viel der gesamten Prozessorleistung von dem Prozess genutzt wird, der Ihre überwachte App hostet.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Prozentwert | Durchschnitt, Minimum, Maximum | Cloudrolleninstanz |
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
Hinweis
Der Metrikbereich liegt zwischen 0 und 100 * n, wobei n für die Anzahl der verfügbaren CPU-Kerne steht. Beispielsweise kann der Metrikwert von 200 % die vollständige Auslastung von zwei CPU-Kernen oder die halbe Auslastung von 4 CPU-Kernen usw. darstellen. Bei normalisierte Prozess-CPU handelt es sich um eine alternative Metrik, die von vielen SDKs erfasst wird und denselben Wert darstellt, diesen jedoch durch die Anzahl der verfügbaren CPU-Kerne dividiert. Daher liegt der Bereich der Metrik normalisierte Prozess-CPU zwischen 0 und 100.
E/A-Rate des Prozesses (performanceCounters/processIOBytesPerSecond)
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Bytes pro Sekunde | Durchschnitt, Minimum, Maximum | Cloudrolleninstanz |
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
Private Bytes des Prozesses (performanceCounters/processPrivateBytes)
Menge des nicht gemeinsam genutzten Arbeitsspeichers, die der überwachte Prozess für seine Daten reserviert hat.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Byte | Durchschnitt, Minimum, Maximum | Cloudrolleninstanz |
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
Prozessorzeit (performanceCounters/processorCpuPercentage)
CPU-Auslastung durch alle Prozesse, die auf der überwachten Serverinstanz ausgeführt werden.
| Unit of measure | Unterstützte Aggregationen | Unterstützte Dimensionen |
|---|---|---|
| Prozentwert | Durchschnitt, Minimum, Maximum | Cloudrolleninstanz |
Hinweis
Die Prozessorzeitmetrik ist für die in Azure App Services gehosteten Anwendungen nicht verfügbar. Verwenden Sie die Metrik Prozess-CPU, um die CPU-Auslastung der in App Services gehosteten Webanwendungen nachzuverfolgen.
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
Servermetriken
Abhängigkeitsaufrufe (dependencies/count)
Diese Metrik bezieht sich auf die Anzahl der Abhängigkeitsaufrufe.
dependencies
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Dauer der Abhängigkeit (dependencies/duration)
Diese Metrik bezieht sich auf die Dauer von Abhängigkeitsaufrufen.
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
Serveranforderungen (requests/count)
Diese Metrik spiegelt die Anzahl der eingehenden Serveranforderungen wider, die von Ihrer Webanwendung empfangen wurden.
requests
| summarize sum(itemCount) by bin(timestamp, 5m)
| render barchart
Serverantwortzeit (requests/duration)
Diese Metrik spiegelt die Zeit wider, die die Server für die Verarbeitung eingehender Anforderungen benötigt haben.
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
Nutzungsmetriken
Ladezeit der Seitenansicht (pageViews/duration)
Diese Metrik bezieht sich auf die Zeit, die für das Laden von PageView-Ereignissen benötigt wurde.
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
Seitenaufrufe (pageViews/count)
Die Anzahl der PageView-Ereignisse, die mit der TrackPageView() Application Insights API protokolliert wurden.
pageViews
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Sitzungen (sessions/count)
Diese Metrik bezieht sich auf die Anzahl der unterschiedlichen Sitzungs-IDs.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(session_Id)
| summarize dcount(session_Id) by bin(timestamp, 1h)
| render barchart
Überwachungen (traces/count)
Die Anzahl der mit dem TrackTrace() Application Insights API-Aufruf protokollierten Überwachungsanweisungen.
traces
| summarize sum(itemCount) by bin(timestamp, 1h)
| render barchart
Benutzer (users/count)
Die Anzahl der unterschiedlichen Benutzer, die auf Ihre Anwendung zugegriffen haben. Die Genauigkeit dieser Metrik kann durch die Verwendung von Telemetriestichproben und Filtern erheblich beeinträchtigt werden.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_Id)
| summarize dcount(user_Id) by bin(timestamp, 1h)
| render barchart
Benutzer, Authentifiziert (users/authenticated)
Die Anzahl der unterschiedlichen Benutzer, die sich bei Ihrer Anwendung authentifiziert haben.
union traces, requests, pageViews, dependencies, customEvents, availabilityResults, exceptions, customMetrics, browserTimings
| where notempty(user_AuthenticatedId)
| summarize dcount(user_AuthenticatedId) by bin(timestamp, 1h)
| render barchart