Benutzerdefinierte Messwerte mit OpenCensus erstellen

OpenCensus ist ein kostenloses Open-Source-Projekt, Bibliotheken:

  • Anbieterneutraler Support für die Erfassung von Messwert- und Trace-Daten in mehreren Sprachen.
  • Er kann die gesammelten Daten in verschiedene Backend-Anwendungen exportieren, einschließlich Cloud Monitoring mithilfe von Exportern

Cloud Monitoring bietet zwar eine API, die das Definieren und zum Erfassen benutzerdefinierter Metriken handelt es sich um eine Low-Level-Proprietäre API. OpenCensus bietet eine API, die dem Stil des Sprachcommunity zusammen mit einem Exporteur, der Ihre Messwertdaten an Cloud Monitoring über die Monitoring API für Sie.

OpenCensus bietet außerdem eine gute Unterstützung für Anwendungs-Tracing. Einen allgemeinen Überblick finden Sie unter OpenCensus Tracing. Cloud Trace empfiehlt OpenCensus für die Trace-Instrumentierung. Um sowohl Messwert- als auch Trace-Daten von Ihren Diensten zu erfassen, können Sie eine einzige Bibliothek verwenden. Weitere Informationen zum Verwenden von OpenCensus mit Cloud Trace finden Sie unter Clientbibliotheken für Trace.

Hinweise

Um Cloud Monitoring verwenden zu können, muss ein Google Cloud-Projekt mit aktivierter Abrechnungsfunktion vorhanden sein. Gehen Sie bei Bedarf so vor:

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  3. Achten Sie darauf, dass die Monitoring API aktiviert ist. Weitere Informationen finden Sie unter Monitoring-API aktivieren.

  4. Bei Anwendungen, die außerhalb von Google Cloud ausgeführt werden, Das Google Cloud-Projekt muss Ihre Anwendung authentifizieren. Normalerweise konfigurieren Sie die Authentifizierung, indem Sie ein Dienstkonto für Ihr Projekt und durch Konfigurieren einer Umgebung .

    Für Anwendungen, die auf einem Amazon Elastic Compute Cloud-Instanz (Amazon EC2) das Dienstkonto für die Instanz AWS-Verbindungsprojekt

    Informationen zum Erstellen eines Dienstkontos finden Sie unter Erste Schritte bei der Authentifizierung

OpenCensus installieren

Damit Sie von OpenCensus in Ihrem Google Cloud-Projekt erfasste Messwerte verwenden können, müssen Sie OpenCensus-Messwertbibliotheken und Stackdriver-Exporter verfügbar machen zu Ihrer Anwendung hinzufügen. Der Stackdriver-Exporter exportiert die Messwerte, OpenCensus erfasst Daten in Ihrem Google Cloud-Projekt. Sie können dann Cloud Monitoring, um diese Messwerte grafisch darzustellen oder zu überwachen.

Go

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Für die Verwendung von OpenCensus ist Go in der Version 1.11 oder höher erforderlich. Die Abhängigkeiten werden automatisch für Sie gehandhabt.

Java

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Fügen Sie für Maven Folgendes zum dependencies-Element in der pom.xml-Datei: 
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-api</artifactId>
  <version>${opencensus.version}</version>
</dependency>
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-exporter-stats-stackdriver</artifactId>
  <version>${opencensus.version}</version>
</dependency>

Node.js

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

  1. Bevor Sie den OpenCensus-Kern und die Exporter-Bibliotheken installieren, müssen Sie Ihre Umgebung auf die Node.js-Entwicklung vorbereitet haben.
  2. Am einfachsten lässt sich OpenCensus mit npm: 
    npm install @opencensus/core
npm install @opencensus/exporter-stackdriver
  3. Platzieren Sie die unten aufgeführten require-Anweisungen am Anfang des Hauptskripts oder des Einstiegspunkts Ihrer Anwendung vor jedem anderen Code:
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Installieren Sie die OpenCensus-Kern- und Stackdriver-Exporter-Bibliotheken mithilfe der folgenden Befehl:

pip install -r opencensus/requirements.txt

Die Datei requirements.txt befindet sich im GitHub-Repository für diese Beispiele. python-docs-samples.

