Benutzerdefinierte Messwerte erstellen

Benutzerdefinierte Messwerte sind von Nutzern definierte Messwerte. Auf dieser Seite wird beschrieben, wie Sie Messwertdeskriptoren für benutzerdefinierte Messwerte erstellen und benutzerdefinierte Messwertdaten schreiben.

Für benutzerdefinierte Messwerte werden dieselben Elemente verwendet wie für die integrierten Cloud Monitoring-Messwerte:

  • Eine Reihe von Datenpunkten.
  • Informationen zum Messwerttyp, die Aufschluss darüber geben, für was die Datenpunkte stehen.
  • Informationen zu überwachten Ressourcen, die Aufschluss über den Ursprung der Datenpunkte geben.

Benutzerdefinierte Messwerte werden genauso verwendet wie integrierte Messwerte. Das heißt, Sie können Diagramme und Benachrichtigungen für Ihre benutzerdefinierten Messwertdaten erstellen.

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 Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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

      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. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

      Zur Projektauswahl

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

    6. Aktivieren Sie die Monitoring-API. Weitere Informationen finden Sie unter Monitoring-API aktivieren.

    7. Wenn Ihre Anwendung außerhalb von Google Cloud ausgeführt wird, muss Ihre Anwendung von Ihrem Google Cloud-Projekt authentifiziert werden. In der Regel konfigurieren Sie die Authentifizierung, indem Sie ein Dienstkonto für Ihr Projekt erstellen und eine Umgebungsvariable konfigurieren.

      Wenn Sie Ihre Anwendung auf einer Amazon Elastic Compute Cloud-Instanz (Amazon EC2) ausführen, erstellen Sie das Dienstkonto für das AWS-Connector-Projekt der Instanz.

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

  • Wenn Sie mit den Strukturen, die allen Messwerten zugrunde liegen, nicht vertraut sind, finden Sie weitere Informationen unter Messwerte, Zeitachsen und Ressourcen.

Erste Schritte mit benutzerdefinierten Messwerten

Zur Verwendung eines benutzerdefinierten Messwerts benötigen Sie einen Messwertdeskriptor für den neuen Messwerttyp. Der Messwertdeskriptor definiert, wie Ihre Daten organisiert sind. Bevor Sie benutzerdefinierte Messwertdaten schreiben, sollten Sie festlegen, wie Sie die erfassten Daten verwenden möchten, und prüfen, ob die Datenorganisation diese Ziele unterstützt.

Messwertdeskriptor erstellen

Sie können den Messwertdeskriptor von Cloud Monitoring automatisch erstellen lassen oder die Methode metricDescriptors.create in der Monitoring API verwenden, um ihn selbst zu erstellen. Sie können Messwertdeskriptoren nicht mithilfe der Google Cloud Console für Monitoring bearbeiten.

Damit Cloud Monitoring den Messwertdeskriptor automatisch erstellt, müssen Sie einfach Zeitachsendaten für Ihren Messwert schreiben. Cloud Monitoring erstellt dann auf Grundlage der geschriebenen Daten einen Deskriptor. Weitere Informationen finden Sie unter Messwertdeskriptoren automatisch erstellen. Für das automatischen Erstellen gelten gewisse Einschränkungen. Daher ist es hilfreich zu wissen, welche Informationen in eine Messwertdefinition einfließen. Nachdem Sie oder Stackdriver Monitoring einen neuen benutzerdefinierten Messwertdeskriptor erstellt haben, können den Messwertdeskriptor mit den API-Methoden des Messwertdeskriptors und den API-Methoden der Zeitachse verwenden.

Unabhängig davon, ob Sie den Messwertdeskriptor explizit erstellen oder von Monitoring basierend auf Ihren Daten für Sie erstellen lassen, müssen Sie immer sicherstellen, dass die Organisation der Daten den gewünschten Abfragen entspricht.

Daten organisieren

Angenommen, Sie haben ein Programm, das auf einer einzelnen Maschine ausgeführt wird, und das Programm ruft die Hilfsprogramme A und B auf. Sie möchten zählen, wie häufig Programme A und B aufgerufen werden. Sie möchten auch wissen, wann das Programm A mehr als zehnmal pro Minute aufgerufen wird und wenn das Programm B mehr als fünfmal pro Minute aufgerufen wird.

Gehen wir davon aus, dass Sie nur ein Google Cloud-Projekt haben und die überwachte Ressource global verwenden möchten, um die Diskussion zu vereinfachen. Weitere Informationen zu dieser Auswahl finden Sie unter Überwachte Ressourcen für benutzerdefinierte Messwerte.

