Beispiele für MQL-Abfragen

In diesem Dokument wird Monitoring Query Language (MQL) anhand von Beispielen vorgestellt. Dabei werden jedoch nicht alle Aspekte der Sprache berücksichtigt. MQL ist in der Referenz zur Monitoring Query Language umfassend dokumentiert.

Informationen zu MQL-basierten Benachrichtigungsrichtlinien finden Sie unter Benachrichtigungsrichtlinien mit MQL.

Sie können eine bestimmte Abfrage in vielen Formen schreiben. Die Sprache ist flexibel und es gibt viele Tastenkombinationen, die Sie verwenden können, wenn Sie mit der Syntax vertraut sind. Weitere Informationen finden Sie unter Strict-Form-Abfragen.

Hinweise

So greifen Sie mit dem Metrics Explorer auf den Codeeditor zu:

1. Wählen Sie im Navigationsbereich der Google Cloud Console Monitoring und anschließend  Metrics Explorer aus:

   Zum Metrics Explorer

2. Klicken Sie in der Symbolleiste des Bereichs "Query Builder" auf die Schaltfläche  MQL oder  PromQL.
3. Prüfen Sie, ob MQL im Schalter Sprache ausgewählt ist. Die Sprachschaltfläche befindet sich in derselben Symbolleiste, mit der Sie Ihre Abfrage formatieren können.

Um eine Abfrage auszuführen, fügen Sie sie in den Editor ein und klicken auf Abfrage ausführen. Eine Einführung in diesen Editor finden Sie unter Codeeditor für MQL verwenden.

Ein wenig Erfahrung mit Cloud Monitoring-Konzepten wie Messwerttypen, Typen überwachter Ressourcen und Zeitachsen ist hilfreich. Eine Einführung in diese Konzepte finden Sie unter Messwerte, Zeitachsen und Ressourcen.

Datenmodell

MQL-Abfragen rufen Daten in der Zeitachsendatenbank von Cloud Monitoring ab und bearbeiten sie. In diesem Abschnitt werden einige Konzepte und Begriffe der Datenbank vorgestellt. Ausführliche Informationen finden Sie im Referenzthema Datenmodell.

Jede Zeitachse stammt von einem einzelnen Typ von überwachter Ressource und jede Zeitachse erfasst Daten eines einzigen Messwerttyps. Ein Deskriptor für überwachte Ressourcen definiert einen Typ einer überwachten Ressource. In ähnlicher Weise definiert ein Messwertdeskriptor einen Messwerttyp. Beispielsweise kann der Ressourcentyp gce_instance, eine Compute Engine-VM, und der Messwerttyp compute.googleapis.com/instance/cpu/utilization, die CPU-Auslastung der Compute Engine-VM, sein.

Diese Deskriptoren geben auch eine Reihe von Labels an, mit denen Informationen zu anderen Attributen des Messwerts oder Ressourcentyps erfasst werden. Ressourcen haben beispielsweise normalerweise das Label zone, mit dem der geografische Standort der Ressource aufgezeichnet wird.

Für jede Kombination von Werten für die Labels aus dem Paar aus Messwertdeskriptor und Deskriptor für überwachte Ressourcen wird eine Zeitachse erstellt.

Die verfügbaren Labels für Ressourcentypen finden Sie in der Liste der überwachten Ressourcen, z. B. gce_instance. Die Labels für Messwerttypen finden Sie in der Messwertliste, z. B. Messwerte aus Compute Engine.

Die Cloud Monitoring-Datenbank speichert die Zeitachsen eines bestimmten Messwerts und Ressourcentyps in einer Tabelle. Der Messwert und der Ressourcentyp dienen als Kennung für die Tabelle. Diese MQL-Abfrage ruft die Tabelle der Zeitachsen ab, die die CPU-Auslastung für Compute Engine-Instanzen aufzeichnen:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization

Die Tabelle enthält eine Zeitachse für jede eindeutige Kombination von Messwert- und Ressourcenlabelwerten.

MQL-Abfragen rufen Zeitachsendaten aus diesen Tabellen ab und wandeln sie in Ausgabetabellen um. Diese Ausgabetabellen können an andere Vorgänge übergeben werden. Sie können beispielsweise die Zeitachsen isolieren, die von Ressourcen in einer bestimmten Zone oder einer Gruppe von Zonen geschrieben werden, indem Sie die abgerufene Tabelle als Eingabe an einen filter - Vorgang übergeben:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter zone =~ 'us-central.*'

Die vorherige Abfrage führt zu einer Tabelle, die nur die Zeitachsen von Ressourcen in einer Zone enthält, die mit us-central beginnt.

MQL-Abfragen sind so strukturiert, dass die Ausgabe eines Vorgangs als Eingabe an den nächsten Vorgang übergeben wird. Bei diesem tabellenbasierten Ansatz können Sie Vorgänge verknüpfen, um diese Daten durch Filterung, Auswahl und andere vertraute Datenbankvorgänge wie Inner und Outer Joins zu bearbeiten. Sie können auch verschiedene Funktionen für die Daten in der Zeitachse ausführen, wenn die Daten von einem Vorgang an einen anderen übergeben werden.

Die in MQL verfügbaren Vorgänge und Funktionen sind in der Referenz zur Monitoring-Abfragesprache vollständig dokumentiert.

Abfragestruktur

Eine Abfrage besteht aus einem oder mehreren operations. Vorgänge sind miteinander verknüpft oder in Pipelines zusammengefasst, sodass die Ausgabe eines Vorgangs die Eingabe für den nächsten ist. Daher hängt das Ergebnis einer Abfrage von der Reihenfolge der Vorgänge ab. Sie können unter anderem Folgendes tun:

• Starten Sie eine Abfrage mit einem fetch oder einem anderen Auswahlvorgang.
• Erstellen Sie eine Abfrage mit mehreren Vorgängen, die miteinander verbunden sind.
• Wählen Sie eine Teilmenge der Informationen mit filter-Vorgängen aus.
• Aggregieren Sie verwandte Informationen mit group_by - Vorgängen.
• Sehen Sie sich Ausreißer mit top - und bottom - Vorgängen an.
• Kombinieren Sie mehrere Abfragen mit den Vorgängen { ; } und join.
• Verwenden Sie die value - Operation und -Funktionen, um Verhältnisse und andere Werte zu berechnen.