Benutzerdefinierte Messwerte mit OpenCensus schreiben

Die Instrumentierung Ihres Codes zur Verwendung von OpenCensus für Messwerte umfasst drei Schritte:

  1. Importieren Sie die OpenCensus-Statistiken und OpenCensus-Stackdriver-Exporter-Pakete.
  2. Initialisieren Sie den Stackdriver-Exporter.
  3. Verwenden Sie die OpenCensus API, um Ihren Code zu instrumentieren.

Das folgende Beispiel ist ein Minimalprogramm, das Messwertdaten mithilfe von OpenCensus. Das Programm führt eine Schleife aus und erfasst Latenzmesswerte. die Schleife abgeschlossen wird, exportiert sie die Statistiken nach Cloud Monitoring und wird beendet:

Go

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


// metrics_quickstart is an example of exporting a custom metric from
// OpenCensus to Stackdriver.
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"contrib.go.opencensus.io/exporter/stackdriver"
	"go.opencensus.io/stats"
	"go.opencensus.io/stats/view"
	"golang.org/x/exp/rand"
)

var (
	// The task latency in milliseconds.
	latencyMs = stats.Float64("task_latency", "The task latency in milliseconds", "ms")
)

func main() {
	ctx := context.Background()

	// Register the view. It is imperative that this step exists,
	// otherwise recorded metrics will be dropped and never exported.
	v := &view.View{
		Name:        "task_latency_distribution",
		Measure:     latencyMs,
		Description: "The distribution of the task latencies",

		// Latency in buckets:
		// [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
		Aggregation: view.Distribution(0, 100, 200, 400, 1000, 2000, 4000),
	}
	if err := view.Register(v); err != nil {
		log.Fatalf("Failed to register the view: %v", err)
	}

	// Enable OpenCensus exporters to export metrics
	// to Stackdriver Monitoring.
	// Exporters use Application Default Credentials to authenticate.
	// See https://developers.google.com/identity/protocols/application-default-credentials
	// for more details.
	exporter, err := stackdriver.NewExporter(stackdriver.Options{})
	if err != nil {
		log.Fatal(err)
	}
	// Flush must be called before main() exits to ensure metrics are recorded.
	defer exporter.Flush()

	if err := exporter.StartMetricsExporter(); err != nil {
		log.Fatalf("Error starting metric exporter: %v", err)
	}
	defer exporter.StopMetricsExporter()

	// Record 100 fake latency values between 0 and 5 seconds.
	for i := 0; i < 100; i++ {
		ms := float64(5*time.Second/time.Millisecond) * rand.Float64()
		fmt.Printf("Latency %d: %f\n", i, ms)
		stats.Record(ctx, latencyMs.M(ms))
		time.Sleep(1 * time.Second)
	}

	fmt.Println("Done recording metrics")
}

Java

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


import com.google.common.collect.Lists;
import io.opencensus.exporter.stats.stackdriver.StackdriverStatsExporter;
import io.opencensus.stats.Aggregation;
import io.opencensus.stats.BucketBoundaries;
import io.opencensus.stats.Measure.MeasureLong;
import io.opencensus.stats.Stats;
import io.opencensus.stats.StatsRecorder;
import io.opencensus.stats.View;
import io.opencensus.stats.View.Name;
import io.opencensus.stats.ViewManager;
import java.io.IOException;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Quickstart {
  private static final int EXPORT_INTERVAL = 70;
  private static final MeasureLong LATENCY_MS =
      MeasureLong.create("task_latency", "The task latency in milliseconds", "ms");
  // Latency in buckets:
  // [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
  private static final BucketBoundaries LATENCY_BOUNDARIES =
      BucketBoundaries.create(Lists.newArrayList(0d, 100d, 200d, 400d, 1000d, 2000d, 4000d));
  private static final StatsRecorder STATS_RECORDER = Stats.getStatsRecorder();

  public static void main(String[] args) throws IOException, InterruptedException {
    // Register the view. It is imperative that this step exists,
    // otherwise recorded metrics will be dropped and never exported.
    View view =
        View.create(
            Name.create("task_latency_distribution"),
            "The distribution of the task latencies.",
            LATENCY_MS,
            Aggregation.Distribution.create(LATENCY_BOUNDARIES),
            Collections.emptyList());

    ViewManager viewManager = Stats.getViewManager();
    viewManager.registerView(view);

    // Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
    // Exporters use Application Default Credentials to authenticate.
    // See https://developers.google.com/identity/protocols/application-default-credentials
    // for more details.
    StackdriverStatsExporter.createAndRegister();

    // Record 100 fake latency values between 0 and 5 seconds.
    Random rand = new Random();
    for (int i = 0; i < 100; i++) {
      long ms = (long) (TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS) * rand.nextDouble());
      System.out.println(String.format("Latency %d: %d", i, ms));
      STATS_RECORDER.newMeasureMap().put(LATENCY_MS, ms).record();
    }

    // The default export interval is 60 seconds. The thread with the StackdriverStatsExporter must
    // live for at least the interval past any metrics that must be collected, or some risk being
    // lost if they are recorded after the last export.

    System.out.println(
        String.format(
            "Sleeping %d seconds before shutdown to ensure all records are flushed.",
            EXPORT_INTERVAL));
    Thread.sleep(TimeUnit.MILLISECONDS.convert(EXPORT_INTERVAL, TimeUnit.SECONDS));
  }
}