Ziehen Sie die folgenden Ansätze in Betracht:

  • Sie verwenden zwei benutzerdefinierte Messwerttypen: Metric-type-A zählt die Aufrufe des Programms A und Metric-type-B zählt die Aufrufe für das Programm B. In diesem Fall enthalten Metric-type-A und Metric-type-B jeweils eine Zeitachse.

    Mit diesem Datenmodell können Sie eine einzelne Benachrichtigungsrichtlinie mit zwei Bedingungen oder zwei Benachrichtigungsrichtlinien mit jeweils einer Bedingung erstellen. Eine Benachrichtigungsrichtlinie kann mehrere Bedingungen unterstützen, hat aber eine einzige Konfiguration für die Benachrichtigungskanäle.

    Dieses Modell eignet sich möglicherweise, wenn Sie nicht an den Ähnlichkeiten der Daten zwischen den beobachteten Aktivitäten interessiert sind. In diesem Beispiel sind die Aktivitäten die Rate, nach der die Programme A und B aufgerufen werden.

  • Sie verwenden einen einzelnen benutzerdefinierten Messwert und ein Label zum Speichern einer Programmkennzeichnung. Das Label kann beispielsweise den Wert A oder B speichern. Da Monitoring eine Zeitachse für jede einmalige Kombination von Labels erstellt, gibt es zwei Zeitachsen für diesen einzelnen Messwerttyp.

    Wie beim vorherigen Modell können Sie eine einzelne Benachrichtigungsrichtlinie oder zwei Benachrichtigungsrichtlinien erstellen. Allerdings sind die Bedingungen für die Benachrichtigungsrichtlinie komplexer. Damit eine Bedingung erstellt wird, die einen Vorfall generiert, wenn die Häufigkeit von Aufrufen für das Programm A einen Schwellenwert überschreitet, muss die Bedingung einen Filter mit Datenpunkten enthalten, deren Labelwert A alle anderen Datenpunkte ausschließt.

    Ein Vorteil dieses Modells ist, dass die Berechnung von Verhältnissen einfach ist. Beispielsweise können Sie ermitteln, wie viel des Gesamtbetrags durch Aufrufe von A verursacht wird.

  • Sie verwenden einen einzelnen benutzerdefinierten Messwert, um die Anzahl der Aufrufe zu zählen, verwenden jedoch kein Label, um festzustellen, welches Programm aufgerufen wurde. In diesem Modell gibt es eine einzelne Zeitachse, in der die Daten für die beiden Programme kombiniert werden. Sie können jedoch keine Benachrichtigungsrichtlinie erstellen, die Ihren Zielen entspricht, da die Daten für zwei Programme nicht getrennt werden können.

Benutzerdefinierte Messwerte benennen

Definieren Sie beim Erstellen eines benutzerdefinierten Messwerts eine String-ID für den Messwerttyp. Dieser String muss unter den benutzerdefinierten Messwerten in Ihrem Google Cloud-Projekt eindeutig sein und muss ein Präfix verwenden, mit dem der Messwert als benutzerdefinierter Messwert gekennzeichnet wird. Die zulässigen Präfixe für Monitoring sind custom.googleapis.com/ und external.googleapis.com/prometheus. Das Präfix gefolgt von einem Namen, der beschreibt, was Sie erfassen. Weitere Informationen zur empfohlenen Benennung von benutzerdefinierten Messwerten finden Sie unter Namenskonventionen. Im Folgenden finden Sie Beispiele für die beiden Arten von IDs für Messwerttypen:

custom.googleapis.com/cpu_utilization
custom.googleapis.com/instance/cpu/utilization

Alle Messwerttypen haben global eindeutige Kennzeichnungen, die Ressourcennamen genannt werden. Die Struktur eines Ressourcennamens für einen Messwerttyp sieht so aus:

projects/[PROJECT_ID]/metricDescriptors/[METRIC_TYPE]

Dabei ist METRIC_TYPE die String-ID des Messwerttyps. Wenn die vorherigen benutzerdefinierten Messwertbeispiele im Projekt my-project-id erstellt wurden, würden ihre Ressourcennamen für diese Messwerte so aussehen:

projects/my-project-id/metricDescriptors/custom.googleapis.com/cpu_utilization
projects/my-project-id/metricDescriptors/custom.googleapis.com/instance/cpu/utilization

Name oder Typ? Im Messwertdeskriptor speichert das Feld name den Ressourcennamen des Messwerttyps und das Feld type speichert den String METRIC_TYPE.

Typ der überwachten Ressource auswählen

Wenn Sie Ihre Daten in eine Zeitachse schreiben, müssen Sie angeben, woher die Daten stammen. Dazu wählen Sie einen Ressourcentyp für die überwachte Ressource aus, der für den Ursprung der Daten steht, und verwenden ihn dann, um den Ursprung genauer zu beschreiben. Die überwachte Ressource ist nicht Teil des Messwerttyps. Stattdessen enthält die Zeitachse, in die Sie Daten schreiben, einen Verweis auf den Messwerttyp, der die Daten beschreibt, und einen Verweis auf die überwachte Ressource, der angibt, woher die Daten stammen.

Sehen Sie sich die überwachte Ressource genau an, bevor Sie den Messwertdeskriptor erstellen. Der verwendete Typ der überwachten Ressource wirkt sich darauf aus, welche Labels Sie in den Messwertdeskriptor aufnehmen müssen. Wenn Sie beispielsweise die überwachte Ressource einer VM-Instanz mit Ihren Daten verwenden, benötigen Sie zum Angeben der Instanz kein Messwertlabel. Weitere Informationen finden Sie unter Überwachte Ressourcen für benutzerdefinierte Messwerte.

Jeder Datenpunkt eines Messwerts muss mit dem Objekt einer überwachten Ressource verknüpft sein. Punkte aus verschiedenen überwachten Ressourcenobjekten werden in verschiedenen Zeitachsen gespeichert.

Überwachte Ressourcen für benutzerdefinierte Messwerte

Sie können in Ihren benutzerdefinierten Messwerten nur die folgenden Typen überwachter Ressourcen verwenden:

Häufig werden die überwachten Ressourcenobjekte verwendet, die die physischen Ressourcen repräsentieren, auf denen Ihr Anwendungscode ausgeführt wird. Dieser Ansatz bietet verschiedene Vorteile:

  • Sie erhalten eine bessere Leistung im Vergleich zur Verwendung eines einzelnen Ressourcentyps.
  • Sie vermeiden falsche Dateneinträge, die verursacht werden, wenn mehrere Prozesse in dieselbe Zeitachse schreiben.
  • Sie können die Daten Ihres benutzerdefinierten Messwerts mit anderen Messwertdaten aus derselben Ressource gruppieren.

