Monitoring-Filter

Mit Filtern in der Cloud Monitoring API können Sie bestimmte Zeitreihen, Messwerttypen, überwachte Ressourcen und Ressourcengruppen in API-Anfragen, Diagrammen und Benachrichtigungsrichtlinien auswählen. Wenn Sie Prozesse zählen möchten, die auf Ihren virtuellen Maschinen in einer Benachrichtigungsrichtlinie oder einem Diagramm ausgeführt werden, verwenden Sie stattdessen Prozessintegritätsfilter.

Hinweis

Wenn Sie mit Messwerten, Zeitreihen und überwachten Ressourcen nicht vertraut sind, lesen Sie den Hilfeartikel Messwerte, Zeitreihen und Ressourcen.

Wenn Sie mit Labels nicht vertraut sind, finden Sie eine Einführung unter Labels.

Filter verwenden

Sie können Filter in der Monitoring API für Folgendes verwenden:

  • Wählen Sie die spezifischen Zeitreihendaten aus, die von einer list-API-Anfrage zurückgegeben werden. Mit dem Filter können Zeitreihen basierend auf dem Projekt, der Gruppe, den überwachten Ressourcenattributen und den Messwertattributen der Daten ausgewählt werden. Weitere Informationen und Beispiele finden Sie unter Zeitreihendaten abrufen.

  • Weisen Sie Ressourcen basierend auf den Attributen der Ressourcen und dem Projekt, zu dem sie gehören, einer Group zu. Weitere Informationen und Beispiele finden Sie unter Gruppenmitgliedschaft definieren.

  • Wählen Sie Ressourcen innerhalb einer Gruppe anhand der Ressourcenattribute aus. Weitere Informationen und Beispiele finden Sie unter Gruppenmitglieder auflisten.

Die Auswahl filtern

Ein Filter besteht aus mindestens einem Selektor, d. h. einem Filter-Keyword. Die folgenden Beispiele veranschaulichen die verschiedenen Selektoren:

  • project: Stimmt überein, wenn die Messwerte der angegebenen Projekte für das den Umfang festlegende Projekt eines Messwertbereichs sichtbar sind, der im Parameter name erwähnt wird.

    Verwenden Sie die Auswahl project, wenn ein Google Cloud -Projekt die Messwerte mehrerer Google Cloud -Projekte oder AWS-Konten anzeigen kann und Sie nur Messwerte für eine Teilmenge dieser Projekte benötigen. Wenn der Messwertbereich für Project-A beispielsweise Project-B enthält, wird eine Übereinstimmung gefunden, wenn name den Wert Project-A hat und Sie den folgenden Filter verwenden:

    project = "Project-B"

    Der folgende Filter stimmt mit jeder Projekt-ID überein, die mit Project- beginnt:

    project = monitoring.regex.full_match("Project-.*")

  • group: Stimmt mit Ressourcen überein, die zu einem Group gehören.

    Der folgende Filter entspricht der Gruppe mit der ID group-id:

    group.id = "group-id"

  • resource: Stimmt mit überwachten Ressourcen eines bestimmten Typs oder mit bestimmten Labelwerten überein.

    • Der folgende Filter stimmt mit allen überwachten Ressourcen überein, die Compute Engine-VM-Instanzen sind:

      resource.type = "gce_instance"

    • Der folgende Filter stimmt mit allen Ressourcen überein, deren Zone mit europe- beginnt:

      resource.labels.zone = starts_with("europe-")

  • metric: Stimmt mit einem bestimmten Messwerttyp oder einer bestimmten Zeitreihe mit einem bestimmten Label überein, das mit einem bestimmten Wert übereinstimmt.

    • Der folgende Filter stimmt mit einem bestimmten Messwerttyp überein:

      metric.type = "compute.googleapis.com/instance/cpu/usage_time"

    • Der folgende Filter gleicht Zeitreihen mit einem Label namens instance_name ab, dessen Wert mit gke-hipster oder gke-nginx beginnt:

      metric.labels.instance_name = monitoring.regex.full_match("gke-(hipster|nginx).*")

In der folgenden Tabelle sehen Sie, welche Selektoren in Filtern basierend auf dem Monitoring API-Aufruf zulässig sind:

