Benutzerdefinierte Messwerte mit OpenCensus

Cloud Monitoring erfasst automatisch mehr als tausend integrierte Messwerte aus einer langen Liste überwachter Ressourcen. Diese Messwerte können jedoch keine anwendungsspezifischen Daten oder clientseitigen Systemdaten erfassen. Die Messwerte informieren über die Back-End-Latenz oder die Laufwerknutzung, geben jedoch keine Hinweise darauf, wie viele Hintergrundroutinen Ihre Anwendung erzeugt hat.

Mit anwendungsspezifischen Messwerten definieren und erfassen Sie Informationen außerhalb der integrierten Cloud Monitoring-Messwerte. Sie erfassen die Messwerte mit einer von einer Bibliothek bereitgestellten API, um Ihren Code zu instrumentieren, und senden sie dann an eine Back-End-Anwendung wie Cloud Monitoring.

In Cloud Monitoring werden anwendungsspezifische Messwerte normalerweise als "benutzerdefinierte Messwerte" bezeichnet. Diese Begriffe sind austauschbar. Es gibt auch die Bezeichnung "personalisierte Messwerte".

Was Cloud Monitoring betrifft, können benutzerdefinierte Messwerte wie die integrierten Messwerte verwendet werden. Sie können sie grafisch darstellen, Benachrichtigungen für sie festlegen und sie anderweitig überwachen. Der Unterschied besteht darin, dass Sie diese Messwerte definieren, sie mit Daten füllen und sie löschen können. Bei den integrierten Messwerten ist dies nicht möglich.

Es gibt viele Möglichkeiten, benutzerdefinierte Messwerte zu erfassen, einschließlich der direkten Verwendung der Cloud Monitoring API. Cloud Monitoring empfiehlt, dass Sie OpenCensus verwenden, um Ihren Code für das Erfassen benutzerdefinierter Messwerte zu instrumentieren.

Hinweis: Benutzerdefinierte Messwerte sind eine kostenpflichtige Funktion von Cloud Monitoring und es können Kosten für Ihre benutzerdefinierten Messwerte anfallen. Weitere Informationen zu den Preisen finden Sie im Abschnitt zu den Preisen für die Operations Suite von Google Cloud.

Was ist OpenCensus?

OpenCensus ist ein kostenloses Open-Source-Projekt. Dessen Bibliotheken bieten folgende Funktionen:

• Herstellerunabhängige Unterstützung für das Erfassen von Messwert- und Trace-Daten in verschiedenen Sprachen.
• Exportieren der gesammelten Daten in eine Vielzahl von Back-End-Anwendungen, einschließlich Cloud Monitoring.

Die aktuelle Liste der unterstützten Sprachen finden Sie unter Sprachunterstützung. Die aktuelle Liste der Back-End-Anwendungen, für die Exporter verfügbar sind, finden Sie unter Exporter.

Warum OpenCensus verwenden?

Obwohl Cloud Monitoring eine API bietet, die das Definieren und Erfassen benutzerdefinierter Messwerte unterstützt, handelt es sich dabei um eine Google-eigene untergeordnete API. OpenCensus bietet eine viel idiomatischere API sowie einen Exporter, der Ihre Messwertdaten über die Monitoring API an Cloud Monitoring sendet.

Außerdem ist OpenCensus ein Open-Source-Projekt. Sie können die erfassten Daten mithilfe einer herstellerneutralen Bibliothek anstelle einer proprietären Bibliothek exportieren.

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. Sie können eine einzige Bibliothekendistribution verwenden, um sowohl Messwert- als auch Trace-Daten von Ihren Diensten zu erfassen. Weitere Informationen zum Verwenden von OpenCensus mit Cloud Trace finden Sie unter Clientbibliotheken für Trace.

Hinweis

Sie benötigen ein Cloud-Projekt mit aktivierter Abrechnung, um Cloud Monitoring verwenden zu können.

Wenn Sie kein Cloud-Projekt haben, gehen Sie so vor:

1. Melden Sie sich bei Ihrem Google-Konto an.

   Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   Zur Projektauswahl

3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

4. Aktivieren Sie die Monitoring-API. Weitere Informationen finden Sie unter Monitoring-API aktivieren.
5. Wenn Ihre Anwendung außerhalb von Google Cloud ausgeführt wird, muss Ihre Anwendung von Ihrem Google Cloud-Projekt authentifiziert werden. Weitere Informationen finden Sie unter Erste Schritte bei der Authentifizierung.

So konfigurieren Sie einen Cloud Monitoring-Arbeitsbereich für Ihr Projekt:

1. Wählen Sie in der Cloud Console Ihr Google Cloud-Projekt aus.
   Zur Cloud Console