global im Vergleich zu generischen Ressourcen

Die Ressourcentypen generic_task und generic_node sind in Situationen nützlich, in denen keiner der spezifischeren Ressourcentypen geeignet ist. Der Typ generic_task eignet sich zum Definieren von aufgabenähnlichen Ressourcen wie Anwendungen. Der Typ generic_node eignet sich zum Definieren knotenähnlicher Ressourcen wie virtuelle Maschinen. Beide generic_*-Typen haben mehrere allgemeine Labels, die Sie zur Definition eindeutiger Ressourcenobjekte verwenden können. Somit lassen sie sich bei Messwertfiltern ganz einfach für Aggregationen und Reduzierungen verwenden.

Im Gegensatz dazu hat der Ressourcentyp global nur die Labels project_id und location. Wenn in einem Projekt viele Quellen für Messwerte vorhanden sind, kann die Verwendung desselben global-Ressourcenobjekts zu Konflikten und Überschreibungen der Messwertdaten führen.

Messwertdeskriptoren erstellen

Die Daten, die Sie für einen benutzerdefinierten Messwert erfassen, müssen mit einem MetricDescriptor-Objekt verknüpft sein, das verschiedene Informationen zum Messwert angibt.

Sie können den Messwertdeskriptor selbst erstellen oder von Monitoring erstellen lassen.

Sie können einen vorhandenen Deskriptor bedingt ändern. Weitere Informationen finden Sie unter Messwertdeskriptoren ändern.

Messwertdeskriptoren automatisch erstellen

Falls Sie Messwertdaten schreiben, wenn noch kein Messwertdeskriptor für den benutzerdefinierten Messwert vorhanden ist, wird automatisch ein Messwertdeskriptor erstellt. Dieser neue Messwertdeskriptor entspricht jedoch vielleicht nicht Ihren Vorstellungen, da die automatische Erstellung von Messwertdeskriptoren auf verschiedenen Annahmen und Standardwerten basiert.

Das ist insbesondere während eines Aufrufs von timeSeries.create der Fall, wenn ein TimeSeries-Objekt ein Metric-Objekt enthält, das einen nicht vorhandenen Namen für einen Messwerttyp angibt. Cloud Monitoring erstellt dann einen neuen MetricDescriptor mit folgenden Feldern:

  • type: Der Typ wird aus dem Feld type des Objekts Metric kopiert.
  • name: Der Name wird aus der Projekt-ID im Methodenaufruf und aus dem Wert von type im Objekt Metric erstellt.
  • labels: Die Labels sind die im Objekt Metric angezeigten Labels. Jeder Labeldeskriptor im neuen Messwertdeskriptor enthält folgende Felder:
    • key: Der Labelschlüssel im Objekt Metric.
    • valueType: STRING
    • description: Nicht definiert
  • metricKind: Die Standardmesswertart ist GAUGE. Wenn Sie jedoch den Parameter metricKind des TimeSeries-Objekts angeben, ist der neue Messwert von dieser Art. Sie können als Art nur GAUGE oder CUMULATIVE festlegen.
  • valueType: Der Werttyp ergibt sich aus dem eingegebenen Wert des zu schreibenden Point-Objekts. Dieser muss BOOL, INT64, DOUBLE oder DISTRIBUTION sein. Wenn Sie im Feld valueType des TimeSeries-Objekts einen Werttyp angeben, muss er mit dem Typ des Point-Objekts übereinstimmen.
  • unit: Nicht definiert
  • description: "Auto created custom metric.".
  • displayName: Nicht definiert

Sie können in einem einzigen timeSeries.create-Aufruf mehrere TimeSeries-Objekte angeben, die auf denselben nicht vorhandenen Messwerttyp verweisen. In diesem Fall werden die Felder des neuen Typs auf dieselbe Weise festgelegt, mit der Ausnahme, dass die Labels im neuen Messwertdeskriptor die Gesamtheit aller Labels umfassen, die in den Metric-Objekten sämtlicher Zeitachsen in diesem Aufruf von create enthalten sind.

Nächster Schritt: Siehe Messwertdaten schreiben.

Messwertdeskriptoren manuell erstellen

In diesem Abschnitt wird beschrieben, wie Sie den Messwertdeskriptor für Ihren benutzerdefinierten Messwert erstellen.

Hinweis

Gehen Sie folgendermaßen vor:

  • Wählen Sie einen Namen oder eine ID des Messwerts für den benutzerdefinierten Messwert aus.

  • Wählen Sie einen Anzeigenamen und eine Beschreibung für den Messwert aus. Der Anzeigename wird in der Google Cloud Console verwendet.

  • Wählen Sie ein Projekt oder Projekte aus, in denen Sie den benutzerdefinierten Messwert festlegen und in die seine Zeitachsendaten geschrieben werden. Wenn Sie denselben Messwert in mehreren Projekten benötigen, geben Sie in jedem Projekt dieselbe Definition dafür an.

    Zum Schreiben benutzerdefinierter Messwerte aus Ressourcen, die von einem AWS-Konto verwaltet werden, erstellen Sie den Messwertdeskriptor im AWS-Connector-Projekt für dieses Konto.

  • Bestimmen Sie die Art, den Werttyp und (optional) die Messwerte. Nicht alle Werttypen und Messwertarten werden für benutzerdefinierte Messwerte unterstützt. Weitere Informationen zu diesen Feldern finden Sie unter Wert- und Messwerttypen.

  • Wählen Sie die Labels für den Messwert aus – den Namen, den Werttyp und die Beschreibung.