Zweck des Filters project-Auswahl group-Auswahl resource-Auswahl metric-Auswahl
Gruppen definieren Ja yes*
Gruppenmitglieder auflisten Ja Ja
Zeitachsen auflisten Ja Ja Ja Ja †
Messwertdeskriptoren auflisten Ja Ja
Listen Sie überwachte Ressourcendeskriptoren auf. Ja
* Die Ressourcenauswahl bietet zusätzliche Optionen, wenn sie zum Definieren der Gruppenmitgliedschaft verwendet wird.
† Beim Auflisten von Zeitreihen müssen Sie genau einen Messwerttyp angeben.

In den folgenden Abschnitten finden Sie Beispiele für typische Anwendungsfälle von Monitoring-Filtern. Eine vollständige Erläuterung der verfügbaren Filterobjekte und ‑operatoren finden Sie unter Filtersyntax.

Zeitreihendaten abrufen

Methode: projects.timeSeries.list
Filterobjekte: project, group.id, resource.type, resource.labels.[KEY], metric.type, metric.labels.[KEY]

Eine Zeitreihe ist eine Liste von Datenpunkten mit Zeitstempel eines Messwerttyps aus einer bestimmten überwachten Ressource. Weitere Informationen finden Sie unter Messwertmodell. Der Messwerttyp wird durch einen Messwertdeskriptor und die überwachte Ressource durch einen Deskriptor für überwachte Ressourcen angegeben.

Der für die Methode timeSeries.list angegebene Filter muss einen metric-Selektor enthalten, der genau einen Messwerttyp angibt:

  • Verwenden Sie den folgenden Filter, um alle Zeitreihen für einen bestimmten Messwerttyp zurückzugeben: 
    metric.type = "compute.googleapis.com/instance/cpu/usage_time"

  • Verwenden Sie den folgenden Filter, um alle Zeitreihen für eine bestimmte Gruppe zurückzugeben. Der Selektor group funktioniert nur mit ausgerichteten Zeitreihendaten. Weitere Informationen finden Sie unter Gruppenselektor:

    metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
group.id = "2468013579"

  • Verwenden Sie den folgenden Filter, um alle Zeitreihen einer bestimmten Compute Engine-Instanz zurückzugeben: 

    metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
metric.labels.instance_name = "my-instance-name"

  • Verwenden Sie den folgenden Filter, um alle Zeitreihen von Compute Engine-Instanzen zurückzugeben, deren Namen mit frontend- beginnen: 

    metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
metric.labels.instance_name = starts_with("frontend-")

  • Verwenden Sie den folgenden Filter, um alle Zeitreihen von Compute Engine-Instanzen zurückzugeben, deren Namen mit gke-hipster oder gke-nginx beginnen: 

    metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
metric.labels.instance_name = monitoring.regex.full_match("^gke-(hipster|nginx).*")

Gruppenmitgliedschaft definieren

Methode: projects.groups.create
Filtern der Objekte: project, resource.type, resource.labels.key, metadata.system_labels.[KEY], metadata.user_labels.[KEY]

Eine Gruppe kann je nach Filter beliebig viele Ressourcen enthalten. Die Gruppenmitgliedschaft ist dynamisch. Bei jeder Auswertung des Filters können mehr oder weniger Ressourcen dem Filter entsprechen. Der Parameter name im Objekt Group gibt die Gruppe und das Bereichsprojekt eines Messwertbereichs an. Wenn der Selektor project im Filter verwendet wird, muss er ein Projekt angeben, dessen Messwerte für das den Umfang festlegende Projekt sichtbar sind.

Wenn Sie beispielsweise eine Gruppe erstellen möchten, die nur Compute Engine-VM-Instanzen in Europa enthält, verwenden Sie den folgenden Filter: 

resource.type = "gce_instance" AND resource.labels.zone = starts_with("europe-")

Informationen zu API-Methoden, mit denen Sie Gruppen löschen, aktualisieren oder auflisten können, finden Sie auf der API-Referenzseite zu projects.groups.

Gruppenmitglieder auflisten

Methode: projects.groups.members.list
Filterobjekte: project, resource.type, resource.labels.[KEY]

Der Parameter name gibt ein den Bereich festlegendes Projekt eines Messwertbereichs und eine in diesem Projekt definierte Gruppe an. Wenn Sie keinen Filter angeben, gibt projects.groups.members.list eine Liste der Mitglieder der Gruppe zurück.

Sie können einen Filter verwenden, um die abgerufenen Gruppenmitglieder einzuschränken. Wenn der Filter einen project-Selektor enthält, muss der Wert des Selektors ein Projekt angeben, dessen Messwerte für das Bereichsprojekt sichtbar sind. Wenn ein ungültiger Wert angegeben wird, wird der Selektor project ignoriert.