Nicht alle Abfragen verwenden alle diese Optionen.

In diesen Beispielen werden nur einige der verfügbaren Vorgänge und Funktionen vorgestellt. Ausführliche Informationen zur Struktur von MQL-Abfragen finden Sie unter Abfragestruktur.

Diese Beispiele geben keine zwei Dinge an, die Sie erwarten könnten: Zeiträume und Ausrichtung. In den folgenden Abschnitten wird erläutert, warum.

Zeiträume

Wenn Sie den Code-Editor verwenden, wird der Zeitraum für Abfragen in den Diagrammeinstellungen definiert. Standardmäßig ist der Zeitraum für das Diagramm auf eine Stunde festgelegt.

Über die Zeitraumauswahl können Sie den Zeitraum des Diagramms ändern. Wenn Sie beispielsweise die Daten für die vergangene Woche sehen möchten, wählen Sie Letzte 1 Woche in der Zeitraumauswahl aus. Du kannst auch eine Start- und Endzeit oder eine Uhrzeit für die Wiedergabe angeben.

Weitere Informationen zu Zeiträumen im Code-Editor finden Sie unter Zeiträume, Diagramme und Code-Editor.

Ausrichtung

Viele der in diesen Beispielen verwendeten Vorgänge, wie die Vorgänge join und group_by, hängen von allen Zeitachsenpunkten in einer Tabelle ab, die in regelmäßigen Abständen auftreten. Der Vorgang, bei dem alle Punkte mit regelmäßigen Zeitstempeln ausgerichtet werden, wird als alignment bezeichnet. Normalerweise wird die Ausrichtung implizit durchgeführt und in keinem der Beispiele wird sie gezeigt.

MQL richtet Tabellen für join- und group_by-Vorgänge bei Bedarf automatisch aus. Mit MQL können Sie die Ausrichtung aber auch explizit vornehmen.

• Allgemeine Informationen zum Konzept der Ausrichtung finden Sie unter Ausrichtung: Aggregation innerhalb einer Reihe.

• Informationen zur Ausrichtung in MQL finden Sie unter Ausrichtung. Die Ausrichtung kann mithilfe der Vorgänge align und every explizit gesteuert werden.

Daten abrufen und filtern

MQL-Abfragen beginnen mit dem Abrufen und Auswählen oder Filtern von Daten. In diesem Abschnitt werden einige grundlegende Informationen zum Abrufen und Filtern mit MQL erläutert.

Zeitreihendaten abrufen

Eine Abfrage beginnt immer mit einem fetch-Vorgang, der Zeitachsen von Cloud Monitoring abruft.

Die einfachste Abfrage besteht aus einem einzelnen fetch-Vorgang und einem Argument, das die abzurufende Zeitachse angibt. Beispiel:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization

Das Argument besteht aus einem überwachten Ressourcentyp gce_instance, einem Doppelpunktzeichenpaar :: und einem Messwerttyp compute.googleapis.com/instance/cpu/utilization.

Diese Abfrage ruft die von Compute Engine-Instanzen geschriebenen Zeitachsen für den Messwerttyp compute.googleapis.com/instance/cpu/utilization ab, der die CPU-Auslastung dieser Instanzen aufzeichnet.

Wenn Sie die Abfrage über den Code-Editor im Metrics Explorer ausführen, erhalten Sie ein Diagramm mit jeder der angeforderten Zeitachsen:

Jede der angeforderten Zeitreihen wird als Linie im Diagramm angezeigt. Jede Zeitachse enthält eine Liste mit Zeitstempelwerten aus dem Messwert zur CPU-Auslastung für eine VM-Instanz in diesem Projekt.

Im von Cloud Monitoring verwendeten Backend-Speicher werden Zeitachsen in Tabellen gespeichert. Der fetch-Vorgang organisiert die Zeitachsen für die angegebenen Typen von überwachten Ressourcen und Messwerten in einer Tabelle und gibt dann die Tabelle zurück. Die zurückgegebenen Daten werden im Diagramm angezeigt.

Der fetch - Vorgang wird zusammen mit seinen Argumenten auf der fetch - Referenzseite beschrieben. Weitere Informationen zu den von Vorgängen generierten Daten finden Sie auf den Referenzseiten für Zeitachsen und Tabellen.

Vorgänge filtern

Abfragen bestehen in der Regel aus einer Kombination mehrerer Vorgänge. Die einfachste Kombination besteht darin, die Ausgabe eines Vorgangs mithilfe des Pipe-Operators | in die Eingabe des nächsten zu leiten. Im folgenden Beispiel wird gezeigt, wie die Tabelle mithilfe einer Pipe in einen Filtervorgang eingegeben wird:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter instance_name =~ 'gke.*'

Diese Abfrage leitet die vom fetch-Vorgang im vorherigen Beispiel zurückgegebene Tabelle an einen filter-Vorgang weiter, der als Ausdruck verwendet wird, der einen booleschen Wert ergibt. In diesem Beispiel bedeutet der Ausdruck "instance_name beginnt mit gke".

Der Vorgang filter verwendet die Eingabetabelle, entfernt die Zeitachse, für die der Filter falsch ist, und gibt die resultierende Tabelle aus. Der folgende Screenshot zeigt das resultierende Diagramm:

Wenn Sie keine Instanznamen haben, die mit gke beginnen, ändern Sie den Filter, bevor Sie diese Abfrage ausführen. Wenn Sie beispielsweise VM-Instanzen mit apache am Anfang ihrer Namen haben, verwenden Sie den folgenden Filter:

 | filter instance_name =~ 'apache.*'