Zur Erleichterung der Auswahl können Sie die integrierten Messwerte durchsuchen und sich ihre Zeitachsendaten ansehen.

Messwertdeskriptor erstellen

Rufen Sie die Methode metricDescriptors.create auf und übergeben Sie ein MetricDescriptor-Objekt, um den Deskriptor für Ihren benutzerdefinierten Messwert zu erstellen.

Sie erhalten in der Regel einen Fehler, wenn Sie metricDescriptors.create mit demselben Typnamen wie für einen vorhandenen benutzerdefinierten Messwertdeskriptor aufrufen. Wenn jedoch alle Felder des neuen MetricDescriptor-Objekts genau mit den Feldern des vorhandenen Deskriptors übereinstimmen, stellt dies keinen Fehler dar, hat aber keine Auswirkungen.

Im folgenden Beispiel erstellen Sie einen benutzerdefinierten Messwert vom Typ „gauge”.

Protokoll

Verwenden Sie zum Erstellen eines Messwertdeskriptors die Methode metricDescriptors.create. Sie können diese Methode mithilfe des APIs Explorer auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter APIs Explorer.

Im Folgenden finden Sie die Beispielparameter für metricDescriptors.create:

  • Name (URL): projects/[PROJECT_ID]

  • Anfragetext: Geben Sie ein MetricDescriptor-Objekt an. Beispiel:

    {
  "name": "",
  "description": "Daily sales records from all branch stores.",
  "displayName": "Sales",
  "type": "custom.googleapis.com/stores/sales",
  "metricKind": "CUMULATIVE",
  "valueType": "DOUBLE",
  "unit": "{USD}",
  "labels": [
    {
      "key": "store_id",
      "valueType": "STRING",
      "description": "The ID of the store."
    },
  ],
}

Geben Sie diese Werte in die Felder des Widgets ein. Ersetzen Sie dabei [PROJECT_ID durch Ihre Projekt-ID:

Erstellen Sie einen Messwertdeskriptor mit diesem API-Dialogfeld, das mit dem Anfragetext gefüllt wurde.

Klicken Sie auf die Schaltfläche Ausführen, um die Methode auszuführen.

Jetzt testen

Beim Erstellen eines neuen benutzerdefinierten Messwerts wird das Feld name in MetricDescriptor ignoriert und kann ausgelassen werden. Die Methode create gibt den neuen Messwertdeskriptor mit einem Eintrag im Feld name zurück. Dieser würde im gegebenen Beispiel so lauten:

"name": "projects/[PROJECT_ID]/metricDescriptors/custom.googleapis.com/stores/daily_sales"

Wenn Sie beispielsweise den Deskriptor eines Messwerts abrufen möchten, verwenden Sie diesen Namen.

C#

        public static object CreateMetric(string projectId,
            string metricType = "custom.googleapis.com/stores/daily_sales")
        {
            // Create client.
            MetricServiceClient metricServiceClient = MetricServiceClient.Create();

            // Prepare custom metric descriptor.
            MetricDescriptor metricDescriptor = new MetricDescriptor();
            metricDescriptor.DisplayName = "Daily Sales";
            metricDescriptor.Description = "Daily sales records from all branch stores.";
            metricDescriptor.MetricKind = MetricKind.Gauge;
            metricDescriptor.ValueType = MetricDescriptor.Types.ValueType.Double;
            metricDescriptor.Type = metricType;
            metricDescriptor.Unit = "{USD}";
            LabelDescriptor labels = new LabelDescriptor();
            labels.Key = "store_id";
            labels.ValueType = LabelDescriptor.Types.ValueType.String;
            labels.Description = "The ID of the store.";
            metricDescriptor.Labels.Add(labels);
            CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
            {
                ProjectName = new ProjectName(projectId),
            };
            request.MetricDescriptor = metricDescriptor;
            // Make the request.
            MetricDescriptor response = metricServiceClient.CreateMetricDescriptor(request);
            Console.WriteLine("Done creating metric descriptor:");
            Console.WriteLine(JObject.Parse($"{response}").ToString());
            return 0;
        }

Go


import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"google.golang.org/genproto/googleapis/api/label"
	"google.golang.org/genproto/googleapis/api/metric"
	metricpb "google.golang.org/genproto/googleapis/api/metric"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// createCustomMetric creates a custom metric specified by the metric type.
func createCustomMetric(w io.Writer, projectID, metricType string) (*metricpb.MetricDescriptor, error) {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return nil, err
	}
	defer c.Close()
	md := &metric.MetricDescriptor{
		Name: "Custom Metric",
		Type: metricType,
		Labels: []*label.LabelDescriptor{{
			Key:         "environment",
			ValueType:   label.LabelDescriptor_STRING,
			Description: "An arbitrary measurement",
		}},
		MetricKind:  metric.MetricDescriptor_GAUGE,
		ValueType:   metric.MetricDescriptor_INT64,
		Unit:        "s",
		Description: "An arbitrary measurement",
		DisplayName: "Custom Metric",
	}
	req := &monitoringpb.CreateMetricDescriptorRequest{
		Name:             "projects/" + projectID,
		MetricDescriptor: md,
	}
	m, err := c.CreateMetricDescriptor(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("could not create custom metric: %v", err)
	}

	fmt.Fprintf(w, "Created %s\n", m.GetName())
	return m, nil
}

Java