Angenommen, Sie erstellen eine Gruppe, die alle Ressourcen enthält, deren Name test enthält. Wenn Sie nur die Gruppenmitglieder auflisten möchten, die Pub/Sub-Themen sind, verwenden Sie den folgenden Filter:

resource.type = "pubsub_topic"

Messwertdeskriptoren auflisten

Methode: projects.metricDescriptors.list
Filterobjekte: project, metric.type

Verwenden Sie einen Filter, um die abgerufenen Messwertdeskriptoren einzuschränken.

Wenn Sie beispielsweise nur die Compute Engine-Messwertdeskriptoren zurückgeben möchten, verwenden Sie den folgenden Filter: 

metric.type = starts_with("compute.googleapis.com")

Eine vollständige Liste der verfügbaren Messwerttypen finden Sie unter Messwertliste. Eine Übersicht über die Benennung von Messwerten finden Sie unter Namenskonventionen für Messwerte.

Überwachte Ressourcendeskriptoren auflisten

Methode: projects.monitoredResourceDescriptors.list
Objekte filtern: resource.type

Verwenden Sie einen Filter, um die abgerufenen Deskriptoren für überwachte Ressourcen einzuschränken.

Wenn Sie beispielsweise nur die Deskriptoren für überwachte Pub/Sub-Ressourcen abrufen möchten, verwenden Sie den folgenden Filter: 

resource.type = starts_with("pubsub")

Eine vollständige Liste der von Monitoring definierten überwachten Ressourcentypen finden Sie unter Liste der überwachten Ressourcen.

Beispiele

In den Filterbeispielen werden der folgende Messwertdeskriptor, der überwachte Ressourcendeskriptor und die VM-Instanz vereinfacht verwendet:

    # Metric descriptor:
    { "name": "projects/my-project-id/metricDescriptors/compute.googleapis.com%2Finstance%2Fdisk%2Fread_bytes_count",
      "type": "compute.googleapis.com/instance/disk/read_bytes_count",
      "labels": [ { "key": "device_name",
                    "description": "The name of the disk device." } ] }

    # Monitored resource descriptor:
    {  "name": "monitoredResourceDescriptors/gce_instance",
       "type": "gce_instance",
       "labels": [
         { "key": "instance_id",
           "description": "The instance ID provided by Google Compute Engine." },
         { "key": "zone",
           "description": "The Google Cloud Platform zone hosting the instance."
         } ] }

    # Resource descriptor for a virtual machine instance.
    { "type": "gce_instance",
      "instance_id": "1472038649266883453",
      "zone": "us-east-1b",
      "disks": [ "log_partition" ],
      "machine_type": "n1-standard-2",
      "tags": { "environment": "bleeding-edge",
                "role": "frobulator" },
      "project_id": "my-project-id" }

Beispiele zum Abrufen von Messwerten

Wenn Sie die Bandbreitennutzung für Lesevorgänge auf Laufwerken für alle Instanzen und alle Geräte anfordern möchten, definieren Sie einen Filter wie folgt. Dieser Filter gibt für jede Instanz eine separate Zeitreihe zurück, die die Lesebandbreite für jedes Gerät enthält:

metric.type = "compute.googleapis.com/instance/disk/read_bytes_count"

Wenn Sie die Anfrage so verfeinern möchten, dass nur die Lesebandbreite für das Laufwerk mit dem Namen „log_partition“ auf jeder Instanz abgefragt wird, definieren Sie den Filter so: Dieser Filter gibt für jede Instanz höchstens eine Zeitreihe zurück, je nachdem, ob auf dieser Instanz ein Gerät mit diesem Namen vorhanden ist:

metric.type = "compute.googleapis.com/instance/disk/read_bytes_count" AND
metric.labels.device_name = "log_partition"

Wenn Sie die Anfrage auf eine einzelne Instanz beschränken möchten, geben Sie diese Instanz an:

resource.type = "gce_instance" AND
resource.labels.instance_id = "1472038649266883453" AND
metric.type = "compute.googleapis.com/instance/disk/read_bytes_count" AND
metric.labels.device_name = "log_partition"

Nach Gruppen filtern

In den folgenden Beispielen wird die Verwendung der Gruppenauswahl in Filtern veranschaulicht, um überwachte Ressourcen auf die in einer bestimmten Gruppe zu beschränken. Informationen zu den Selektoren, die zum Definieren der Gruppenmitgliedschaft verwendet werden, finden Sie unter Ressourcenauswahl für Gruppendefinitionen.