Node.js

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

'use strict';

const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

const EXPORT_INTERVAL = process.env.EXPORT_INTERVAL || 60;
const LATENCY_MS = globalStats.createMeasureInt64(
  'task_latency',
  MeasureUnit.MS,
  'The task latency in milliseconds'
);

// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
const view = globalStats.createView(
  'task_latency_distribution',
  LATENCY_MS,
  AggregationType.DISTRIBUTION,
  [],
  'The distribution of the task latencies.',
  // Latency in buckets:
  // [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
  [0, 100, 200, 400, 1000, 2000, 4000]
);

// Then finally register the views
globalStats.registerView(view);

// Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
// Exporters use Application Default Credentials (ADCs) to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
// Expects ADCs to be provided through the environment as ${GOOGLE_APPLICATION_CREDENTIALS}
// A Stackdriver workspace is required and provided through the environment as ${GOOGLE_PROJECT_ID}
const projectId = process.env.GOOGLE_PROJECT_ID;

// GOOGLE_APPLICATION_CREDENTIALS are expected by a dependency of this code
// Not this code itself. Checking for existence here but not retaining (as not needed)
if (!projectId || !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
  throw Error('Unable to proceed without a Project ID');
}

// The minimum reporting period for Stackdriver is 1 minute.
const exporter = new StackdriverStatsExporter({
  projectId: projectId,
  period: EXPORT_INTERVAL * 1000,
});

// Pass the created exporter to Stats
globalStats.registerExporter(exporter);

// Record 100 fake latency values between 0 and 5 seconds.
for (let i = 0; i < 100; i++) {
  const ms = Math.floor(Math.random() * 5);
  console.log(`Latency ${i}: ${ms}`);
  globalStats.record([
    {
      measure: LATENCY_MS,
      value: ms,
    },
  ]);
}

/**
 * The default export interval is 60 seconds. The thread with the
 * StackdriverStatsExporter must live for at least the interval past any
 * metrics that must be collected, or some risk being lost if they are recorded
 * after the last export.
 */
setTimeout(() => {
  console.log('Done recording metrics.');
  globalStats.unregisterExporter(exporter);
}, EXPORT_INTERVAL * 1000);

Python

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


from random import random
import time

from opencensus.ext.stackdriver import stats_exporter
from opencensus.stats import aggregation
from opencensus.stats import measure
from opencensus.stats import stats
from opencensus.stats import view


# A measure that represents task latency in ms.
LATENCY_MS = measure.MeasureFloat(
    "task_latency", "The task latency in milliseconds", "ms"
)

# A view of the task latency measure that aggregates measurements according to
# a histogram with predefined bucket boundaries. This aggregate is periodically
# exported to Stackdriver Monitoring.
LATENCY_VIEW = view.View(
    "task_latency_distribution",
    "The distribution of the task latencies",
    [],
    LATENCY_MS,
    # Latency in buckets: [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
    aggregation.DistributionAggregation([100.0, 200.0, 400.0, 1000.0, 2000.0, 4000.0]),
)