// Your Google Cloud Platform project ID
String projectId = System.getProperty("projectId");
String metricType = CUSTOM_METRIC_DOMAIN + "/" + type;

final MetricServiceClient client = MetricServiceClient.create();
ProjectName name = ProjectName.of(projectId);

MetricDescriptor descriptor =
    MetricDescriptor.newBuilder()
        .setType(metricType)
        .addLabels(
            LabelDescriptor.newBuilder()
                .setKey("store_id")
                .setValueType(LabelDescriptor.ValueType.STRING))
        .setDescription("This is a simple example of a custom metric.")
        .setMetricKind(MetricDescriptor.MetricKind.GAUGE)
        .setValueType(MetricDescriptor.ValueType.DOUBLE)
        .build();

CreateMetricDescriptorRequest request =
    CreateMetricDescriptorRequest.newBuilder()
        .setName(name.toString())
        .setMetricDescriptor(descriptor)
        .build();

client.createMetricDescriptor(request);

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
async function createMetricDescriptor() {
  const request = {
    name: client.projectPath(projectId),
    metricDescriptor: {
      description: 'Daily sales records from all branch stores.',
      displayName: 'Daily Sales',
      type: 'custom.googleapis.com/stores/daily_sales',
      metricKind: 'GAUGE',
      valueType: 'DOUBLE',
      unit: '{USD}',
      labels: [
        {
          key: 'store_id',
          valueType: 'STRING',
          description: 'The ID of the store.',
        },
      ],
    },
  };

  // Creates a custom metric descriptor
  const [descriptor] = await client.createMetricDescriptor(request);
  console.log('Created custom Metric:\n');
  console.log(`Name: ${descriptor.displayName}`);
  console.log(`Description: ${descriptor.description}`);
  console.log(`Type: ${descriptor.type}`);
  console.log(`Kind: ${descriptor.metricKind}`);
  console.log(`Value Type: ${descriptor.valueType}`);
  console.log(`Unit: ${descriptor.unit}`);
  console.log('Labels:');
  descriptor.labels.forEach(label => {
    console.log(`  ${label.key} (${label.valueType}) - ${label.description}`);
  });
}
createMetricDescriptor();

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Api\LabelDescriptor;
use Google\Api\LabelDescriptor_ValueType;
use Google\Api\MetricDescriptor;
use Google\Api\MetricDescriptor_MetricKind;
use Google\Api\MetricDescriptor_ValueType;

/**
 * Create a new metric in Stackdriver Monitoring.
 * Example:
 * ```
 * create_metric($projectId);
 * ```
 *
 * @param string $projectId Your project ID
 */
function create_metric($projectId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $projectName = $metrics->projectName($projectId);

    $descriptor = new MetricDescriptor();
    $descriptor->setDescription('Daily sales records from all branch stores.');
    $descriptor->setDisplayName('Daily Sales');
    $descriptor->setType('custom.googleapis.com/stores/daily_sales');
    $descriptor->setMetricKind(MetricDescriptor_MetricKind::GAUGE);
    $descriptor->setValueType(MetricDescriptor_ValueType::DOUBLE);
    $descriptor->setUnit('{USD}');
    $label = new LabelDescriptor();
    $label->setKey('store_id');
    $label->setValueType(LabelDescriptor_ValueType::STRING);
    $label->setDescription('The ID of the store.');
    $labels = [$label];
    $descriptor->setLabels($labels);

    $descriptor = $metrics->createMetricDescriptor($projectName, $descriptor);
    printf('Created a metric: ' . $descriptor->getName() . PHP_EOL);
}

Python

from google.api import label_pb2 as ga_label
from google.api import metric_pb2 as ga_metric
from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
descriptor = ga_metric.MetricDescriptor()
descriptor.type = "custom.googleapis.com/my_metric" + str(uuid.uuid4())
descriptor.metric_kind = ga_metric.MetricDescriptor.MetricKind.GAUGE
descriptor.value_type = ga_metric.MetricDescriptor.ValueType.DOUBLE
descriptor.description = "This is a simple example of a custom metric."

labels = ga_label.LabelDescriptor()
labels.key = "TestLabel"
labels.value_type = ga_label.LabelDescriptor.ValueType.STRING
labels.description = "This is a test label"
descriptor.labels.append(labels)

descriptor = client.create_metric_descriptor(
    name=project_name, metric_descriptor=descriptor
)
print("Created {}.".format(descriptor.name))

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

descriptor = Google::Api::MetricDescriptor.new(
  type:        metric_type,
  metric_kind: Google::Api::MetricDescriptor::MetricKind::GAUGE,
  value_type:  Google::Api::MetricDescriptor::ValueType::DOUBLE,
  description: "This is a simple example of a custom metric."
)

result = client.create_metric_descriptor name:              project_name,
                                         metric_descriptor: descriptor
p "Created #{result.name}"
p result

Wenn Probleme auftreten, lesen Sie Fehler bei API-Aufrufen beheben.

Nächster Schritt: Siehe Messwertdaten schreiben.

Messwerte löschen

Löschen Sie den Messwertdeskriptor des benutzerdefinierten Messwerts, um diesen zu löschen. Sie können die Zeitachsendaten, die in Ihrem Google Cloud-Projekt gespeichert sind, nicht löschen. Das Löschen des Messwertdeskriptors macht jedoch den Zugriff auf die Daten unmöglich. Die Daten laufen ab und werden gemäß der Datenaufbewahrungsrichtlinie gelöscht.

Sie können den Messwertdeskriptor für einen integrierten Messwert nicht löschen.