{ "name": "projects/my-test-project/groups/024681012",
  "display_name": "My Redis Cluster",
  "filter": "metadata.user_labels.role=redis" }

In einem Aufruf der Methode projects.timeSeries.list fordert der folgende Filter die Bandbreitennutzung für das Lesen von Laufwerken für alle Compute Engine-Instanzen in einer bestimmten Gruppe an. Die Gruppe muss im Scoping-Projekt eines Messwertbereichs definiert sein, der im Parameter name der Methode angegeben ist:

resource.type = "gce_instance" AND
group.id = "024681012" AND
metric.type = "compute.googleapis.com/instance/disk/read_bytes_count"

Referenz: Filtersyntax

Eine Übersicht über Filter mit Beispielen finden Sie unter Filter verwenden.

Ein Monitoring-Filter ist ein String, der aus bis zu vier Selektortypen besteht:

    <monitoring_filter> ::=  <project_selector> AND
                             <group_selector> AND
                             <resource_selector> AND
                             <metric_selector>

Der Filter stimmt mit einem Element überein, wenn alle enthaltenen Selektoren mit dem Element übereinstimmen. Wie in den folgenden Abschnitten beschrieben, können einige Selektoren mehrere Vergleiche enthalten, die durch AND oder OR verbunden sind. Die Reihenfolge der Selektoren im Filter spielt keine Rolle, aber Vergleiche für verschiedene Selektoren dürfen nicht vermischt werden.

Je nach Zweck des Filters können bestimmte Selektoren erforderlich, optional oder unzulässig sein. Der Filter, der zum Auflisten von Zeitreihen verwendet wird, muss beispielsweise einen Messwertselektor enthalten. Der Filter, der die Ressourcen in einer Gruppe definiert, darf jedoch keinen Messwertselektor enthalten, da Gruppen keine Messwerttypen oder Zeitreihen enthalten.

Vergleiche

Filter und ihre Selektoren werden aus Vergleichen erstellt. Jeder Vergleich hat das folgende Format:

  • [OBJECT]: Wählt einen zu testenden Wert aus. Eine der folgenden Optionen:

    project
