OTLP-Attribute zur Zuordnung von Ressourcentypen

In diesem Dokument werden die Regeln beschrieben, mit denen Google Cloud Observability den Typ der überwachten Ressource in Logging für Logdaten bestimmt, die von der Telemetry API aufgenommen werden. Die überwachte Ressource beschreibt die Quelle der Logdaten und wird in einem LogEntry mithilfe von Labels dargestellt. Google Cloud Observability bestimmt die Werte dieser Labels anhand der OTLP-Ressourcenattribute.

Allgemeine Struktur von Logdaten im OTLP-Format

Wenn Logdaten mit der Telemetry API an Google Cloud gesendet werden, müssen diese Daten in einem Format vorliegen, das mit OTLP kompatibel ist. Die allgemeine Struktur dieser Daten sieht so aus:

"resourceLogs": [
    {
      "resource": {
        "attributes": [...]
      },
      "scopeLogs": [
        {
          "logRecords": [...]
        }
      ]
    }
]

OpenTelemetry fasst einzelne Logs zusammen, die jeweils durch eine logRecord-Struktur dargestellt werden, mit Informationen zur Quelle dieser Logs, die durch die resource-Struktur dargestellt wird.

Wenn Google Cloud Observability ein resourceLogs-Objekt empfängt, wird für jeden logRecord ein LogEntry erstellt. Im Gegensatz zu OTLP, wo Quellinformationen mit einer Sammlung einzelner Logs zusammengefasst werden, enthält jede LogEntry-Struktur Informationen zur Quelle des Logs und zum Log selbst.

Weitere Informationen zur Struktur von Logdaten im OTLP-Format finden Sie unter siehe die OpenTelemetry logs.proto.

OTLP-Ressourcenattribute mit dem Google Cloud Ressourcendetektor festlegen

Verwenden Sie einen Google Cloud Ressourcendetektor, um OTLP-Ressourcenattribute in Ihren OTLP-Logdaten festzulegen. Diese Detektoren fügen der Telemetrie die OTLP-Ressourcenattribute hinzu, die die Quelle der Telemetrie beschreiben:

Konfigurieren Sie für den collectorbasierten Export die Ressourcenerkennung als Teil der Prozessoren des Collectors. Ihr Collector kann beispielsweise zwei Ressourcendetektoren angeben:
```
resourcedetection:
    detectors: ["env", "gcp"]
```
In den folgenden Dokumenten finden Sie Beispiele für Collector, die Messwert- oder Tracedaten exportieren:
- Collector bereitstellen und verwenden: Beschreibt, wie Sie Messwertdaten an die Telemetry API senden.
- Google-eigenen OpenTelemetry Collector in Google Kubernetes Engine bereitstellen: Beschreibt, wie Sie Log-, Messwert- und Tracedaten erfassen, wenn Sie Google Kubernetes Engine verwenden. Der Collector sendet Tracedaten an die Telemetry API und Messwertdaten an einen Prometheus-Exporter.
Hinweis: Wir empfehlen, bei Verwendung von Google Kubernetes Engine einen collectorbasierten Export zu verwenden. Dies ist die einzige Konfiguration, mit der Sie die Ressourcenattribute konfigurieren können, die Google Cloud Observability benötigt, um Telemetriedaten einer App Hub-Anwendung zuzuordnen.
Wenn Sie den direkten Export verwenden, verwenden Sie den entsprechenden Google Cloud Ressourcendetektor für Ihre Sprache:

So werden Ressourcenlabels festgelegt

Jeder Logeintrag enthält eine Reihe von Labels, die die Quelle des Logeintrags identifizieren. Diese Quelle wird auch als eine überwachte Ressource in Loggingbezeichnet. Im Folgenden werden die Labels für Google Kubernetes Engine veranschaulicht.

resource: {
    labels: {
        cluster_name: "my-cluster"
        container_name: "server"
        location: "us-central1"
        namespace_name: "default"
        pod_name: "my-pod"
        project_id: "my-project"
    }
    type: "k8s_container"
}