Rufen Sie zum Löschen des benutzerdefinierten Messwertdeskriptors die Methode metricDescriptors.delete auf.

Protokoll

Verwenden Sie zum Löschen eines Messwertdeskriptors die Methode metricDescriptors.delete. Sie können diese Methode mithilfe des APIs Explorer auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter APIs Explorer.

So löschen Sie den benutzerdefinierten Messwert stores/daily_sales, den Sie unter Messwertdeskriptor manuell erstellen erstellt haben:

  1. Rufen Sie die Referenzseite für metricDescriptors.delete auf:

  2. Geben Sie den Namen des Messwertdeskriptors im APIs Explorer-Widget an:

    Name: projects/[PROJECT_ID]/metricDescriptors/custom.googleapis.com/stores/daily_sales

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

Jetzt testen

C#

public static object DeleteMetric(string projectId, string metricType)
{
    // Create client.
    MetricServiceClient metricServiceClient = MetricServiceClient.Create();
    // Initialize request argument(s).
    MetricDescriptorName name = new MetricDescriptorName(projectId, metricType);
    // Make the request.
    metricServiceClient.DeleteMetricDescriptor(name);
    Console.WriteLine($"Done deleting metric descriptor: {name}");
    return 0;
}

Go


import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// deleteMetric deletes the given metric. name should be of the form
// "projects/PROJECT_ID/metricDescriptors/METRIC_TYPE".
func deleteMetric(w io.Writer, name string) error {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return err
	}
	defer c.Close()
	req := &monitoringpb.DeleteMetricDescriptorRequest{
		Name: name,
	}

	if err := c.DeleteMetricDescriptor(ctx, req); err != nil {
		return fmt.Errorf("could not delete metric: %v", err)
	}
	fmt.Fprintf(w, "Deleted metric: %q\n", name)
	return nil
}

Java

String projectId = System.getProperty("projectId");
final MetricServiceClient client = MetricServiceClient.create();
MetricDescriptorName metricName = MetricDescriptorName.of(projectId, name);
client.deleteMetricDescriptor(metricName);
System.out.println("Deleted descriptor " + name);

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

async function deleteMetricDescriptor() {
  /**
   * TODO(developer): Uncomment and edit the following lines of code.
   */
  // const projectId = 'YOUR_PROJECT_ID';
  // const metricId = 'custom.googleapis.com/stores/daily_sales';

  const request = {
    name: client.projectMetricDescriptorPath(projectId, metricId),
  };

  // Deletes a metric descriptor
  const [result] = await client.deleteMetricDescriptor(request);
  console.log(`Deleted ${metricId}`, result);
}
deleteMetricDescriptor();

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;

/**
 * Example:
 * ```
 * delete_metric($projectId, $databaseId);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $metricId  The ID of the Metric Descriptor to delete
 */
function delete_metric($projectId, $metricId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $metricPath = $metrics->metricDescriptorName($projectId, $metricId);
    $ret = $metrics->deleteMetricDescriptor($metricPath);

    printf('Deleted a metric: ' . $metricPath . PHP_EOL);
}

Python

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
client.delete_metric_descriptor(name=descriptor_name)
print("Deleted metric descriptor {}.".format(descriptor_name))

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
metric_name = client.metric_descriptor_path project:           project_id,
                                            metric_descriptor: metric_type

client.delete_metric_descriptor name: metric_name
p "Deleted metric descriptor #{metric_name}."

Wenn Probleme auftreten, lesen Sie Fehler bei API-Aufrufen beheben.

Messwertdaten schreiben

Sie können Daten nur in Messwerttypen für benutzerdefinierte Messwerte schreiben. Verwenden Sie zum Schreiben von Daten die Methode timeSeries.create. Wenn die Zeitachse bereits vorhanden ist, hängt diese Methode einen neuen Datenpunkt an die vorhandene Zeitachse an. Wenn die Zeitachse nicht vorhanden ist, wird sie durch diese Methode erstellt und an die Daten angefügt.

Zum Schreiben von Datenpunkten übergeben Sie eine Liste mit Objekten vom Typ TimeSeries an die Methode timeSeries.create. Die Liste darf maximal 200 Objekte enthalten und jedes Objekt in der Liste muss eine andere Zeitachse angeben:

  • Jede Zeitachse wird durch die Felder metric und resource des TimeSeries-Objekts identifiziert. Diese Felder stellen den Messwerttyp der Daten und die überwachte Ressource dar, aus der die Daten erfasst wurden.
  • Lassen Sie die Felder metricKind und valueType weg. Sie werden beim Schreiben von Datenpunkten ignoriert.

  • Jedes TimeSeries-Objekt darf nur ein einziges Point-Objekt enthalten:

    • Der Wert und das Zeitintervall des Punkts müssen mit der Definition des Messwerttyps übereinstimmen. Informationen zu Zeitintervallen für unterschiedliche Messwertarten finden Sie unter TimeInterval.
    • Das Zeitintervall des Punkts muss nach allen bereits in der Zeitachse enthaltenen Punkten liegen.
    • Das Ende des Intervalls darf maximal 25 Stunden in der Vergangenheit oder fünf Minuten in der Zukunft liegen.

  • Wenn Sie mehr als einen Punkt in dieselbe Zeitachse schreiben möchten, verwenden Sie für jeden Punkt einen separaten Aufruf der Methode timeSeries.create. Schreiben Sie keine Daten in eine einzelne Zeitachse, die nicht schneller als ein Punkt alle 10 Sekunden sind. Wenn Sie Datenpunkte in unterschiedliche Zeitachsen einfügen, besteht keine zeitliche Einschränkung.