Der Ausdruck filter wird für jede Eingabezeitachse einmal ausgewertet. Wenn der Ausdruck true ergibt, wird diese Zeitachse in die Ausgabe aufgenommen. In diesem Beispiel führt der Filterausdruck eine Übereinstimmung mit einem regulären Ausdruck (=~) mit dem Label instance_name jeder Zeitachse durch. Wenn der Wert des Labels mit dem regulären Ausdruck 'gke.*' übereinstimmt, wird die Zeitachse in die Ausgabe aufgenommen. Andernfalls wird die Zeitreihe aus der Ausgabe entfernt.

Weitere Informationen zum Filtern finden Sie auf der filter-Referenzseite. Das Prädikat filter kann ein beliebiger Ausdruck sein, der einen booleschen Wert zurückgibt. Weitere Informationen finden Sie unter Ausdrücke.

Gruppieren und Aggregieren

Mit Gruppierung können Sie Zeitachsen nach bestimmten Dimensionen gruppieren. Bei der Aggregation werden alle Zeitachsen in einer Gruppe zu einer Ausgabezeitachse kombiniert.

Die folgende Abfrage filtert die Ausgabe des anfänglichen fetch - Vorgangs, um nur die Zeitachsen von Ressourcen in einer Zone beizubehalten, die mit us-central beginnt. Anschließend werden die Zeitachsen nach Zone gruppiert und mithilfe der mean - Aggregation kombiniert.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter zone =~ 'us-central.*'
| group_by [zone], mean(val())

Die Tabelle, die sich aus dem Vorgang group_by ergibt, enthält eine Zeitachse pro Zone. Der folgende Screenshot zeigt das resultierende Diagramm:

Der Vorgang group_by akzeptiert zwei Argumente, die durch ein Komma getrennt sind: ,. Diese Argumente bestimmen das genaue Gruppierungsverhalten. In diesem Beispiel group_by [zone], mean(val()) verhalten sich die Argumente so:

• Das erste Argument, [zone], ist ein Zuordnungsausdruck, der die Gruppierung der Zeitachsen bestimmt. In diesem Beispiel werden die für die Gruppierung zu verwendenden Labels angegeben. Beim Gruppierungsschritt werden alle Eingabezeitachsen mit denselben zone-Ausgabewerten in einer Gruppe zusammengefasst. In diesem Beispiel erfasst der Ausdruck die Zeitachsen von den Compute Engine-VMs in einer Zone.

  Die Ausgabezeitachse hat nur das Label zone, wobei der Wert aus der Eingabezeitachse in der Gruppe kopiert wird. Andere Labels in der Eingabezeitachse werden aus der Ausgabezeitachse entfernt.

  Der Kartenausdruck kann viel mehr als nur Listenlabels. Weitere Informationen finden Sie auf der map-Referenzseite.

• Das zweite Argument, mean(val()), bestimmt, wie die Zeitachsen in jeder Gruppe zu einer Ausgabezeitachse kombiniert bzw. aggregated (zusammengefasst) werden. Jeder Punkt in der Ausgabezeitachse für eine Gruppe ist das Ergebnis der Aggregation der Punkte mit demselben Zeitstempel aus allen Eingabezeitachsen in der Gruppe.

  Die Aggregationsfunktion, in diesem Beispiel mean, bestimmt den aggregierten Wert. Die Funktion val() gibt die zu aggregierenden Punkte zurück. Die Aggregationsfunktion wird auf diese Punkte angewendet. In diesem Beispiel erhalten Sie den Mittelwert der CPU-Auslastung der virtuellen Maschinen in der Zone zu jedem Ausgabezeitpunkt.

  Der Ausdruck mean(val()) ist ein Beispiel für einen Aggregationsausdruck.

Der Vorgang group_by kombiniert immer Gruppierung und Aggregation. Wenn Sie eine Gruppierung angeben, aber das Aggregationsargument weglassen, verwendet group_by die Standardaggregation aggregate(val()), mit der eine geeignete Funktion für den Datentyp ausgewählt wird. Eine Liste der Standardaggregationsfunktionen finden Sie unter aggregate.

group_by mit einem logbasierten Messwert verwenden

Angenommen, Sie haben einen logbasierten Verteilungsmesswert erstellt, um die Anzahl der verarbeiteten Datenpunkte aus einer Reihe von langen Einträgen einschließlich Strings wie den folgenden zu extrahieren:

... entry ID 1 ... Processed data points 1000 ...
... entry ID 2 ... Processed data points 1500 ...
... entry ID 3 ... Processed data points 1000 ...
... entry ID 4 ... Processed data points 500 ...

Verwenden Sie eine MQL wie die folgende, um eine Zeitachse zu erstellen, die die Anzahl aller verarbeiteten Datenpunkte anzeigt:

fetch global
| metric 'logging.googleapis.com/user/METRIC_NAME'
| group_by [], sum(sum_from(value))

Informationen zum Erstellen eines logbasierten Verteilungsmesswerts finden Sie unter Verteilungsmesswerte konfigurieren.

Spalten aus einer Gruppe ausschließen

Sie können den drop-Modifikator in einer Zuordnung verwenden, um Spalten aus einer Gruppe auszuschließen. Der Kubernetes-Messwert core_usage_time hat beispielsweise sechs Spalten:

fetch k8s_container :: kubernetes.io/container/cpu/core_usage_time
| group_by [project_id, location, cluster_name, namespace_name, container_name]

Wenn Sie pod_name nicht gruppieren müssen, können Sie es mit drop ausschließen:

fetch k8s_container :: kubernetes.io/container/cpu/core_usage_time
| group_by drop [pod_name]

Zeitreihe auswählen

Die Beispiele in diesem Abschnitt zeigen, wie Sie bestimmte Zeitachsen aus einer Eingabetabelle auswählen.

Obere oder unterste Zeitreihe auswählen

Geben Sie die folgende Abfrage ein, um die Zeitachsendaten für die drei Compute Engine-Instanzen mit der höchsten CPU-Auslastung in Ihrem Projekt anzuzeigen:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3

Der folgende Screenshot zeigt das Ergebnis eines Projekts:

Sie können die Zeitachse mit der niedrigsten CPU-Auslastung abrufen. Ersetzen Sie dazu top durch bottom.