def main():
    # Register the view. Measurements are only aggregated and exported if
    # they're associated with a registered view.
    stats.stats.view_manager.register_view(LATENCY_VIEW)

    # Create the Stackdriver stats exporter and start exporting metrics in the
    # background, once every 60 seconds by default.
    exporter = stats_exporter.new_stats_exporter()
    print('Exporting stats to project "{}"'.format(exporter.options.project_id))

    # Register exporter to the view manager.
    stats.stats.view_manager.register_exporter(exporter)

    # Record 100 fake latency values between 0 and 5 seconds.
    for num in range(100):
        ms = random() * 5 * 1000

        mmap = stats.stats.stats_recorder.new_measurement_map()
        mmap.measure_float_put(LATENCY_MS, ms)
        mmap.record()

        print(f"Fake latency recorded ({num}: {ms})")

    # Keep the thread alive long enough for the exporter to export at least
    # once.
    time.sleep(65)


if __name__ == "__main__":
    main()
Wenn diese Messwertdaten in Cloud Monitoring exportiert werden, können Sie sie wie alle anderen Daten verwenden.

Das Programm erstellt eine OpenCensus-Ansicht mit dem Namen task_latency_distribution. Diese Zeichenfolge wird Teil des den Namen der wenn er nach Cloud Monitoring exportiert wird. Unter Messwertdeskriptoren abrufen erfahren Sie, wie die OpenCensus-Ansicht als Cloud Monitoring-Messwertdeskriptor implementiert wird. Sie können daher den Ansichtsnamen als Suchstring verwenden, wenn Sie einen Messwert für ein Diagramm auswählen.

Wenn Sie das Beispielprogramm ausgeführt haben, können Sie den Metrics Explorer verwenden, um sehen Sie sich Ihre Daten an: <ph type="x-smartling-placeholder">
    </ph>

  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. Maximieren Sie im Element Messwert das Menü Messwert auswählen, geben Sie OpenCensus/task_latency_distribution in die Filterleiste ein und wählen Sie dann über die Untermenüs einen bestimmten Ressourcentyp und Messwert aus:
    1. Wählen Sie im Menü Aktive Ressourcen die überwachte Ressource aus. Wenn Sie das Programm in einer lokalen Umgebung ausführen, Wählen Sie dann Global aus.
    2. Wählen Sie im Menü Aktive Messwertkategorien die Option Benutzerdefiniert aus.
    3. Wählen Sie im Menü Aktive Messwerte die Option Latenzverteilung für Aufgaben aus.
    4. Klicken Sie auf Anwenden.

Der folgende Screenshot zeigt die Zeitreihen, die nach der Ausführung des in einer lokalen Umgebung:

Messwerte aus OpenCensus in Cloud Monitoring.

Jede Säule in der Heatmap repräsentiert einen einzelnen Programmdurchlauf. Die farbigen Komponenten jeder Säule stehen für Buckets in der Latenzverteilung.

OpenCensus-Messwerte in Cloud Monitoring lesen

Sie verwenden benutzerdefinierte Messwerte, einschließlich der von OpenCensus geschriebenen Messwerte, z. B. integrierten Metriken. Sie können Diagramme erstellen, Benachrichtigungen dafür einrichten, und sie auch anderweitig überwachen.

In diesem Abschnitt wird die Verwendung des APIs Explorer für folgende Aktionen beschrieben: Messdaten lesen zu können. Informationen zum Lesen von Messwertdaten mithilfe von der Cloud Monitoring API oder mithilfe von Clientbibliotheken folgende Dokumente:

Der Screenshot aus dem vorherigen Abschnitt aus dem Metrics Explorer. Wenn Sie Diagrammtools verwenden, sollten Sie Verwenden Sie den Namen der OpenCensus-Ansicht, um die Liste der Messwerte zu filtern. Weitere Informationen finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen

Messwertdeskriptoren abrufen

So rufen Sie die Messwertdaten direkt über die Monitoring API ab: müssen Sie die Cloud Monitoring-Namen in die die OpenCensus-Messwerte exportiert wurden. Sie können diese Namen indem Sie die vom Exporter erstellten Messwertdeskriptoren abrufen und dann sehen Sie sich das Feld type an. Weitere Informationen zu Messwertdeskriptoren finden Sie unter MetricDescriptor.

