Beispiele für MQL-Abfragen

In diesem Dokument wird die Monitoring Query Language (MQL) anhand von Beispielen vorgestellt. Allerdings nicht versuchen, alle Aspekte der Sprache abzudecken. MQL ist in der Referenz zu Monitoring Query Language ausführlich dokumentiert ist.

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

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

Hinweise

Um auf den Code-Editor zuzugreifen, wenn Sie den Metrics Explorer verwenden, führen Sie die Folgendes:

1. Rufen Sie in der Google Cloud Console die Seite  Metrics Explorer auf:

   Zum Metrics Explorer

   Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

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.

Fügen Sie die Abfrage in den Editor ein und klicken Sie auf Abfrage ausführen, um eine Abfrage auszufü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 Zeitreihe stammt von einem einzelnen Typ von überwachter Ressource. jede Zeitreihe Daten eines Messwerttyps erfasst. 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 Wertekombination wird eine Zeitreihe erstellt für die Labels aus dem Paar aus einem Messwertdeskriptor und einem Deskriptor der überwachten Ressource.

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 für jede eindeutige Kombination von Messwerten eine Zeitreihe. und Ressourcenlabelwerte.

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 Zeitreihe ausführen, von einem Vorgang an einen anderen übergeben wird.

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 Vorgängen. 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.
• Mit filter-Vorgängen eine Teilmenge von Informationen auswählen.
• 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, definieren die Diagrammeinstellungen die Zeitraum für Abfragen. Standardmäßig ist der Zeitraum des Diagramms auf eine Stunde festgelegt.

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

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

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 Ausrichtung 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 Abfrage- und mit MQL filtern.

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 identifiziert die abzurufende Zeitreihe, z. B.:

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 im Code-Editor in Metrics Explorer ausführen, erhalten Sie ein Diagramm mit jeder der angeforderten Zeitreihen:

Jede der angeforderten Zeitreihen wird im Diagramm als Linie angezeigt. Jedes Zeitreihe enthält eine Liste von Werten aus der CPU-Auslastung mit Zeitstempeln Messwert 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 filter-Vorgang entfernt die Zeitachse für der Filter auf "false" gesetzt 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, ist diese Zeitachse im . In diesem Beispiel führt der Filterausdruck einen regulären Ausdruck aus. =~, für das Label instance_name jeder Zeitachse. Wenn der Wert des Labels mit dem regulären Ausdruck 'gke.*' übereinstimmt, dann entspricht die Zeitachse in der Ausgabe enthalten ist. 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 Aggregate

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 aus dem group_by-Vorgang resultierende Tabelle hat 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 für die Eingabezeitachse 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. aggregiert (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 zu extrahieren. Datenpunkte, die aus einer Reihe langer Einträge verarbeitet wurden, einschließlich Zeichenfolgen wie Folgendes:

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

Um eine Zeitreihe zu erstellen, die die Anzahl aller verarbeiteten Datenpunkte anzeigt, Verwenden Sie einen MQL wie den folgenden:

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 Modifikator drop in einer Zuordnung verwenden, um Spalten aus einer Gruppe. 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 sie 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.

Zeitreihe oben oder unten 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 folgendermaßen abrufen: top wird durch bottom ersetzt.

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

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()

Mit dem Ausdruck val() wird der Wert des jeweils neuesten Punkts ausgewählt. auf die es angewendet wird. Daher gibt die Abfrage diese Zeitachsen zurück, mit dem höchsten Wert für den letzten Punkt.

Sie können einen Ausdruck angeben, der eine Aggregation für einige oder alle Punkte durchführt in einer Zeitreihe, 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 within-Funktion nicht verwendet wird, gibt die mean-Funktion wird auf die Werte aller angezeigten Punkte in der Zeitreihe angewendet.

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

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

Stellen Sie sich ein Szenario vor, in dem Sie viele Compute Engine-VM-Instanzen haben. Einige dieser Instanzen verbrauchen viel mehr Speicher als die meisten, Diese Ausreißer machen es schwieriger, größere Gruppe. Ihre CPU-Auslastungsdiagramme sehen so aus:

Sie möchten die drei Ausreißer aus dem Diagramm ausschließen, damit die Muster in der größeren Gruppe deutlicher darzustellen.

Um die drei wichtigsten Zeitreihen aus einer Abfrage auszuschließen, die die Zeitreihe abruft Verwenden Sie für die Compute Engine-CPU-Auslastung den Tabellenvorgang top. zur Identifizierung der Zeitreihe und des Tabellenvorgangs outer_join um die identifizierte Zeitreihe aus den Ergebnissen auszuschließen. Sie können die folgende Abfrage:

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 an allen Instanzen. Diese Tabelle wird dann in zwei Ergebnistabellen verarbeitet:

• Der Tabellenvorgang top n gibt eine Tabelle aus, die enthält die n-Zeit Reihe mit den höchsten Werten. In diesem Fall ist n = 3. Das Ergebnis enthält die drei auszuschließenden Zeitreihen.

  Die Tabelle mit den drei Top-Zeitreihen wird dann value-Tabellenvorgang. Durch diesen Vorgang wird eine weitere Spalte hinzugefügt. mit jeder Zeitreihe in der Tabelle „Top-3“. Diese Spalte is_default_value erhält den booleschen Wert false für alle in der Tabelle mit den Top-3-Punkten.

• Der ident-Vorgang gibt die gleiche Tabelle zurück, die in die Pipe eingefügt wurde: Originaltabelle der CPU-Auslastungszeitreihen. In keinem der Fälle Reihen in dieser Tabelle haben die Spalte is_default_value.

Die Tabelle mit den drei oben genannten Tabellen und die ursprüngliche Tabelle werden outer_join-Tabellenvorgang. Die Tabelle mit den drei obersten ist die linke Tabelle. im JOIN ist die abgerufene Tabelle die rechte Tabelle im JOIN. Der Outer Join ist so eingerichtet, dass er den Wert true als Wert für ein beliebiges Feld, das in einer Zeile, die verbunden werden soll, nicht vorhanden ist. Das Ergebnis der Outer Join ist eine zusammengeführte Tabelle, bei der die Zeilen aus den drei Tabellen die Spalte is_default_value mit dem Wert false und alle Zeilen aus die nicht in den ersten drei Tabellen enthalten waren, Spalte is_default_value mit dem Wert true.

Die aus dem Join resultierende Tabelle wird dann an den filter übergeben. Tabellenvorgang, der die Zeilen herausfiltert, die Wert von false in der Spalte is_default_value. Die resultierende Tabelle enthält die Zeilen aus der ursprünglich abgerufenen Tabelle ohne die Zeilen aus der Tabelle mit den drei wichtigsten Punkten. Diese Tabelle enthält den vorgesehenen Satz von Zeitreihen, durch den hinzugefügten is_default_column.

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

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

Sie können eine Abfrage erstellen, um die Zeitreihe mit der niedrigsten Priorität auszuschließen CPU-Auslastung durch Ersetzen von top n durch bottom n.

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

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 der größten Spitzenwert:

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 nach dem größten Wert in des Diagramms für jede Zeitreihe.

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 keine „Top 2“ gibt, 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 Zeitreihe mit dem Maximalwert und die einzelne Zeitreihe mit dem Minimum Wert:

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 Lesbarkeit. MQL ist keine raumabhä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 Zeitreihen für denselben Messwerttyp und sollten Sie einige davon kombinieren. Wenn Sie sie auswählen möchten basierend auf den Werten eines einzelnen Labels, können Sie die Abfrage über die Query Builder-Oberfläche im Metrics Explorer. Erforderliche Schritte Filterung nach zwei oder mehr verschiedenen Werten desselben Labels, aber der Query Builder erfordert, dass eine Zeitreihe mit allen ausgewählten Filtern übereinstimmt: ist der Labelabgleich ein AND-Test. Keine Zeitreihe darf zwei verschiedene Werte für dasselbe Label. Sie können jedoch keinen OR-Test für Filter erstellen. im Query Builder erstellen.

Die folgende Abfrage ruft die Zeitachse für die Compute Engine ab. Messwert instance/disk/max_read_ops_count für zwei bestimmte Compute Engine Instanzen erstellt und die Ausgabe über 1-minütige Intervalle ausgerichtet:

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 das Ergebnis dieser Abfrage:

Wenn Sie die Summe der maximalen max_read_ops_count-Werte für diese zwei VMs erstellen und summieren, können Sie so vorgehen:

• Den Maximalwert für jede Zeitreihe finden Sie mithilfe des Parameters Tabellenoperator group_by, der denselben 1-Minuten-Takt angibt Ausrichtungszeitraum und Aggregierung über den Zeitraum mit dem max-Aggregator um eine Spalte mit dem Namen max_val_of_read_ops_count_max in der Ausgabe zu erstellen .
• Die Summe der Zeitreihen ermitteln Sie mit dem Tabellenoperator group_by und den Aggregator sum in der Spalte max_val_of_read_ops_count_max.

Hier sehen Sie die Abfrage:

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 das Ergebnis dieser Abfrage:

Perzentilstatistiken für Zeit und Streams berechnen

Um einen Perzentil-Streamwert über ein gleitendes Fenster separat für jede Stream verwenden, verwenden Sie einen zeitlich begrenzten group_by-Vorgang. Beispiel: Die Abfrage berechnet den Wert für das 99. Perzentil eines Streams über einen gleitenden Übergang von einer Stunde Fenster:

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

Um die gleiche Perzentilstatistik zu einem bestimmten Zeitpunkt über alle Streams hinweg zu berechnen, und nicht für einen Zeitraum in einem Stream, sondern eine räumliche group_by-Operation:

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. Die resultierende Zeitreihe zählt die Anfragen mit der HTTP-Antwort „5xx“ (Fehler) Codes.

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

• Der Vorgang ident oder Identität gibt seine Eingabe aus, sodass Dieser Vorgang gibt die ursprünglich abgerufene Tabelle zurück. 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 Zeitreihen werden zusammengefasst, indem die Zeitstempel jedes Punkts in einer Zeitreihe zum Zeitstempel eines Punkts in der anderen Zeitreihe. Für jedes übereinstimmende Punktepaar erzeugt outer_join einen einzelnen Ausgabepunkt mit zwei Werten, einen aus jeder der Eingabetabellen. Die komprimierte Zeitreihe wird vom Join mit denselben Labels wie der zwei Eingabezeitachsen.

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 der Zähler zusätzliche Beschriftungen hat, wird für Punkte, die im Feld Nenner.

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 Zeitreihe abgeleitet werden, können Sie auch das Verhältnis nur durch Gruppierung. 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 ausfü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 Zeitreihe die Funktion mul. Beispiel: Der Parameter folgende Abfrage ruft die Zeitreihe ab und multipliziert dann jeden Wert bis 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.instance_name in der ersten Tabelle, aber nicht in der zweiten Tabelle vorhanden ist:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/write_bytes_count'
      ; metric 'compute.googleapis.com/instance/disk/max_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/write_bytes_count'
        | group_by []
      ; metric 'compute.googleapis.com/instance/disk/max_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.instance_name in der zweiten Tabelle vorhanden ist, jedoch nicht in der ersten:

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

  Eine in der ersten Tabelle gefundene Zeitreihe hat möglicherweise Labelwerte, die mit mehrere Zeitreihen in der zweiten Tabelle, sodass MQL die Subtraktion für jede Paarung durchführt.

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 Zeitachse ab und nach Zonen sortiert und jeweils die Mittelwerte berechnet. 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 Zeitreihe ab und verwendet dann group_by [] um sie zu einer einzigen Zeitreihe ohne Beschriftungen zu kombinieren. Datenpunkte zur CPU-Auslastung. 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 Zeitreihe enthalten, werden übergeben. in union, wodurch eine Tabelle erzeugt wird, die die Zeitreihen aus beiden Eingabetabellen.

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.