Der top -Vorgang gibt eine Tabelle mit einer angegebenen Anzahl von Zeitachsen aus der Eingabetabelle aus. Die in der Ausgabe enthaltene Zeitachse hat für einen Teil der Zeitreihe den größten Wert.

Da diese Abfrage keine Möglichkeit zum Sortieren der Zeitachsen angibt, gibt sie diese Zeitachsen mit dem größten Wert für den neuesten Punkt zurück. Wenn Sie angeben möchten, welche Zeitachsen den größten Wert haben, können Sie ein Argument für den top-Vorgang angeben. Die vorherige Abfrage entspricht beispielsweise der folgenden Abfrage:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3, val()

Der Ausdruck val() wählt den Wert des neuesten Punkts in jeder Zeitachse aus, auf die er angewendet wird. Daher gibt die Abfrage die Zeitachsen mit dem größten Wert für den aktuellsten Punkt zurück.

Sie können einen Ausdruck angeben, der eine Aggregation über einige oder alle Punkte in einer Zeitreihe durchführt, um den Sortierwert zu erhalten. Im Folgenden wird der Mittelwert aller Punkte der letzten 10 Minuten verwendet:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3, mean(val()).within(10m)

Wenn die Funktion within nicht verwendet wird, wird die Funktion mean auf die Werte aller angezeigten Punkte in der Zeitachse angewendet.

Der Vorgang bottom funktioniert ähnlich. Die folgende Abfrage ermittelt den Wert des größten Punkts in jeder Zeitachse mit max(val()) und wählt dann die drei Zeitachsen aus, für die dieser Wert der kleinste ist:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| bottom 3, max(val())

Der folgende Screenshot zeigt ein Diagramm mit den Streams mit den geringsten Spitzen:

Die oberen oder unteren n Ergebnisse in der Zeitreihe ausschließen

Nehmen wir ein Szenario mit vielen Compute Engine-VM-Instanzen. Einige dieser Instanzen verbrauchen viel mehr Arbeitsspeicher als die meisten Instanzen, und diese Ausreißer erschweren es, die Nutzungsmuster in der größeren Gruppe zu erkennen. Ihre CPU-Auslastungsdiagramme sehen so aus:

Sie möchten die drei Ausreißer aus dem Diagramm ausschließen, damit Sie die Muster in der größeren Gruppe besser sehen können.

Wenn Sie die drei wichtigsten Zeitachsen in einer Abfrage ausschließen möchten, die die Zeitachsen für die Compute Engine-CPU-Auslastung abruft, verwenden Sie den Tabellenvorgang top, um die Zeitreihe zu identifizieren, und den Tabellenvorgang outer_join, um die identifizierten Zeitachsen aus den Ergebnissen auszuschließen. Sie können dazu die folgende Abfrage verwenden:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| {
    top 3 | value [is_default_value: false()]
  ;
    ident
  }
| outer_join true(), _
| filter is_default_value
| value drop [is_default_value]

Der Vorgang fetch gibt eine Tabelle mit Zeitachsen für die CPU-Auslastung von allen Instanzen zurück. Diese Tabelle wird dann in zwei resultierende Tabellen verarbeitet:

• Der Tabellenvorgang top n gibt eine Tabelle aus, die die Zeitachse n mit den höchsten Werten enthält. In diesem Fall ist n = 3. Die resultierende Tabelle enthält die auszuschließenden dreimaligen Reihen.

  Die Tabelle mit den drei häufigsten Zeitachsen wird dann an einen value-Tabellenvorgang übergeben. Durch diesen Vorgang wird jeder Zeitreihe in den drei obersten Tabellen eine weitere Spalte hinzugefügt. Die Spalte is_default_value erhält den booleschen Wert false für alle Zeitachsen in den ersten drei Tabellen.

• Der Vorgang ident gibt die Tabelle zurück, an die eine Pipeline übergeben wurde: die ursprüngliche Tabelle der Zeitreihen der CPU-Auslastung. Keine der Zeitachsen in dieser Tabelle hat die Spalte is_default_value.

Die Top-3-Tabelle und die ursprüngliche Tabelle werden dann per Pipe an den Tabellenvorgang outer_join übergeben. Die Tabelle oben drei ist die linke Tabelle im Join, die abgerufene Tabelle die rechte Tabelle im Join. Der Outer Join ist so eingerichtet, dass für jedes Feld, das in einer zu verbindenden Zeile nicht vorhanden ist, der Wert true angegeben wird. Das Ergebnis des Outer Join ist eine zusammengeführte Tabelle, wobei die Zeilen aus den ersten drei Tabellen die Spalte is_default_value mit dem Wert false beibehalten und alle Zeilen aus der ursprünglichen Tabelle, die nicht auch in den ersten drei Tabelle enthalten waren, die Spalte is_default_value mit dem Wert true erhalten.

Die aus dem Join resultierende Tabelle wird an den Tabellenvorgang filter übergeben, mit dem die Zeilen herausgefiltert werden, die in der Spalte is_default_value den Wert false haben. Die resultierende Tabelle enthält die Zeilen aus der ursprünglich abgerufenen Tabelle ohne die Zeilen aus der ersten drei Tabelle. Diese Tabelle enthält den gewünschten Satz von Zeitachsen mit dem hinzugefügten is_default_column.

Im letzten Schritt löschen Sie die Spalte is_default_column, die durch den Join hinzugefügt wurde, damit die Ausgabetabelle dieselben Spalten wie die ursprünglich abgerufene Tabelle hat.

Der folgende Screenshot zeigt das Diagramm für die vorherige Abfrage:

Sie können eine Abfrage erstellen, um die Zeitachse mit der niedrigsten CPU-Auslastung auszuschließen. Ersetzen Sie dazu top n durch bottom n.

Die Möglichkeit, Ausreißer auszuschließen, kann nützlich sein, wenn Sie eine Benachrichtigung einrichten möchten, aber nicht möchten, dass die Ausreißer ständig die Benachrichtigung auslösen. Die folgende Benachrichtigungsabfrage verwendet dieselbe Ausschlusslogik wie die vorherige Abfrage, um die Auslastung des CPU-Limits durch eine Reihe von Kubernetes-Pods zu überwachen, nachdem die beiden obersten Pods ausgeschlossen wurden:

fetch k8s_container
| metric 'kubernetes.io/container/cpu/limit_utilization'
| filter (resource.cluster_name == 'CLUSTER_NAME' &&
          resource.namespace_name == 'NAMESPACE_NAME' &&
          resource.pod_name =~ 'POD_NAME')
| group_by 1m, [value_limit_utilization_max: max(value.limit_utilization)]
| {
    top 2 | value [is_default_value: false()]
  ;
    ident
  }
| outer_join true(), _
| filter is_default_value
| value drop [is_default_value]
| every 1m
| condition val(0) > 0.73 '1'

Oben oder unten aus Gruppen auswählen

Die Tabellenvorgänge top und bottom wählen Zeitachsen aus der gesamten Eingabetabelle aus. Die Vorgänge top_by und bottom_by gruppieren die Zeitachsen in einer Tabelle und wählen dann eine bestimmte Anzahl von Zeitachsen aus jeder Gruppe aus.

Die folgende Abfrage wählt die Zeitreihe in jeder Zone mit dem größten Spitzenwert aus:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top_by [zone], 1, max(val())

Der Ausdruck [zone] gibt an, dass eine Gruppe aus allen Zeitachsen mit demselben Wert in der Spalte zone besteht. Die 1 in der top_by gibt an, wie viele Zeitachsen aus den Gruppen der einzelnen Zonen ausgewählt werden sollen. Der Ausdruck max(val()) sucht in jeder Zeitreihe nach dem größten Wert im Zeitraum des Diagramms.

Anstelle von max können Sie eine beliebige Aggregationsfunktion verwenden. Im folgenden Beispiel wird der Aggregator mean und mit within der Sortierbereich von 20 Minuten angegeben. Es werden die zwei wichtigsten Zeitachsen in jeder Zone ausgewählt:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top_by [zone], 2, mean(val()).within(20m)

Im vorherigen Beispiel gibt es nur eine Instanz in der Zone us-central-c. Es wird also nur eine Zeitachse zurückgegeben. Es gibt keine „Top 2“ in der Gruppe.

Auswahl mit union kombinieren

Sie können Auswahlvorgänge wie top und bottom kombinieren, um Diagramme zu erstellen, die beide enthalten. Die folgende Abfrage gibt beispielsweise die einzelne Zeitachse mit dem Höchstwert und die einzelne Zeitachse mit dem Mindestwert zurück:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| {
    top 1, max(val())
  ;
    bottom 1, min(val())
  }
| union

Hinweis: Die Einrückung und Ausrichtung der Abfragekomponenten dient nur der Lesbarkeit. MQL ist keine speicherabhängige Sprache.

Das resultierende Diagramm enthält zwei Linien, eine mit dem höchsten Wert und eine mit dem niedrigsten:

Sie können geschweifte Klammern ({ }) verwenden, um Abfolgen von Vorgängen anzugeben, die jeweils eine Tabelle mit Zeitachsen als Ausgabe liefern. Die einzelnen Vorgänge werden durch einen Strichpunkt (;) getrennt.

In diesem Beispiel gibt der fetch - Vorgang eine einzelne Tabelle zurück, die an jeden der beiden Vorgänge in der Sequenz, einen top - und einen bottom - Vorgang, weitergeleitet wird. Jeder dieser Vorgänge führt zu einer Ausgabetabelle, die auf derselben Eingabetabelle basiert. Der Vorgang union kombiniert dann die beiden Tabellen zu einer, die im Diagramm angezeigt wird.

Weitere Informationen zu Sequenzierungsvorgängen mithilfe von { } finden Sie im Referenzthema Abfragestruktur.

Zeitreihen mit unterschiedlichen Werten für ein Label kombinieren

Angenommen, Sie haben mehrere Zeitachsen für denselben Messwerttyp und möchten einige davon kombinieren. Wenn Sie sie anhand der Werte eines einzelnen Labels auswählen möchten, können Sie die Abfrage nicht über die Benutzeroberfläche des Query Builders im Metrics Explorer erstellen. Sie müssen nach zwei oder mehr verschiedenen Werten desselben Labels filtern. In der Benutzeroberfläche des Query Builders muss jedoch eine Zeitachse mit allen ausgewählten Filtern übereinstimmen: Der Labelabgleich ist ein AND-Test. Keine Zeitachse darf zwei verschiedene Werte für dasselbe Label haben. Sie können jedoch im Query Builder keinen OR-Test für Filter erstellen.

Die folgende Abfrage ruft die Zeitachse für den Compute Engine-Messwert instance/disk/max_read_ops_count für zwei bestimmte Compute Engine-Instanzen ab und richtet die Ausgabe über einminütige Intervalle aus:

fetch gce_instance
| metric 'compute.googleapis.com/instance/disk/max_read_ops_count'
| filter (resource.instance_id == '1854776029354445619' ||
          resource.instance_id == '3124475757702255230')
| every 1m

Das folgende Diagramm zeigt ein Ergebnis dieser Abfrage:

Wenn Sie die Summe der maximalen max_read_ops_count-Werte für diese beiden VMs ermitteln und addieren möchten, können Sie Folgendes tun:

• Ermitteln Sie den Maximalwert für jede Zeitachse, indem Sie den Tabellenoperator group_by verwenden, denselben 1-minütigen Ausrichtungszeitraum angeben und über den Zeitraum mit dem Aggregator max aggregieren, um eine Spalte mit dem Namen max_val_of_read_ops_count_max in der Ausgabetabelle zu erstellen.
• Ermitteln Sie die Summe der Zeitachse mithilfe des Tabellenoperators group_by und des Aggregators sum in der Spalte max_val_of_read_ops_count_max.

Die Abfrage sieht so aus:

fetch gce_instance
| metric 'compute.googleapis.com/instance/disk/max_read_ops_count'
| filter (resource.instance_id == '1854776029354445619' ||
          resource.instance_id == '3124475757702255230')