So rufen Sie die für die exportierten Messwerte erstellten Messwertdeskriptoren auf:

  1. Rufen Sie die Referenzseite metricDescriptors.list auf.

  2. Führen Sie im Widget API testen auf der Referenzseite die folgenden Schritte aus: Felder:

    1. Geben Sie den Namen Ihres Projekts in das Feld name ein. Verwenden Sie die Methode in der Namensstruktur projects/PROJECT_ID. In diesem Dokument wird ein Projekt mit der ID a-gcp-project verwendet.

    2. Geben Sie einen Filter in das Feld filter ein. Es gibt viele Messwerte, in einem Projekt verwenden. Mit Filtern können Sie diese entfernen, Beschreibungen, die nicht von Interesse sind.

      Das ist beispielsweise der Fall, weil der Name der OpenCensus-Ansicht Teil eines Messwertnamens verwenden, können Sie einen Filter wie diesen hinzufügen:

      metric.type=has_substring("task_latency_distribution")

      Der Schlüssel metric.type ist ein Feld in einem Typ, der in ein Zeitreihe. Weitere Informationen finden Sie unter TimeSeries.

    3. Klicken Sie auf Ausführen.

Hier sehen Sie den zurückgegebenen Messwertdeskriptor:

    {
      "metricDescriptors": [
        {
          "name": "projects/a-gcp-project/metricDescriptors/custom.googleapis.com/opencensus/task_latency_distribution",
          "labels": [
            {
              "key": "opencensus_task",
              "description": "Opencensus task identifier"
            }
          ],
          "metricKind": "CUMULATIVE",
          "valueType": "DISTRIBUTION",
          "unit": "ms",
          "description": "The distribution of the task latencies",
          "displayName": "OpenCensus/task_latency_distribution",
          "type": "custom.googleapis.com/opencensus/task_latency_distribution"
        }
      ]
    }

Diese Zeile im Messwertdeskriptor gibt den Namen des Messwerttyps in Cloud Monitoring an:

    "type": "custom.googleapis.com/opencensus/task_latency_distribution"

Sie haben jetzt alle erforderlichen Informationen, um die Daten manuell abzurufen. die mit dem Messwerttyp verknüpft sind. Der Wert des Feldes type ist ebenfalls in der Google Cloud Console angezeigt, wenn Sie den Messwert grafisch darstellen.

Messwertdaten abrufen

So rufen Sie Zeitreihendaten aus einem Messwerttyp manuell ab:

  1. Rufen Sie die Referenzseite für timeSeries.list auf.

  2. Führen Sie im Widget API testen auf der Referenzseite die folgenden Schritte aus: Felder:

    1. Geben Sie den Namen Ihres Projekts in das Feld name ein. Verwenden Sie die Methode in der Namensstruktur projects/PROJECT_ID.

    2. Geben Sie im Feld filter den folgenden Wert ein:

      metric.type="custom.googleapis.com/opencensus/task_latency_distribution"

    3. Geben Sie Werte in die Felder interval.startTime und interval.endTime ein. Diese Werte müssen als Zeitstempel eingegeben werden, z. B. 2018-10-11T15:48:38-04:00 Achten Sie darauf, dass der Wert für startTime früher ist als der Wert endTime.

    4. Klicken Sie auf die Schaltfläche Ausführen.

Hier sehen Sie das Ergebnis eines solchen Abrufs:

    {
      "timeSeries": [
        {
          "metric": {
            "labels": {
              "opencensus_task": "java-3424@docbuild"
            },
            "type": "custom.googleapis.com/opencensus/task_latency_distribution"
          },
          "resource": {
            "type": "gce_instance",
            "labels": {
              "instance_id": "2455918024984027105",
              "zone": "us-east1-b",
              "project_id": "a-gcp-project"
            }
          },
          "metricKind": "CUMULATIVE",
          "valueType": "DISTRIBUTION",
          "points": [
            {
              "interval": {
                "startTime": "2019-04-04T17:49:34.163Z",
                "endTime": "2019-04-04T17:50:42.917Z"
              },
              "value": {
                "distributionValue": {
                  "count": "100",
                  "mean": 2610.11,
                  "sumOfSquaredDeviation": 206029821.78999996,
                  "bucketOptions": {
                    "explicitBuckets": {
                      "bounds": [
                        0,
                        100,
                        200,
                        400,
                        1000,
                        2000,
                        4000
                      ]
                    }
                  },
                  "bucketCounts": [
                    "0",
                    "0",
                    "1",
                    "6",
                    "13",
                    "15",
                    "44",
                    "21"
                  ]
                }
              }
            }
          ]
        },
        [ ... data from additional program runs deleted ...]
      ]
    }