Protokoll

Verwenden Sie zum Schreiben von Messwertdaten die Methode timeSeries.create. Sie können diese Methode mithilfe des APIs Explorer auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter APIs Explorer.

So schreiben Sie einen Punkt in den benutzerdefinierten Messwert stores/daily_sales, der unter Messwertdeskriptoren manuell erstellen erstellt wurde:

  1. Rufen Sie die Referenzseite für timeSeries.create auf.
  2. Geben Sie die Parameter unten im APIs Explorer-Widget an.
  3. Klicken Sie auf die Schaltfläche Ausführen.

Verwenden Sie folgende Beispielparameter:

  • Name: projects/[PROJECT_ID]

  • Anfragetext: Fügen Sie eine Liste mit TimeSeries-Objekten hinzu. Im folgenden Beispiel ist nur eine einzige Zeitachse in der Liste enthalten.

    {
 "timeSeries": [
  {
   "metric": {
    "type": "custom.googleapis.com/my_metric",
    "labels": {
     "my_label": "my_value"
    }
   },
   "resource": {
    "type": "gce_instance",
    "labels": {
     "project_id": "[PROJECT_ID]",
     "instance_id": "1234567890123456789",
     "zone": "us-central1-f"
    }
   },
   "points": [
    {
     "interval": {
      "endTime": "2018-06-01T10:00:00-04:00"
     },
     "value": {
      "doubleValue": 123.45
     }
    }
   ]
  }
 ]
}

Jetzt testen

C#

        public static object WriteTimeSeriesData(string projectId)
        {
            // Create client.
            MetricServiceClient metricServiceClient = MetricServiceClient.Create();
            // Initialize request argument(s).
            ProjectName name = new ProjectName(projectId);
            // Prepare a data point.
            Point dataPoint = new Point();
            TypedValue salesTotal = new TypedValue();
            salesTotal.DoubleValue = 123.45;
            dataPoint.Value = salesTotal;
            Timestamp timeStamp = new Timestamp();
            timeStamp.Seconds = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;
            TimeInterval interval = new TimeInterval();
            interval.EndTime = timeStamp;
            dataPoint.Interval = interval;

            // Prepare custom metric.
            Metric metric = new Metric();
            metric.Type = "custom.googleapis.com/stores/daily_sales";
            metric.Labels.Add("store_id", "Pittsburgh");

            // Prepare monitored resource.
            MonitoredResource resource = new MonitoredResource();
            resource.Type = "global";
            resource.Labels.Add("project_id", projectId);

            // Create a new time series using inputs.
            TimeSeries timeSeriesData = new TimeSeries();
            timeSeriesData.Metric = metric;
            timeSeriesData.Resource = resource;
            timeSeriesData.Points.Add(dataPoint);

            // Add newly created time series to list of time series to be written.
            IEnumerable<TimeSeries> timeSeries = new List<TimeSeries> { timeSeriesData };
            // Write time series data.
            metricServiceClient.CreateTimeSeries(name, timeSeries);
            Console.WriteLine("Done writing time series data:");
            Console.WriteLine(JObject.Parse($"{timeSeriesData}").ToString());
            return 0;
        }

Go


// writeTimeSeriesValue writes a value for the custom metric created
func writeTimeSeriesValue(projectID, metricType string) error {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return err
	}
	defer c.Close()
	now := &timestamp.Timestamp{
		Seconds: time.Now().Unix(),
	}
	req := &monitoringpb.CreateTimeSeriesRequest{
		Name: "projects/" + projectID,
		TimeSeries: []*monitoringpb.TimeSeries{{
			Metric: &metricpb.Metric{
				Type: metricType,
				Labels: map[string]string{
					"environment": "STAGING",
				},
			},
			Resource: &monitoredres.MonitoredResource{
				Type: "gce_instance",
				Labels: map[string]string{
					"instance_id": "test-instance",
					"zone":        "us-central1-f",
				},
			},
			Points: []*monitoringpb.Point{{
				Interval: &monitoringpb.TimeInterval{
					StartTime: now,
					EndTime:   now,
				},
				Value: &monitoringpb.TypedValue{
					Value: &monitoringpb.TypedValue_Int64Value{
						Int64Value: rand.Int63n(10),
					},
				},
			}},
		}},
	}
	log.Printf("writeTimeseriesRequest: %+v\n", req)

	err = c.CreateTimeSeries(ctx, req)
	if err != nil {
		return fmt.Errorf("could not write time series value, %v ", err)
	}
	return nil
}

Java

String projectId = System.getProperty("projectId");
// Instantiates a client
MetricServiceClient metricServiceClient = MetricServiceClient.create();

// Prepares an individual data point
TimeInterval interval =
    TimeInterval.newBuilder()
        .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))
        .build();
TypedValue value = TypedValue.newBuilder().setDoubleValue(123.45).build();
Point point = Point.newBuilder().setInterval(interval).setValue(value).build();

List<Point> pointList = new ArrayList<>();
pointList.add(point);

ProjectName name = ProjectName.of(projectId);

// Prepares the metric descriptor
Map<String, String> metricLabels = new HashMap<>();
Metric metric =
    Metric.newBuilder()
        .setType("custom.googleapis.com/my_metric")
        .putAllLabels(metricLabels)
        .build();

// Prepares the monitored resource descriptor
Map<String, String> resourceLabels = new HashMap<>();
resourceLabels.put("instance_id", "1234567890123456789");
resourceLabels.put("zone", "us-central1-f");