| group_by 1m, [max_val_of_read_ops_count_max: max(value.max_read_ops_count)]
| every 1m
| group_by [], [summed_value: sum(max_val_of_read_ops_count_max)]

Das folgende Diagramm zeigt ein Ergebnis dieser Abfrage:

Perzentilstatistiken zeit- und streamübergreifend berechnen

Wenn Sie für jeden Stream einen Perzentil-Stream-Wert über ein gleitendes Fenster separat berechnen möchten, verwenden Sie einen zeitlichen group_by-Vorgang. Die folgende Abfrage berechnet beispielsweise den 99. Perzentilwert eines Streams über ein gleitendes Fenster von 1 Stunde:

fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization
| group_by 1h, percentile(val(), 99)
| every 1m

Verwenden Sie einen räumlichen group_by-Vorgang, um dieselbe Perzentilstatistik zu einem bestimmten Zeitpunkt über mehrere Streams hinweg und nicht für einen bestimmten Zeitraum innerhalb eines Streams zu berechnen:

fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization
| group_by [], percentile(val(), 99)

Verhältnisse berechnen

Angenommen, Sie haben einen verteilten Webdienst erstellt, der auf Compute Engine-VM-Instanzen ausgeführt wird und Cloud Load Balancing verwendet.

Sie möchten ein Diagramm sehen, in dem das Verhältnis der Anfragen, die HTTP 500 - Antworten (interne Fehler) zurückgeben, zur Gesamtzahl der Anfragen angezeigt wird. also das Anfrage-Fehler-Verhältnis. In diesem Abschnitt werden mehrere Möglichkeiten zum Berechnen des Verhältnisses zwischen Anfrage und Fehler erläutert.

Cloud Load Balancing verwendet den Typ http_lb_rule der überwachten Ressource. Der Typ der überwachten Ressource http_lb_rule hat das Label matched_url_path_rule, dass das Präfix der für die Regel definierten URLs aufzeichnet. der Standardwert ist UNMATCHED.

Der Messwerttyp loadbalancing.googleapis.com/https/request_count hat das Label response_code_class. Mit diesem Label wird die Klasse der Antwortcodes erfasst.

outer_join und div verwenden

Die folgende Abfrage ermittelt die 500 - Antworten für jeden Wert des Labels matched_url_path_rule in jeder überwachten http_lb_rule - Ressource in Ihrem Projekt. Anschließend wird die Fehlerzählungstabelle mit der Originaltabelle verknüpft, die alle Antwortzählungen enthält und die Werte unterteilt, um das Verhältnis der Fehlerantworten zu den Gesamtantworten anzuzeigen:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| {
    filter response_code_class = 500
  ;
    ident
  }
| group_by [matched_url_path_rule]
| outer_join 0
| div

Das folgende Diagramm zeigt das Ergebnis eines Projekts:

Die schattierten Bereiche um die Linien auf dem Diagramm Min./Max.-Bänder. Weitere Informationen finden Sie unter Min./Max.-Bänder.

Der Vorgang fetch gibt eine Tabelle mit Zeitachsen aus, die die Anzahl der Anfragen für alle Abfragen mit Load-Balancing enthält. Diese Tabelle wird auf zwei Arten von den beiden Vorgangssequenzen in den geschweiften Klammern verarbeitet.

• filter response_code_class = 500 gibt nur die Zeitachsen aus, die das Label response_code_class mit dem Wert 500 haben. In der resultierenden Zeitachse werden die Anfragen mit HTTP 5xx-Antwortcodes (Fehler) gezählt.

  Diese Tabelle ist der Zähler des Verhältnisses.

• Der Vorgang ident oder identity (Identität) gibt seine Eingabe aus, sodass dieser Vorgang die ursprünglich abgerufene Tabelle zurückgibt. Dies ist die Tabelle, die Zeitachsen mit Anzahlen für jeden Antwortcode enthält.

  Diese Tabelle ist der Nenner des Verhältnisses.

Die von den Vorgängen filter und ident erstellten Zähler- und Nennertabellen werden vom Vorgang group_by separat verarbeitet. Der group_by - Vorgang gruppiert die Zeitachsen in jeder Tabelle nach dem Wert des Labels matched_url_path_rule und addiert die Anzahl für jeden Wert des Labels. Dieser group_by - Vorgang gibt die Aggregatorfunktion nicht explizit an, daher wird der Standardwert sum verwendet.

• Für die gefilterte Tabelle ist das Ergebnis group_by die Anzahl der Anfragen, die für jeden matched_url_path_rule - Wert eine 500 - Antwort zurückgeben.

• Für die Identitätstabelle ist das group_by-Ergebnis die Gesamtzahl der Anfragen für jeden matched_url_path_rule-Wert.

Diese Tabellen werden an den Vorgang outer_join weitergeleitet, der Zeitachsen mit übereinstimmenden Labelwerten koppelt, eine aus jeder der beiden Eingabetabellen. Die gekoppelten Zeitachsen werden zusammengeführt, indem der Zeitstempel jedes Punkts in einer Zeitachse mit dem Zeitstempel eines Punkts in der anderen Zeitachse abgeglichen wird. Für jedes übereinstimmende Punktepaar erzeugt outer_join einen einzelnen Ausgabepunkt mit zwei Werten, einen aus jeder der Eingabetabellen. Die komprimierte Zeitachse wird vom Join mit denselben Labels wie die zwei Eingabezeitachsen ausgegeben.

Bei einem Outer Join muss ein Ersatzwert angegeben werden, wenn ein Punkt aus der zweiten Tabelle keinen übereinstimmenden Punkt in der ersten Tabelle hat. In diesem Beispiel wird ein Punkt mit dem Wert 0 - dem Argument für den outer_join - Vorgang verwendet.

Hinweis: Warum wird 0 als Wert verwendet? Wenn eine überwachte Ressource noch nie mit einer 500 - Antwort geantwortet hat, gibt es für 500 - Antworten keinen Zählwert. Der Ersatzwert liefert den Wert 0 für die Anzahl.