2. Wählen Sie im Navigationsbereich Monitoring aus.

   Wenn Sie Cloud Monitoring noch nie verwendet haben, wird beim ersten Zugriff auf Monitoring in der Google Cloud Console automatisch ein Arbeitsbereich erstellt und Ihr Projekt mit diesem Arbeitsbereich verknüpft. Wenn Ihr Projekt nicht mit einem Arbeitsbereich verknüpft ist, wird ein Dialogfeld angezeigt, in dem Sie entweder einen Arbeitsbereich erstellen oder dieses Projekt zu einem vorhandenen Arbeitsbereich hinzufügen können. Wir empfehlen, einen Arbeitsbereich zu erstellen. Klicken Sie nach der Auswahl auf Hinzufügen.

OpenCensus installieren

Sie müssen die Messwertbibliotheken und den Stackdriver-Exporter verfügbar machen, um OpenCensus verwenden zu können.

Go

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

Fügen Sie für Maven in Ihrer pom.xml-Datei Folgendes zum dependencies-Element hinzu:

Auf GitHub ansehen Feedback

<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-api</artifactId>
  <version>${opencensus.version}</version>
</dependency>
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-impl</artifactId>
  <version>${opencensus.version}</version>
</dependency>
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-exporter-stats-stackdriver</artifactId>
  <version>${opencensus.version}</version>
</dependency>

Node.js

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

   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:

Auf GitHub ansehen Feedback

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

Python

Installieren Sie die OpenCensus-Core- und Stackdriver-Exporter-Bibliothek mit dem folgenden Befehl:

pip install -r opencensus/requirements.txt

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

OpenCensus für Messwerte verwenden

Instrumentieren Sie Ihren Code für die Verwendung von OpenCensus für Messwerte in drei allgemeinen Schritten:

1. Importieren Sie die Pakete für OpenCensus-Statistiken und OpenCensus-Stackdriver-Exporter.
2. Initialisieren Sie den Stackdriver-Exporter.
3. Verwenden Sie die OpenCensus API zur Instrumentierung Ihres Codes.

Einfaches Beispiel

Es folgt ein kleines Programm, das diese Schritte veranschaulicht. In einer Schleife werden Latenzmesswerte gesammelt. Wenn die Schleife beendet ist, werden die Statistiken nach Cloud Monitoring exportiert, anschließend wird das Programm beendet:

Go

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

'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