MonitoredResource resource =
    MonitoredResource.newBuilder().setType("gce_instance").putAllLabels(resourceLabels).build();

// Prepares the time series request
TimeSeries timeSeries =
    TimeSeries.newBuilder()
        .setMetric(metric)
        .setResource(resource)
        .addAllPoints(pointList)
        .build();

List<TimeSeries> timeSeriesList = new ArrayList<>();
timeSeriesList.add(timeSeries);

CreateTimeSeriesRequest request =
    CreateTimeSeriesRequest.newBuilder()
        .setName(name.toString())
        .addAllTimeSeries(timeSeriesList)
        .build();

// Writes time series data
metricServiceClient.createTimeSeries(request);
System.out.println("Done writing time series value.");

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

async function writeTimeSeriesData() {
  /**
   * TODO(developer): Uncomment and edit the following lines of code.
   */
  // const projectId = 'YOUR_PROJECT_ID';

  const dataPoint = {
    interval: {
      endTime: {
        seconds: Date.now() / 1000,
      },
    },
    value: {
      doubleValue: 123.45,
    },
  };

  const timeSeriesData = {
    metric: {
      type: 'custom.googleapis.com/stores/daily_sales',
      labels: {
        store_id: 'Pittsburgh',
      },
    },
    resource: {
      type: 'global',
      labels: {
        project_id: projectId,
      },
    },
    points: [dataPoint],
  };

  const request = {
    name: client.projectPath(projectId),
    timeSeries: [timeSeriesData],
  };

  // Writes time series data
  const result = await client.createTimeSeries(request);
  console.log('Done writing time series data.', result);
}
writeTimeSeriesData();

PHP

use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Cloud\Monitoring\V3\Point;
use Google\Cloud\Monitoring\V3\TimeInterval;
use Google\Cloud\Monitoring\V3\TimeSeries;
use Google\Cloud\Monitoring\V3\TypedValue;
use Google\Protobuf\Timestamp;

/**
 * Example:
 * ```
 * write_timeseries($projectId);
 * ```
 *
 * @param string $projectId Your project ID
 */
function write_timeseries($projectId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $projectName = $metrics->projectName($projectId);

    $endTime = new Timestamp();
    $endTime->setSeconds(time());
    $interval = new TimeInterval();
    $interval->setEndTime($endTime);

    $value = new TypedValue();
    $value->setDoubleValue(123.45);

    $point = new Point();
    $point->setValue($value);
    $point->setInterval($interval);
    $points = [$point];

    $metric = new Metric();
    $metric->setType('custom.googleapis.com/stores/daily_sales');
    $labels = ['store_id' => 'Pittsburg'];
    $metric->setLabels($labels);

    $resource = new MonitoredResource();
    $resource->setType('global');
    $labels = ['project_id' => $projectId];
    $resource->setLabels($labels);

    $timeSeries = new TimeSeries();
    $timeSeries->setMetric($metric);
    $timeSeries->setResource($resource);
    $timeSeries->setPoints($points);

    $result = $metrics->createTimeSeries(
        $projectName,
        [$timeSeries]);

    printf('Done writing time series data.' . PHP_EOL);
}

Python

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"

series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/my_metric" + str(uuid.uuid4())
series.resource.type = "gce_instance"
series.resource.labels["instance_id"] = "1234567890123456789"
series.resource.labels["zone"] = "us-central1-f"
series.metric.labels["TestLabel"] = "My Label Data"
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
    {"end_time": {"seconds": seconds, "nanos": nanos}}
)
point = monitoring_v3.Point({"interval": interval, "value": {"double_value": 3.14}})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

series = Google::Cloud::Monitoring::V3::TimeSeries.new
series.metric = Google::Api::Metric.new type: metric_type

resource = Google::Api::MonitoredResource.new type: "global"
resource.labels["project_id"] = project_id
series.resource = resource

point = Google::Cloud::Monitoring::V3::Point.new
point.value = Google::Cloud::Monitoring::V3::TypedValue.new double_value: 3.14
now = Time.now
end_time = Google::Protobuf::Timestamp.new seconds: now.to_i, nanos: now.nsec
point.interval = Google::Cloud::Monitoring::V3::TimeInterval.new end_time: end_time
series.points << point

client.create_time_series name: project_name, time_series: [series]
p "Time series created."

Wenn Probleme auftreten, lesen Sie Fehler bei API-Aufrufen beheben.

Messwertdeskriptoren ändern

Verwenden Sie die Methode timeSeries.create, um Labels zu einem vorhandenen benutzerdefinierten Messwert hinzuzufügen, und fügen Sie die neuen Labels in die Zeitachsendaten ein. Wenn die Labels, die Sie schreiben möchten, gültig sind und nicht dazu führen, dass die Anzahl der Labels im Messwertdeskriptor das Labellimit von 30 überschreitet, werden die Labels hinzugefügt. Die Zeitachsendaten werden dann so geschrieben, als wäre das Label von Anfang an vorhanden gewesen.

Wenn Sie neben dem Hinzufügen neuer Labels noch andere Vorgänge ausführen möchten, müssen Sie den Messwertdeskriptor löschen und neu erstellen. In diesem Fall gehen alle Zeitachsendaten verloren, die zuvor für den alten Messwertdeskriptor erfasst wurden. Weitere Informationen finden Sie unter Messwerte löschen.

Sie können einen Messwert nicht umbenennen.

Nächste Schritte

  • Informationen zu den integrierten Messwerten finden Sie in der Messwertliste.
  • Informationen zu den verfügbaren überwachten Ressourcen finden Sie in der Ressourcenliste.