Schließlich nimmt der div-Vorgang jeden Punkt mit zwei Werten auf und teilt die Werte, um einen einzelnen Ausgabepunkt zu erzeugen: das Verhältnis von 500 Antworten zu allen Antworten für jede URL-Zuordnung.

Der String div ist hier der Name der Funktion div, die zwei numerische Werte teilt. Aber es wird hier als Vorgang verwendet. Wenn sie als Vorgänge verwendet werden, erwarten Funktionen wie div an jedem Eingabepunkt zwei Werte (was durch join sichergestellt wird) und erzeugen einen einzelnen Wert für den entsprechenden Ausgabepunkt.

Der Teil | div der Abfrage ist eine Verknüpfung für | value val(0) / val(1). Der value - Vorgang ermöglicht beliebige Ausdrücke in den Wertspalten einer Eingabetabelle, um die Wertspalten der Ausgabetabelle zu erzeugen. Weitere Informationen finden Sie auf den Referenzseiten zum Vorgang value und zu Ausdrücken.

ratio verwenden

Die div - Funktion könnte durch eine beliebige Funktion für zwei Werte ersetzt werden, aber da Verhältnisse so häufig verwendet werden, bietet MQL einen ratio -Tabellenvorgang, der Verhältnisse direkt berechnet.

Die folgende Abfrage entspricht der vorherigen Version mit outer_join und div:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| {
    filter response_code_class = 500
  ;
    ident
  }
| group_by [matched_url_path_rule]
| ratio

In dieser Version ersetzt der ratio - Vorgang die outer_join 0 | div - Vorgänge in der früheren Version und führt zum selben Ergebnis.

Beachten Sie, dass ratio nur dann outer_join verwendet, um 0 für den Zähler anzugeben, wenn sowohl die Zähler- als auch die Nennereingabe die gleichen Labels haben, die die einzelnen Zeitachsen identifizieren, die MQL-outer_join erfordert. Wenn die Zählereingabe zusätzliche Labels hat, gibt es keine Ausgabe für jeden Punkt, der im Nenner fehlt.

group_by und / verwenden

Es gibt noch eine weitere Möglichkeit, das Verhältnis von Fehlerantworten zu allen Antworten zu berechnen. Da der Zähler und Nenner für das Verhältnis aus derselben Zeitachse abgeleitet werden, können Sie das Verhältnis auch allein durch Gruppieren berechnen. Die folgende Abfrage zeigt diesen Ansatz:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| group_by [matched_url_path_rule],
    sum(if(response_code_class = 500, val(), 0)) / sum(val())

Diese Abfrage verwendet einen Aggregationsausdruck, der auf dem Verhältnis von zwei Summen basiert:

• Im ersten sum wird die Funktion if verwendet, um Labels mit 500 Werten und 0 für andere zu zählen. Die Funktion sum berechnet die Anzahl der Anfragen, die 500 zurückgegeben haben.

• Die zweite sum addiert die Anzahl für alle Anfragen, val().

Die beiden Summen werden dann aufgeteilt, sodass sich das Verhältnis von 500 Antworten zu allen Antworten ergibt. Diese Abfrage führt zu demselben Ergebnis wie die Abfragen in outer_join und div und ratio verwenden.

filter_ratio_by verwenden

Da Verhältnisse häufig durch Teilen von zwei aus derselben Tabelle abgeleiteten Summen berechnet werden, stellt MQL zu diesem Zweck den filter_ratio_by -Vorgang bereit. Die folgende Abfrage führt das Gleiche wie die vorherige Version aus, bei der die Summen explizit geteilt werden:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| filter_ratio_by [matched_url_path_rule], response_code_class = 500

Der erste Operand des filter_ratio_by-Vorgangs, hier [matched_url_path_rule], gibt an, wie die Antworten gruppiert werden. Der zweite Vorgang, hier response_code_class = 500, fungiert als Filterausdruck für den Zähler.

• Die Tabelle "Denominator" ist das Ergebnis der Gruppierung der abgerufenen Tabelle nach matched_url_path_rule und die Zusammenfassung mithilfe von sum.
• Die Zähler-Tabelle ist die abgerufene Tabelle, die nach Zeitachsen mit dem HTTP-Antwortcode 5xx gefiltert, dann nach matched_url_path_rule gruppiert und mit sum zusammengefasst wird.

Verhältnisangaben und Kontingentmesswerte

Zum Einrichten von Abfragen und Benachrichtigungen zu serviceruntime-Kontingentmesswerten und ressourcenspezifischen Kontingentmesswerten zum Überwachen Ihres Kontingentverbrauchs können Sie MQL verwenden. Weitere Informationen und Beispiele finden Sie unter Kontingentmesswerte verwenden.

Arithmetische Berechnung

Manchmal möchten Sie vielleicht eine arithmetische Operation mit Daten durchführen, bevor Sie sie grafisch darstellen. Sie können beispielsweise Zeitachsen skalieren, Daten logarithmisch skalieren oder die Summe zweier Zeitachsen grafisch darstellen. Eine Liste der in MQL verfügbaren arithmetischen Funktionen finden Sie unter Arithmetik.

Verwenden Sie zum Skalieren einer Zeitachse die Funktion mul. Die folgende Abfrage ruft beispielsweise die Zeitachse ab und multipliziert jeden Wert mit 10:

  fetch gce_instance
  | metric 'compute.googleapis.com/instance/disk/read_bytes_count'
  | mul(10)

Wenn Sie zwei Zeitachsen summieren möchten, konfigurieren Sie die Abfrage so, dass zwei Tabellen von Zeitachsen abgerufen werden, führen Sie diese Ergebnisse zusammen und rufen Sie dann die Funktion add auf. Das folgende Beispiel veranschaulicht eine Abfrage, die die Summe der Anzahl der Byte berechnet, die aus Compute Engine-Instanzen gelesen und in diese geschrieben wurden:

  fetch gce_instance
  | { metric 'compute.googleapis.com/instance/disk/read_bytes_count'
    ; metric 'compute.googleapis.com/instance/disk/write_bytes_count' }
  | outer_join 0
  | add