Auf GitHub ansehen Feedback

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("Fake latency recorded ({}: {})".format(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. Dieser String wird Teil des Namens des Messwerts, wenn er in 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. Sie können ihn beispielsweise im Metrics Explorer im Feld Find resource type and metric (Ressourcentyp und Messwert suchen) eingeben. Der folgende Screenshot zeigt das Ergebnis:

Jede Säule in der Heatmap repräsentiert einen einzelnen Programmdurchlauf. Die farbigen Komponenten jeder Säule stehen für Buckets in der Latenzverteilung. Weitere Informationen zu den Daten, die dem Diagramm zugrunde liegen, finden Sie unter OpenCensus-Messwerte in Cloud Monitoring.

Dokumentation zu OpenCensus

OpenCensus stellt eine verbindliche Referenzdokumentation für die Messwert-API und den Stackdriver-Exporter zur Verfügung. Die folgende Tabelle enthält Links zu diesen Referenzdokumenten:

Sprache	API-Referenzdokumentation	Exporter-Dokumentation	Quickstart
Go	Go API	Statistiken- und Trace-Exporter	Messwerte
Java	Java API	Statistiken-Exporter	Messwerte
NodeJS	NodeJS API	Statistiken-Exporter	Messwerte
Python	Python API	Statistiken-Exporter	Messwerte

Modelle zuordnen

Die direkte Verwendung der Cloud Monitoring API für benutzerdefinierte Messwerte wird unterstützt. Ihre Verwendung wird unter Benutzerdefinierte Messwerte verwenden beschrieben. Der OpenCensus-Exporter für Cloud Monitoring verwendet diese API.

Auch wenn Sie die Besonderheiten der Verwendung der Cloud Monitoring API nicht kennen müssen, ist es hilfreich, die Konstrukte und die Terminologie zu verstehen, damit Sie wissen, wie Cloud Monitoring die Messwerte darstellt. Dieser Abschnitt enthält einige Hintergrundinformationen.

Sobald Ihre Messwerte in Cloud Monitoring aufgenommen wurden, werden sie in Cloud Monitoring-Konstrukten gespeichert. Sie können beispielsweise den Messwertdeskriptor – einen Typ aus der Monitoring API – eines benutzerdefinierten Messwerts abrufen. Weitere Informationen finden Sie unter MetricDescriptor. Sie begegnen diesen Messwertdeskriptoren beispielsweise, wenn Sie Diagramme für Ihre Daten erstellen.

Terminologie und Konzepte

Die von der OpenCensus API verwendeten Konstrukte unterscheiden sich von denen, die von Cloud Monitoring verwendet werden. Das gleiche gilt für einen Teil der Terminologie. 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 Messwerte von OpenCensus.

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 entspricht im Allgemeinen dem MetricDescriptor in der Monitoring API. Eine Ansicht beschreibt, wie einzelne Messwerte erfasst und zusammengefasst werden. Alle aufgezeichneten Messwerte werden nach Tags aufgeschlüsselt.

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

• 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 werden beim Exportieren verwendet, um MetricKind, ValueType und die Einheit zu ermitteln, die im Messwertdeskriptor von Cloud Monitoring beschrieben werden.

• Ein OpenCensus-Messwert ("measurement") ist ein Datenpunkt, der für die Messung erfasst wird. Messwerte müssen in Ansichten zusammengefasst werden. Andernfalls werden die einzelnen Messwerte gelöscht. Dieses Konstrukt entspricht 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.

OpenCensus-Messwerte in Cloud Monitoring

Sie können die exportierten Messwerte in Cloud Monitoring betrachten. Der Screenshot unter Einfaches Beispiel stammt aus dem Metrics Explorer. Wenn Sie das Beispielprogramm ausgeführt haben, können Sie den Metrics Explorer zum Anzeigen Ihrer Daten verwenden.

So rufen Sie mit Metrics Explorer die Messwerte für eine überwachte Ressource auf:

1. Wechseln Sie in der Google Cloud Console zu Monitoring oder verwenden Sie die folgende Schaltfläche:
   Zu Monitoring
2. Klicken Sie im Navigationsbereich von Monitoring auf Metrics Explorer .
3. Geben Sie den Namen der überwachten Ressource in das Textfeld Ressourcentyp und Messwert finden ein.

Wenn Sie den Messwert angeben, können Sie mit dem Namen der OpenCensus-Ansicht die Suche einschränken. Weitere Informationen finden Sie unter Messwerte auswählen.

Messwertdeskriptoren abrufen

Sie können die Messwertdaten mit der Monitoring API direkt abrufen. Zum Abrufen der Messwertdaten benötigen Sie die Cloud Monitoring-Namen, an die die OpenCensus-Messwerte exportiert wurden.

Eine Möglichkeit, diese Informationen abzurufen, ist, die vom Exporter erstellten Messwertdeskriptoren abzurufen und den Wert des Felds type zu ermitteln. Der Wert enthält den Namen der OpenCensus-Ansicht, aus der er exportiert wurde. Weitere Informationen zu Messwertdeskriptoren finden Sie unter MetricDescriptor.

Sie finden die für die exportierten Messwerte erstellten Messwertdeskriptoren mit dem Widget "API Explorer" (API testen) auf der Referenzseite der Methode metricDescriptors.list. So rufen Sie die Messwertdeskriptoren für die OpenCensus-Messwerte mithilfe dieses Tools ab:

1. Geben Sie den Namen Ihres Projekts in das Feld name ein: 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. Der Name der OpenCensus-Ansicht ist im Messwertnamen enthalten. Sie können diesen Namen verwenden, um die Auflistung einzuschränken. Geben Sie dazu einen Filter an:

   metric.type=has_substring("task_latency_distribution")

   In jedem Projekt gibt es viele Messwertdeskriptoren. Die meisten davon werden übersprungen, wenn Sie nach einem Teilstring aus dem Namen der OpenCensus-Ansicht filtern.

3. Klicken Sie auf die Schaltfläche Execute (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"

Mit dieser Information können Sie die Daten, die diesem Messwerttyp zugeordnet sind, manuell abrufen. Das sind auch die Daten, die in einem Diagramm für diesen Messwert angezeigt werden.

Messwertdaten abrufen

Zum manuellen Abrufen von Zeitachsendaten aus einem Messwerttyp können Sie das Tool API testen auf der Referenzseite für die Methode timeSeries.list verwenden:

1. Geben Sie den Namen Ihres Projekts in das Feld name ein: projects/[PROJECT_ID]
2. Geben Sie in das Feld filter einen Filter für den gewünschten Messwerttyp ein: metric.type="custom.googleapis.com/opencensus/task_latency_distribution"
   • Der Schlüssel metric.type ist ein Feld in einem Typ, der in eine Zeitachse eingebettet ist. Weitere Informationen finden Sie unter TimeSeries.
   • Der Wert ist der Wert type, der aus dem Messwertdeskriptor aus Messwertdeskriptoren abrufen extrahiert wird.
3. Geben Sie Zeitgrenzen für den Abruf ein. Geben Sie dazu Werte für diese Felder an:
   • interval.endTime als Zeitstempel. Beispiel: 2018-10-11T15:48:38-04:00
   • interval.startTime (muss vor interval.endTime liegen)
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 Daten umfassen hier:

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