Monitoring-Filter

In diesem Leitfaden wird beschrieben, wie Sie Filter bei Verwendung der Monitoring API konfigurieren. Mit Filtern geben Sie überwachte Ressourcen, Messwerttypen, -Gruppendefinitionen, und Zeitachsen an.

Sie können auch einen Filter verwenden, um eine Benachrichtigungsrichtlinie zu konfigurieren, die Prozesse überwacht, die auf Ihren Systemen ausgeführt werden. Informationen zu diesen Filtern finden Sie unter Filter für die Prozessintegrität.

Hinweise

Wenn Sie mit Messwerten, Zeitreihen und überwachten Ressourcen nicht vertraut sind, finden Sie weitere Informationen unter 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 Zeitachsendaten aus, die von einer list-API-Anfrage zurückgegeben werden. Der Filter kann Zeitachsen basierend auf dem Projekt, der -Gruppe, den Attributen der überwachten und den Messwertattributen der Daten auswählen. Weitere Informationen und Beispiele finden Sie unter Zeitachsendaten 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 basierend auf den Attributen der Ressourcen und dem Projekt aus, zu dem sie gehören. Weitere Informationen und Beispiele finden Sie unter Gruppenmitglieder auflisten.
Listen Sie bestimmte Messwerttypen auf. Weitere Informationen und Beispiele finden Sie unter Messwertdeskriptoren auflisten.
Listen Sie bestimmte überwachte Ressourcentypen au. Weitere Informationen und Beispiele finden Sie unter Überwachte Ressourcendeskriptoren auflisten.

Die Auswahl filtern

Ein Filter besteht aus mindestens einem Selektor, der ein Filter-Keyword ist. In den folgenden Beispielen werden die verschiedenen Selektoren veranschaulicht:

project: Übereinstimmung, wenn die Messwerte des angegebenen Projekts für das den Umfang festlegende Projekt eines im Parameter name genannten Messwertbereichs sichtbar sind.

Verwenden Sie die Auswahl project, wenn ein Google Cloud-Projekt die Messwerte mehrerer Google Cloud-Projekte oder AWS-Konten ansehen kann und Sie nur Messwerte für ein einzelnes Projekt abrufen möchten. Wenn der Messwertbereich für Project-A beispielsweise Project-B enthält, kommt es zu einer Übereinstimmung, wenn name den Wert Project-A hat und Sie den folgenden Filter verwenden:
```
project = "Project-B"
```
group: Gleicht Ressourcen ab, die zu einer Group gehören.

Der folgende Filter entspricht der Gruppe mit der Kennzeichnung group-id:
```
group.id = "group-id"
    
```
resource: Gleicht überwachte Ressourcen eines bestimmten Typs oder mit bestimmten Labelwerten ab.
- Der folgende Filter entspricht allen überwachten Ressourcen, bei denen es sich um Compute Engine-VM-Instanzen handelt:
```
resource.type = "gce_instance"
```
- Der folgende Filter stimmt mit allen Ressourcen überein, deren Zone mit europe- beginnt:
```
resource.labels.zone = starts_with("europe-")
```
metric: Gleicht einen bestimmten Messwerttyp oder eine Zeitachse mit einem bestimmten Label ab, das einem bestimmten Wert entspricht.
- Der folgende Filter entspricht einem bestimmten Messwerttyp:
```
metric.type = "compute.googleapis.com/instance/cpu/usage_time"
```
- Der folgende Filter entspricht Zeitachsen mit einem Label namens instance_name, dessen Wert mit gke-hipster oder gke-nginx beginnt:
```
metric.labels.instance_name = monitoring.regex.full_match("gke-(hipster|nginx).*")
```

Die folgende Tabelle zeigt, welche Auswahlelemente in Filtern basierend auf dem Aufruf der Monitoring API zulässig sind:

Zweck des Filters	`project`-Selektor	`group`-Selektor	`resource`-Selektor	`metric`-Selektor
Gruppen definieren	yes		ja^*
Gruppenmitglieder auflisten	Ja		yes
Zeitachsen auflisten	yes	Ja	yes	ja ^†
Messwertdeskriptoren auflisten	Ja			Ja
Listen Sie überwachte Ressourcendeskriptoren auf.			yes