Die zurückgegebenen Messwertdaten umfassen Folgendes:

  • Informationen zu der überwachten Ressource, aus der die Daten erfasst wurden OpenCensus erkennt automatisch überwachte gce_instance-, k8s_container- und aws_ec2_instance-Ressourcen. Diese Daten stammen aus einem Programm, das auf einer Compute Engine-Instanz ausgeführt wurde. Weitere Informationen zur Verwendung anderer überwachter Ressourcen finden Sie unter Set monitored resource for exporter (Überwachte Ressource für Exporter festlegen).
  • Die Beschreibung der Art des Messwerts und des Typs der Werte.
  • Die tatsächlichen Datenpunkte, die innerhalb des angeforderten Zeitintervalls erfasst wurden.

So stellt Monitoring OpenCensus-Messwerte dar

Die direkte Verwendung der Cloud Monitoring API für benutzerdefinierte Messwerte wird unterstützt. wird beschrieben in Benutzerdefinierte Messwerte mit der API erstellen Der OpenCensus-Exporter für Cloud Monitoring verwendet diese API. Dieser Abschnitt enthält Informationen dazu, wie Cloud Monitoring stellt die von OpenCensus geschriebenen Messwerte dar.

Die von der OpenCensus API verwendeten Konstrukte unterscheiden sich von den von Cloud Monitoring und einige Begriffe. Wenn Cloud Monitoring auf "Messwerte" verweist, bezieht sich OpenCensus teilweise auf "Statistiken". Die Komponente von OpenCensus, die Messwertdaten an Cloud Monitoring sendet, wird beispielsweise als "stats exporter for Stackdriver" ("Exporteur von Statistiken für Stackdriver") bezeichnet.

Eine Übersicht über das OpenCensus-Modell für Messwerte finden Sie unter OpenCensus-Messwerte:

Die Datenmodelle für OpenCensus-Werte und Cloud Monitoring-Messwerte entsprechen einander nicht genau. Viele Konzepte existieren in beiden, aber sie sind nicht direkt austauschbar.

  • Eine OpenCensus-Ansicht ("view") entspricht dem MetricDescriptor in der Monitoring API. Eine Ansicht beschreibt, wie einzelne Messwerte erfasst und zusammengefasst werden. Tags bei allen aufgezeichneten Messungen berücksichtigt werden.

  • Ein OpenCensus-Tag ("tag") ist ein Schlüssel/Wert-Paar. Ein OpenCensus-Tag entspricht im Allgemeinen dem LabelDescriptor in der Monitoring API. Mit Tags können Sie Kontextinformationen erfassen, mit denen Sie zum Filtern und Gruppieren von Messwerten.

  • Eine OpenCensus-Kennzahl ("measure") beschreibt die aufzuzeichnenden Messwertdaten. Eine OpenCensus-Zusammenfassung ("aggregation") ist eine Funktion, die auf Daten angewendet wird, um sie zu aggregieren. Diese Funktionen werden beim Exportieren verwendet, um die MetricKind, ValueType und Einheit der im Cloud Monitoring-Messwertdeskriptor erfasst wird.

  • Ein OpenCensus-Messwert ("measurement") ist ein erfasster Datenpunkt. Messwerte müssen in Ansichten zusammengefasst werden. Andernfalls werden die einzelnen Messwerte gelöscht. Eine OpenCensus-Messung ist analog zu einem Point in der Monitoring API. Wenn Messwerte in Ansichten zusammengefasst werden, werden die aggregierten Daten als Ansichtsdaten gespeichert, analog zu einer TimeSeries in der Monitoring API.

Nächste Schritte