Wenn Sie die Anzahl der geschriebenen Byte von der Anzahl der gelesenen Byte abziehen möchten, ersetzen Sie im vorherigen Ausdruck add durch sub.

MQL verwendet die Labels in den Tabellensätzen, die vom ersten und zweiten Abruf zurückgegeben werden, um zu bestimmen, wie die Tabellen verknüpft werden:

• Wenn die erste Tabelle ein Label enthält, das in der zweiten Tabelle nicht gefunden wurde, kann MQL für die Tabellen keinen outer_join-Vorgang ausführen und meldet daher einen Fehler. Die folgende Abfrage führt beispielsweise zu einem Fehler, da das Label metric.throttle_reason in der ersten Tabelle, aber nicht in der zweiten Tabelle vorhanden ist:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/throttled_read_bytes_count'
      ; metric 'compute.googleapis.com/instance/disk/write_bytes_count' }
    | outer_join 0
    | add
  

  Eine Möglichkeit zur Behebung dieses Fehlers besteht darin, Gruppierungsklauseln anzuwenden, damit die beiden Tabellen dieselben Labels haben. So können Sie beispielsweise alle Zeitachsenlabels durch Gruppieren entfernen:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/throttled_read_bytes_count'
        | group_by []
      ; metric 'compute.googleapis.com/instance/disk/write_bytes_count'
        | group_by [] }
    | outer_join 0
    | add
  

• Wenn die Labels der beiden Tabellen übereinstimmen oder die zweite Tabelle ein Label enthält, das in der ersten Tabelle nicht gefunden wurde, ist der Outer Join zulässig. Die folgende Abfrage verursacht beispielsweise keinen Fehler, obwohl das Label metric.throttle_reason in der zweiten Tabelle vorhanden ist, jedoch nicht in der ersten:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/write_bytes_count'
      ; metric 'compute.googleapis.com/instance/disk/throttled_read_bytes_count' }
    | outer_join 0
    | sub
  

  Eine in der ersten Tabelle gefundene Zeitachse kann Labelwerte haben, die mit mehreren Zeitachsen in der zweiten Tabelle übereinstimmen. Daher führt MQL die Subtraktion für jedes Paar aus.

Zeitverschiebung

Manchmal möchten Sie das, was jetzt passiert, mit dem, was in der Vergangenheit passiert ist, vergleichen. Damit Sie frühere Daten mit aktuellen Daten vergleichen können, bietet MQL den Tabellenvorgang time_shift, mit dem frühere Daten in den aktuellen Zeitraum verschoben werden.

Im Laufe der Zeit

Die folgende Abfrage verwendet time_shift, join und div, um das Verhältnis der mittleren Auslastung in beiden zu berechnen Zone zwischen heute und vor einer Woche.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| group_by [zone], mean(val())
| {
    ident
  ;
    time_shift 1w
  }
| join | div

Das folgende Diagramm zeigt ein mögliches Ergebnis dieser Abfrage:

Die ersten beiden Vorgänge rufen die Zeitreihe ab und gruppieren sie dann nach Zone, wobei die Mittelwerte jedes einzelnen berechnet werden. Die resultierende Tabelle wird dann an zwei Vorgänge übergeben. Der erste Vorgang, ident, übergibt die Tabelle unverändert.

Der zweite Vorgang, time_shift, fügt den Zeitraum (1 Woche) den Zeitstempeln für Werte in der Tabelle hinzu, wodurch Daten von einer Woche vorwärts verschoben werden. Durch diese Änderung werden die Zeitstempel für ältere Daten in der zweiten Tabelle mit den Zeitstempeln für die aktuellen Daten in der ersten Tabelle abgeglichen.

Die unveränderte Tabelle und die zeitversetzte Tabelle werden dann mit einem internen join kombiniert. join erzeugt eine Tabelle mit Zeitachsen, in denen jeder Punkt zwei Werte hat: die aktuelle Auslastung und die Auslastung vor einer Woche. Die Abfrage verwendet dann den div - Vorgang, um das Verhältnis des aktuellen Werts zum ein Wochen alten Wert zu berechnen.

Bisherige und aktuelle Daten

Durch die Kombination von time_shift mit union können Sie ein Diagramm erstellen, in dem vergangene und aktuelle Daten gleichzeitig angezeigt werden. Die folgende Abfrage gibt beispielsweise die durchschnittliche Gesamtauslastung jetzt und vor einer Woche zurück. Mit union können Sie diese beiden Ergebnisse im selben Diagramm anzeigen.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| group_by []
| {
     add [when: "now"]
  ;
     add [when: "then"] | time_shift 1w
  }
| union

Das folgende Diagramm zeigt ein mögliches Ergebnis dieser Abfrage:

Diese Abfrage ruft die Zeitachse ab und kombiniert sie dann mit group_by [] in einer einzelnen Zeitachse ohne Labels, sodass die Datenpunkte zur CPU-Auslastung übrig bleiben. Dieses Ergebnis wird an zwei Vorgänge übergeben. Die erste fügt eine Spalte für ein neues Label namens when mit dem Wert now hinzu. Der zweite fügt ein Label namens when mit dem Wert then hinzu und übergibt das Ergebnis an den Vorgang time_shift, um die Werte um eine Woche zu verschieben. Diese Abfrage verwendet den Kartenmodifikator add. Weitere Informationen finden Sie unter Maps.

Die beiden Tabellen, die jeweils Daten für eine einzelne Zeitachse enthalten, werden an union übergeben, wodurch eine Tabelle erstellt wird, die die Zeitachsen aus beiden Eingabetabellen enthält.

Nächste Schritte

Eine Übersicht über die MQL-Sprachstrukturen finden Sie unter Über die MQL-Sprache.

Eine vollständige Beschreibung von MQL finden Sie in der Referenz zur Monitoring-Abfragesprache.

Informationen zur Interaktion mit Diagrammen finden Sie unter Mit Diagrammen arbeiten.