^* Die Ressourcenauswahl bietet zusätzliche Optionen, wenn sie zum Definieren der Gruppenmitgliedschaft verwendet wird.
^† Beim Auflisten von Zeitachsen 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 Beschreibung der verfügbaren Filterobjekte und Operatoren finden Sie unter Filtersyntax.

Zeitachsendaten werden abgerufen

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

Eine Zeitachse ist eine Liste mit Zeitstempeln 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 angeben muss:

So geben Sie alle Zeitreihen für einen bestimmten Messwerttyp zurück:
```
metric.type = "compute.googleapis.com/instance/cpu/usage_time"
```
So werden alle Zeitreihen für eine bestimmte Gruppe zurückgegeben. Der group-Selektor funktioniert nur mit ausgerichteten Zeitachsendaten. Weitere Informationen finden Sie unter Gruppen-Selektor:
```
metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
group.id = "2468013579"
```

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

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

Wenn Sie alle Zeitachsen von Compute Engine-Instanzen zurückgeben, deren Namen mit frontend- beginnen, verwenden Sie den folgenden Filter:
```
metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
metric.labels.instance_name = starts_with("frontend-")
```

Wenn Sie alle Zeitachsen von Compute Engine-Instanzen zurückgeben, deren Namen mit gke-hipster oder gke-nginx beginnen, verwenden Sie den folgenden Filter:

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
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. Mit dem Parameter name im Objekt Group werden die Gruppe und das den Umfang festlegende Projekt eines metrics-scope-concept des Messwertbereichs angegeben. Wenn im Filter die Auswahl project verwendet wird, muss sie ein Projekt angeben, dessen Messwerte für das den Umfang festlegende Projekt sichtbar sind.

Verwenden Sie den folgenden Filter, um eine Liste aller Compute Engine-VM-Instanzen in Europa zurückzugeben:
```
resource.type = "gce_instance" AND resource.labels.zone = starts_with("europe-")
```

Gruppenmitglieder auflisten

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

Verwenden Sie einen Filter, um einzuschränken, welche Gruppenmitglieder Sie abrufen. Der Parameter name gibt ein umfassendes Projekt eines Messwertbereichs und eine in diesem Projekt definierte Gruppe an. Wenn im Filter die Auswahl project verwendet wird, muss sie ein Projekt angeben, dessen Messwerte für das den Umfang festlegende Projekt sichtbar sind.

Verwenden Sie den folgenden Filter, um eine Liste aller Pub/Sub-Themenressourcen zurückzugeben, die zum Projekt my-project gehören:
```
project = "my-project" AND resource.type = "pubsub_topic"
```

Messwertdeskriptoren auflisten

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

Verwenden Sie einen Filter, um einzuschränken, welche Messwertdeskriptoren Sie abrufen:

Verwenden Sie den folgenden Filter, um nur die Compute Engine-Messwertdeskriptoren zurückzugeben:
```
metric.type = starts_with("compute.googleapis.com")
```

Eine vollständige Liste der verfügbaren Messwerttypen finden Sie unter Liste der Messwerte. Einen Überblick ü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 einzuschränken, welche überwachten Ressourcendeskriptoren Sie abrufen:

Verwenden Sie den folgenden Filter, um nur die überwachten Pub/Sub-Ressourcendeskriptoren abzurufen:
```
resource.type = starts_with("pubsub")
```

Eine vollständige Liste der von Monitoring definierten Typen überwachter Ressourcen finden Sie unter Liste überwachter 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 provide 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

Definieren Sie wie folgt einen Filter, um die Bandbreitennutzung für die Laufwerksleserate für alle Instanzen und alle Geräte anzufordern. Dieser Filter gibt für jede Instanz eine separate Zeitreihe zurück, die die Lesebandbreite für jedes Gerät meldet:

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

Definieren Sie den Filter wie folgt, um die Anfrage zur Abfrage der Lesebandbreite nur für das Laufwerkgerät, das bei jeder Instanz als „log_partition“ bekannt ist, zu verfeinern. Dieser Filter gibt für jede Instanz maximal eine Zeitachse zurück, je nachdem, ob ein Gerät mit diesem Namen in der Instanz vorhanden ist:

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