group.id
metric.type
metric.labels.[KEY]
resource.type
resource.labels.[KEY]
metadata.system_labels.[KEY]
metadata.user_labels.[KEYSTRING]

    [KEY] ist ein Name, z. B. zone oder instance_id.

    [KEYSTRING] kann ein Name sein. Wenn er Sonderzeichen enthält, muss er in Anführungszeichen (") gesetzt werden.

  • [OPERATOR]: ein Vergleichsoperator, einer der folgenden:

    =            # equality (case-sensitive)
> < >= <=    # numeric ordering
!=           # not equal
:            # "has" substring match and test for key (case-sensitive)

  • [VALUE]: ein Literalwert oder ein integrierter Funktionsaufruf; einer der folgenden Werte:

    <string>     # "a Unicode string". Don't use apostrophes (`'`) to quote strings.
<bool>       # true or false
<number>     # 0, -2, 123456, 3.14156
<function>   # operators on the right side of '=' or '!=':
             #   starts_with(<string>)
             #   ends_with(<string>)
             #   has_substring(<string> [, ignore_case=false])
             #   one_of(<string>,...,<string>) for up to 100 strings
             #   monitoring.regex.full_match(<RE2-string>)

    Außer bei Verwendung in der Methode timeSeries.list akzeptiert der Filter has_substring ein optionales zweites Argument, das angibt, ob bei der Übereinstimmung die Groß-/Kleinschreibung ignoriert wird oder nicht. Der Standardwert ist false, sodass bei der Standardübereinstimmung die Groß-/Kleinschreibung berücksichtigt wird:

    • Groß-/Kleinschreibung beachten: display_name=has_substring("Demo")
    • Groß-/Kleinschreibung beachten: display_name=has_substring("Demo", false)
    • Groß-/Kleinschreibung wird nicht beachtet: display_name=has_substring("Demo", true)

    Bei Verwendung in der Methode timeSeries.list wird nur das Formular has_substring(<string>) unterstützt.

    Der Filter monitoring.regex.full_match verwendet einen String mit regulärem Ausdruck in der RE2-Syntax.

Mit den folgenden Operatoren können Sie Vergleiche gruppieren oder ändern. OR hat eine höhere Priorität als AND. Die Operatoren müssen in Großbuchstaben geschrieben werden:

(...)        # grouping comparisons
AND          # conjunction (optional but recommended)
OR           # disjunction

Der Operator AND kann zwischen Operatoren weggelassen werden, ist jedoch klarer und weniger fehleranfällig.

Der Vergleich x = one_of("a", "b", "c") entspricht Folgendem:

(x = "a" OR x = "b" OR x = "c")
Nur in Gruppendefinitionen können Sie den unären Negationsoperator NOT vor einem Vergleich verwenden, aber nicht mit einem Existenzoperator (:) oder vor einem Ausdruck in Klammern:

NOT          # negates the following comparison

Die Auswahl filtern

Verwenden Sie Selektoren, um die Filterauswahl auf bestimmte Elemente zu beschränken. In den folgenden Abschnitten werden Klammern zur Darstellung von Wiederholungen verwendet. Die Notation <x> {OR <y>} bedeutet beispielsweise, dass Sie Folgendes schreiben können:

<x>
<x> OR <y>
<x> OR <y> OR <y>
<x> OR <y> OR <y> OR <y>
...

Projektauswahl

Mit einer Projektauswahl wird die Filterauswahl auf Elemente beschränkt, die zu einem einzelnen Projekt oder einem Projektsatz gehören. Jedes Projekt kann durch seine ID, seine Nummer oder mithilfe eines regulären Ausdrucks angegeben werden:

<project_selector> ::= project '=' (<number> | <string> | monitoring.regex.full_match '(' <RE2-string> ')') {OR project '=' (<number> | <string> | monitoring.regex.full_match '(' <RE2-string> ')')}

Wenn Ihr Projektselektor mehr als einen Vergleich enthält, setzen Sie den gesamten Selektor in Klammern, um die Lesbarkeit zu verbessern. Beispiel:

(project=12345 OR project="my-project-id" OR monitoring.regex.full_match("^6789.*") OR monitoring.regex.full_match("some-project-id.*" )) AND resource.type="gce_instance"

Gruppenauswahl

Eine Gruppenauswahl beschränkt die Filterauswahl auf Elemente, die zu einer einzelnen Gruppe gehören:

<group_selector> ::= group.id '=' <string>

Mit dem folgenden Filter kann beispielsweise eine Zeitreihe von jeder VM-Instanz in einer Gruppe abgerufen werden:

group.id = 12345 AND
resource.type = "gce_instance" AND
metric.type = "compute.googleapis.com/instance/disk/read_bytes_count"

Die Gruppenauswahl ist nur in Filtern zulässig, die an die Methode projects.timeSeries.list übergeben werden. Außerdem sind für die Gruppenauswahl ausgerichtete Daten erforderlich. Das bedeutet, dass der Aufruf projects.timeSeries.list Werte für die Felder perSeriesAligner und alignmentPeriod enthalten muss. Das liegt daran, dass die Gruppenmitgliedschaft selbst eine Art Zeitreihe ist, die mit den Messwertdaten verknüpft werden muss. Durch die Angabe von Ausrichtungsparametern können Sie steuern, wie diese Verknüpfung erfolgt. Weitere Informationen zu Ausrichtungsparametern finden Sie unter Daten aggregieren.

Ressourcenauswahl

Eine Ressourcenauswahl beschränkt die Filterauswahl auf Ressourcen oder mit Ressourcen verknüpfte Elemente, die einen bestimmten Ressourcentyp oder bestimmte Labelwerte haben:

<resource_selector> ::= <resource_type_expression>
                      | <resource_label_expression>
                      | <resource_type_expression> AND <resource_label_expression>

<resource_type_expression> ::= resource.type '=' <string>
                             | resource.type ':' <string>
                             | resource.type '=' starts_with '(' <string> ')'
                             | resource.type '=' ends_with '(' <string> ')'

<r_label_comparison> ::= resource.labels.[KEY] '=' (<string> | <bool>)
                       | resource.labels.[KEY] ':' <string>
                       | resource.labels.[KEY] '=' (starts_with | ends_with) '(' <string> ')'
                       | resource.labels.[KEY] ('=' | '>' | '<' | '>=' | '<=') <number>

<resource_label_expression> ::= <r_label_comparison> {AND <r_label_comparison>}
                              | <r_label_comparison> {OR <r_label_comparison>}

Wenn Sie mehr als ein <r_label_comparison> in Ihrem Selektor verwenden, setzen Sie alle in Klammern, um die Lesbarkeit zu verbessern. Mit dem folgenden Filter können Sie beispielsweise eine Gruppe definieren, die alle Compute Engine-VM-Instanzen in den USA und Europa enthält:

resource.type = "gce_instance" AND
(resource.labels.zone = starts_with("us-") OR resource.labels.zone = starts_with("europe-"))

Ressourcenauswahl für Gruppendefinitionen

Ressourcenauswahlen, die zum Definieren von Gruppenmitgliedschaften verwendet werden, verwenden Erweiterungen für die Syntax <resource_selector>:

  • Sie können Filter basierend auf dem Wert von Systemlabels für Metadaten (metadata.system_labels.[KEY]) und Nutzerlabels für Metadaten (metadata.user_labels.[KEYSTRING]) einfügen. Wir empfehlen, die Schlüssel für metadata.user_labels in Anführungszeichen zu setzen, da sie Sonderzeichen wie Bindestriche enthalten können.

    Wenn ein Selektor einen Metadatenfilter und einen Ressourcenfilter enthält, müssen Sie diese mit AND kombinieren. OR kann nicht verwendet werden. In einem Diagramm mit der folgenden Auswahl wird beispielsweise die CPU-Auslastung für alle VM-Instanzen mit dem Maschinentyp e2-medium oder e2-micro angezeigt:

    metric.type="compute.googleapis.com/instance/cpu/utilization"
resource.type="gce_instance" AND
(metadata.system_labels."machine_type"="e2-medium" OR
metadata.system_labels."machine_type"="e2-micro")

  • Sie können den Nicht-Gleich-Operator (!=) verwenden, um Ressourcentypen, Ressourcenlabels und Metadaten zu vergleichen. Der Operator kann beim Vergleich von Strings, Zahlen, booleschen Werten oder Teilstringfunktionen verwendet werden. Beispiel: resource.type!=starts_with("gce") ist "true", wenn der Ressourcentyp nicht mit "gce" beginnt.

  • Sie können einen einzelnen NOT-Operator vor einem Ressourcenvergleich verwenden. Beispiel: NOT resource.labels.zone="europe" ist „true“, wenn die Zone der Ressource nicht "europe" enthält. Sie können NOT nicht vor einem Existenzoperator (:) oder einem Ausdruck in Klammern verwenden.

  • Mit dem Operator „exists“ (:) können Sie prüfen, ob Schlüssel vorhanden sind. Der Vergleich resource.labels:zone ist beispielsweise wahr, wenn der Labelschlüssel zone in der Ressource vorhanden ist.

Einer der Metadatenschlüssel für Plattformressourcen für VM-Instanzen ist beispielsweise spot_instance. Mit der folgenden Filterauswahl werden Instanzen ausgewählt, bei denen es sich um Spot-Instanzen handelt:

resource.type = "gce_instance" AND metadata.system_labels.spot_instance = true

Messwertauswahl

Eine Messwertauswahl gibt bestimmte Messwerte oder Messwertdeskriptoren an, indem der Messwerttyp und die Messwertlabels begrenzt werden. Bei Verwendung mit der Methode projects.timeSeries.list muss der Messwertselektor einen einzelnen Messwerttyp angeben:

<metric_selector> ::= <metric_name_expression> [AND <metric_label_expression>]

<metric_name_expression> ::= metric.type '=' <string>
                           | metric.type ':' <string>
                           | metric.type '=' starts_with '(' <string> ')'
                           | metric.type '=' ends_with '(' <string> ')'

<metric_label_comparison> ::= metric.labels.[KEY] '=' <string> | <bool>
                            | metric.labels.[KEY] ':' <string>
                            | metric.labels.[KEY] '=' starts_with '(' <string> ')'
                            | metric.labels.[KEY] '=' ends_with '(' <string> ')'
                            | metric.labels.[KEY] ('=' | '>' | '<' | '>=' | '<=') <number>

<metric_label_expression> ::= <metric_label_comparison> {[AND] <metric_label_comparison>}
                            | <metric_label_comparison> {OR <metric_label_comparison>}

Mit dem folgenden Filter können Sie beispielsweise eine Zeitreihe für eine bestimmte Datenbankinstanz abrufen:

metric.type = "cloudsql.googleapis.com/database/state" AND
(metric.labels.resource_type = "instance" AND
 metric.labels.resource_id = "abc-123456")