Wie Sie sehen, hat eine überwachte Ressource ein Feld type und ein oder mehrere labels. Die Labels für eine überwachte Ressource enthalten mindestens project_id oder resource_container.

In der folgenden Tabelle werden die Regeln beschrieben, mit denen Google Cloud Observability OTLP-Ressourcenattribute einer überwachten Ressource zuordnet. Die Tabelle ist sortiert. Wenn die Ressourcenattribute beispielsweise cloud.platform enthalten und der Wert gcp_compute_engine ist, wird der Typ der überwachten Ressource auf gce_instance festgelegt. Um den Wert eines Labels einer überwachten Ressource zu bestimmen, verwendet Google Cloud Observability eine priorisierte Liste von Ressourcenattributen. Der Wert eines Labels ist ein leerer String, wenn keine der Ressourcenattribute verfügbar sind.

OTLP-Attribut und Wert an einen Logeintrag angehängt	Typ der überwachten Ressource in Cloud Logging	Labelwerte der überwachten Ressource aus OTLP-Ressourcenattributen abgeleitet, nach Priorität
`cloud.platform` hat den Wert `gcp_compute_engine`	`gce_instance`	`project_id`: siehe Projekt-ID ableiten. `instance_id`: instance_id, host.id `zone`: zone, cloud.availability_zone
`cloud.platform` hat den Wert `gcp_app_engine`	`gae_app`	`project_id`: siehe Projekt-ID ableiten. `module_id`: gae_module_id, faas.name `version_id`: gae_version_id, faas.version `zone`: zone, cloud.availability_zone
`cloud.platform` hat den Wert `aws_ec2`	`aws_ec2_instance`	`project_id`: siehe Projekt-ID ableiten. `instance_id`: instance_id, host.id `aws_account`: aws_account, cloud.account.id `region`: region, cloud.availability_zone, cloud.region
`cloud.platform` hat den Wert `gcp_bare_metal_solution`	`baremetal instance`	`resource_container`: siehe resource_container-ID ableiten. `region`: region, cloud.availability_zone, cloud.region `instance_id`: instance_id, host.id
`service.name` und `service.instance.id` sind nicht leer	`generic_task`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `namespace`: namespace, service.namespace `job_name`: job, service.name, faas.name `task_id`: task_id, service.instance.id, faas.instance
`faas.name` und `faas.instance` sind nicht leer	`generic_task`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `namespace`: namespace, service.namespace `job_name`: job, service.name, faas.name `task_id`: task_id, service.instance.id, faas.instance
`k8s.cluster.name` und `k8s.container.name` sind nicht leer	`k8s_container`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `cluster_name`: cluster_name, k8s.cluster.name `namespace_name`: namespace_name, k8s.namespace_name `pod_name`: pod_name, k8s.pod.name `container_name`: container_name, k8s.container.name
`k8s.cluster.name` und `k8s.pod.name` sind nicht leer	`k8s_pod`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `cluster_name`: cluster_name, k8s.cluster.name `namespace_name`: namespace_name, k8s.namespace_name `pod_name`: pod_name, k8s.pod.name
`k8s.cluster.name` und `k8s.node.name` sind nicht leer	`k8s_node`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `cluster_name`: cluster_name, k8s.cluster.name `node_name`: node_name, k8s.node.name
`k8s.cluster.name` ist nicht leer	`k8s_cluster`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `cluster_name`: cluster_name, k8s.cluster.name
Kein anderes Label stimmt überein	`generic_node`	`project_id`: siehe Projekt-ID ableiten. `location`: location, cloud.availability_zone, cloud.region `namespace`: namespace, service.namespace `node_id`: node_id, host.id, host_name

Labelwert für Projekt- oder Ressourcencontainer-ID ableiten

Alle Typen der überwachten Ressource in Logging haben entweder ein project_id-Label oder ein resource_container-Label. Das System durchsucht die folgenden Attribute in der angegebenen Reihenfolge, um den Wert dieser Labels zu bestimmen:

project_id
gcp.project.id
gcp.project_id
gcp.dest_project_id
gcp.resource.container
resource_container
cloud.account.id
cloud.account_id