Um die Anfrage auf eine einzelne Instanz zu beschränken, 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

Die folgenden Beispiele veranschaulichen die Verwendung der Gruppenauswahl in Filtern, um überwachte Ressourcen auf eine bestimmte 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" }

Bei 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 haben, die durch AND oder OR verknüpft sind. Die Reihenfolge der Selektoren im Filter spielt keine Rolle, Vergleiche für verschiedene Selektoren dürfen jedoch nicht vermischt werden.

Je nach Zweck des Filters können bestimmte Selektoren erforderlich, optional oder unzulässig sein. Der Filter zum Auflisten von Zeitachsen muss beispielsweise eine Messwertauswahl enthalten. Der Filter, mit dem die Ressourcen in einer Gruppe definiert werden, darf jedoch keinen Messwertselektor enthalten, da Gruppen keine Messwerttypen oder Zeitachsen enthalten.

Vergleiche

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

[OBJEKT]: 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 wie zone oder instance_id.

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

[OPERATOR]: Vergleichsoperator; einer der folgenden Werte:

=            # 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>)
    
```
Sofern der Filter has_substring nicht in der Methode timeSeries.list verwendet wird, verwendet er ein optionales zweites Argument, das angibt, ob bei der Übereinstimmung die Groß- und Kleinschreibung ignoriert wird. Der Standardwert ist false. Beim Standardabgleich wird also zwischen Groß- und Kleinschreibung unterschieden:
- Groß-/Kleinschreibung beachten: display_name=has_substring("Demo")
- Groß-/Kleinschreibung beachten: display_name=has_substring("Demo", false)
- Groß-/Kleinschreibung wird nicht berücksichtigt: display_name=has_substring("Demo", true)
Bei Verwendung in der Methode timeSeries.list wird nur das Formular has_substring(<string>) unterstützt.

Für den Filter monitoring.regex.full_match wird ein String mit regulärem Ausdruck in der RE2 verwendet.

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 Folgendes:

(x = "a" OR x = "b" OR x = "c")

Nur in Gruppendefinitionen können Sie den unären Negationsoperator NOT vor einem Vergleich verwenden, jedoch nicht mit einem vorhandenen Operator (:) 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 oder seine Nummer angegeben werden:

<project_selector> ::= project '=' (<number> | <string>) {OR project '=' (<number> | <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") 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>

Der folgende Filter kann beispielsweise verwendet werden, um Zeitachsen aus jeder der VM-Instanzen in einer Gruppe abzurufen:

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 erfordert die Gruppenauswahl ausgerichtete Daten, d. h., der projects.timeSeries.list-Aufruf muss Werte für die Felder perSeriesAligner und alignmentPeriod enthalten. Dies liegt daran, dass die Gruppenmitgliedschaft selbst eine Art Zeitreihe ist, die mit den Messwertdaten verknüpft werden muss. Mit Ausrichtungsparametern können Sie steuern, wie der Join 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 eine <r_label_comparison> in Ihrem Selektor verwenden, setzen Sie sie zur besseren Lesbarkeit alle in Klammern. Mit dem folgenden Filter lässt sich z. B. 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 fügen Filter basierend auf dem Wert von Metadatensystemlabels (metadata.system_labels.[KEY]) und Metadaten-Nutzerlabels (metadata.user_labels.[KEYSTRING]) ein. Wir empfehlen, die Schlüssel für metadata.user_labels anzugeben, 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. Ein Diagramm mit der folgenden Auswahl zeigt beispielsweise die CPU-Auslastung für alle VM-Instanzen mit dem Maschinentyp e2-medium oder e2-micro an:
```
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 vor einem Ressourcenvergleich einen einzelnen NOT-Operator 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 vorhandenen Operator (:) oder einem Ausdruck in Klammern verwenden.
Mit dem Operator „exists“ (:) können Sie prüfen, ob Schlüssel vorhanden sind. Für den Vergleich resource.labels:zone gilt beispielsweise der Wert „true“, 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 die Messwertauswahl 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>}

Der folgende Filter könnte beispielsweise verwendet werden, um eine Zeitachse für eine bestimmte Datenbankinstanz abzurufen:

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