Benutzerdefinierte Messwerte mit der API erstellen

In diesem Dokument wird beschrieben, wie Sie benutzerdefinierte Messwerte erstellen und mithilfe der Cloud Monitoring API. Benutzerdefinierte Messwerte verwenden dieselben Elemente wie das integrierte Cloud Monitoring werden folgende Messwerte verwendet:

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

Benutzerdefinierte Messwerte, auch benutzerdefinierte Messwerte genannt, wie integrierte Messwerte verwendet werden können. Das heißt: können Sie Diagramme und Benachrichtigungen für diese Messwertdaten erstellen.

Logbasierte Messwerte sind eine Klasse benutzerdefinierter Messwerte, mit der Cloud Monitoring API erstellen. Logbasierte Messwerte leiten sich ab Messwertdaten aus Logeinträgen, aber die Monitoring API bietet keine Möglichkeit, anzugeben, wie Messwertdaten aus Logeinträgen extrahiert werden. Verwenden Sie stattdessen Cloud Logging, um logbasierte Messwerte zu erstellen. Wenn Sie Log-basierten Messwerts erstellt Logging die und sendet die Messwertdaten für Sie an Cloud Monitoring. Informationen zum Erstellen logbasierter Messwerte finden Sie in den folgenden Dokumenten:

• Zählermesswerte erstellen
• Verteilungsmesswerte erstellen

Zur Instrumentierung Ihrer Anwendung empfehlen wir die Verwendung einer anbieterneutrales, quelloffenes Instrumentierungsframework wie OpenTelemetry und nicht anbieter- und produktspezifischen APIs oder Clientbibliotheken. Informationen zur Instrumentierung Ihrer Anwendung finden Sie unter <ph type="x-smartling-placeholder"></ph> Instrumentierung und Beobachtbarkeit.

Hinweis: Benutzerdefinierte Messwerte sind eine kostenpflichtige Funktion von Cloud Monitoring und können Kosten für diese Messwerte anfallen. Preisinformationen finden Sie unter Cloud Monitoring-Preisübersicht.

Hinweise

Um mehr über die Strukturen zu erfahren, die allen Metriken zugrunde liegen, Siehe Messwerte, Zeitreihen und Ressourcen.

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

Benutzerdefinierten Messwerttyp erstellen

Um einen benutzerdefinierten Messwert zu erstellen, definieren Sie entweder einen Objekt MetricDescriptor der verschiedene Informationen zur Metrik angibt, oder Sie schreiben metrische Daten. Wenn Sie Messwertdaten schreiben, Monitoring erstellt den Messwertdeskriptor für Sie basierend auf die Struktur der von Ihnen bereitgestellten Daten. Informationen zum Erstellen eines Messwertdeskriptors finden Sie unter Messwertdeskriptoren für benutzerdefinierte Messwerte

Messwertdeskriptoren automatisch erstellen

Sie schreiben Messwertdaten, wenn ein Messwertdeskriptor für diesen benutzerdefinierten Messwert existiert, 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.

Cloud Monitoring erstellt eine neue MetricDescriptor, wenn TimeSeries-Objekt, das in einem Aufruf von timeSeries.create verweist auf einen Metric-Objekts, das eine nicht existierende Name des Messwerttyps. Cloud Monitoring verwendet die folgenden Regeln, um den Parameter MetricDescriptor:

• type: Der Typ wird aus dem Objekt Metric kopiert. type.
• name: Der Name wird aus der Projekt-ID im Methodenaufruf und aus dem Wert von type im Objekt Metric erstellt.
• labels: Die Labels, die im Objekt Metric angezeigt werden. Jeder Labeldeskriptor im neuen Messwertdeskriptor enthält folgende Felder:
  • key: Der Labelschlüssel im Objekt Metric.
  • valueType: STRING
  • description: Nicht definiert
• metricKind: Die Messwertart ist auf GAUGE festgelegt, sofern Sie nichts angeben. Der metricKind-Parameter des TimeSeries-Objekts. Wenn Sie metricKind angeben, geschieht Folgendes: der neue Messwert diesen Typ hat. Sie können nur angeben, GAUGE- und CUMULATIVE-Typen.
• valueType: Der Werttyp wird aus dem typisierten Wert des Point wird gerade geschrieben. Der Werttyp muss BOOL sein, INT64, DOUBLE oder DISTRIBUTION. Wenn Sie einen Werttyp in der valueType des TimeSeries Dieser Typ muss mit dem Typ von Point übereinstimmen.
• unit: Nicht definiert
• description: "Auto created custom metric.".
• displayName: Nicht definiert

In einem einzigen timeSeries.create-Aufruf können Sie mehrere TimeSeries-Objekte einschließen, die auf denselben nicht vorhandenen Messwerttyp verweisen. In diesem Fall Die Labels im neuen Messwertdeskriptor bestehen aus der Kombination aller Labels in den Metric-Objekten in allen Zeitreihen in diesem Aufruf von create.

Nächster Schritt: Siehe Benutzerdefinierte Messwerte schreiben.

Messwertdeskriptoren manuell erstellen

So erstellen Sie einen Messwertdeskriptor:

1. Ermitteln Sie die Struktur des Messwertdeskriptors. Hilfe bei der Erstellung können Sie die integrierten Messwerte durchsuchen und sehen sich die Zeitreihendaten an:

   1. Wählen Sie einen Messwertnamen für den benutzerdefinierten Messwerts.

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

   3. Wählen Sie ein oder mehrere Projekte aus, in denen der benutzerdefinierte Messwert definiert werden soll und schreiben ihre Zeitreihendaten. Wenn Sie denselben Messwert in mehreren Projekten benötigen, sollten Sie identische Messwerte verwenden. die Definitionen der Metrik in jedem Projekt.

      So schreiben Sie benutzerdefinierte Messwerte aus Ressourcen, die von einem AWS-Konto verwaltet werden: Erstellen Sie den Messwertdeskriptor in der AWS-Verbindungsprojekt für dieses Konto.

   4. Bestimmen Sie die Art, den Werttyp und (optional) die Einheiten des Messwerts. Nicht alle Wert- und Messwerttypen werden unterstützt für benutzerdefinierten Messwerten. Weitere Informationen zu diesen Feldern finden Sie unter Werttypen und Messwertarten:

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

2. Überwachte Ressourcen bestimmen, für die die Messwertdaten verwendet werden geschrieben. Wählen Sie eine der folgenden Optionen aus:

   • aws_ec2_instance: Amazon EC2-Instanz.
   • dataflow_job: Dataflow-Job.
   • gae_instance: App Engine-Instanz.
   • gce_instance: Compute Engine-Instanz.
   • generic_node: Vom Nutzer angegebener Rechenknoten.
   • generic_task: Benutzerdefinierte Aufgabe.
   • gke_container: GKE-Containerinstanz.
   • global: Verwenden Sie diese Ressource, wenn kein anderer Ressourcentyp geeignet sind. Für die meisten Anwendungsfälle sind generic_node oder generic_task bessere Entscheidungen als global.
   • k8s_cluster: Kubernetes-Cluster.
   • k8s_container: Kubernetes-Container.
   • k8s_node: Kubernetes-Knoten.
   • k8s_pod: Kubernetes-Pod.

3. Erstellen Sie ein MetricDescriptor-Objekt und übergeben Sie es als ein Argument zu einem Aufruf der metricDescriptors.create-Methode.

Beim Aufrufen von metricDescriptors.create mit demselben Typ als vorhandenen Messwertdeskriptor verwenden. Wenn jedoch alle Felder des neuen MetricDescriptor-Objekts mit den Feldern des vorhandenen Deskriptors exakt identisch sind, entsteht kein Fehler, aber der Vorgang ist wirkungslos.

Im folgenden Beispiel erstellen Sie einen Messwert vom Typ „Tachometer“.

Protokoll

Verwenden Sie zum Erstellen eines Messwertdeskriptors die Methode metricDescriptors.create. Sie können diese Methode mit dem APIs Explorer-Widget auf der Referenzseite der Methode. Siehe APIs Explorer für erhalten Sie weitere Informationen.

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": "GAUGE",
    "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:

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

Jetzt testen

Hinweis: Klicken Sie im APIs Explorer auf Vollbild, um die Anfrage als cURL-Befehl, als HTTP-Anfrage oder in JavaScript aufzurufen.

Wenn Sie einen neuen Messwert erstellen, wird das Feld name im MetricDescriptor wird ignoriert und kann weggelassen 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 zum Beispiel einen Messwertdeskriptor abrufen, verwenden Sie diesen Namen.

C#

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

        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

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

import (
	"context"
	"fmt"
	"io"

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

// 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: %w", err)
	}

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

Java

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

// Your Google Cloud Platform project ID
final String projectId = System.getProperty("projectId");

try (final MetricServiceClient client = MetricServiceClient.create();) {
  ProjectName projectName = ProjectName.of(projectId);

  MetricDescriptor descriptor =
      MetricDescriptor.newBuilder()
          .setType(type)
          .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(projectName.toString())
          .setMetricDescriptor(descriptor)
          .build();

  descriptor = client.createMetricDescriptor(request);
  System.out.println("Created descriptor " + descriptor.getName());
}

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.

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

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

use Google\Api\LabelDescriptor;
use Google\Api\MetricDescriptor;
use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\CreateMetricDescriptorRequest;

/**
 * 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 = 'projects/' . $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);
    $createMetricDescriptorRequest = (new CreateMetricDescriptorRequest())
        ->setName($projectName)
        ->setMetricDescriptor($descriptor);

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

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

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

# 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

Lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen, wenn Sie Schwierigkeitsgrad.

Nächster Schritt: Siehe Benutzerdefinierte Messwerte schreiben.

Benutzerdefinierte Messwerte 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 Zeitreihe vorhanden ist, hängt einen neuen Datenpunkt an die vorhandene Zeitachse an. Wenn der Parameter nicht vorhanden ist, wird sie mit dieser Methode erstellt und die Daten werden angehängt.

Zum Schreiben von Datenpunkten übergeben Sie eine Liste mit Objekten vom Typ TimeSeries an die Methode timeSeries.create. Die maximale Listengröße beträgt 200 und jedes Objekt in der Liste muss eine andere Zeitreihe angeben:

• Die Werte der Felder metric und resource geben einen bestimmten TimeSeries-Objekt. 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 jedem Punkt liegen, der bereits in der Zeitreihe.
  • Das Ende des Intervalls darf maximal 25 Stunden in der Vergangenheit oder fünf Minuten in der Zukunft liegen.

• Um mehr als einen Punkt in dieselbe Zeitachse zu schreiben, verwenden Sie einen separater Aufruf von timeSeries.create für jeden Punkt. Schreiben Sie Daten nicht schneller als 1 Punkt alle 5 Sekunden. Wenn Sie Daten hinzufügen auf verschiedene Zeitreihen verweist, gibt es keine Ratenbegrenzung.

Protokoll

Verwenden Sie zum Schreiben von Messwertdaten die Methode timeSeries.create. Sie können diese Methode mit dem APIs Explorer-Widget auf der Referenzseite der Methode. Siehe APIs Explorer .

Um einen Punkt in den Messwert stores/daily_sales zu schreiben, der im Messwertdeskriptoren manuell erstellen:

1. Rufen Sie die Referenzseite für timeSeries.create auf.
2. Geben Sie im APIs Explorer-Widget die unten aufgeführten Parameter 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 Zeitachse in der Liste enthalten.

  Hinweis: Die Werte project_id und endTime in dem folgenden Anfragetext müssen geändert werden. Verwenden Sie die ID Ihres Projekts. Das endTime muss nah an der aktuellen Uhrzeit liegen. date -Iseconds gibt den Fehlerwert die aktuelle Uhrzeit in einem brauchbaren Format.

  {
   "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

Hinweis: Klicken Sie im APIs Explorer auf Vollbild, um die Anfrage als cURL-Befehl, als HTTP-Anfrage oder in JavaScript aufzurufen.

C#

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

        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

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

// 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, %w ", err)
	}
	return nil
}

Java

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

String projectId = System.getProperty("projectId");

// 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
try (final MetricServiceClient client = MetricServiceClient.create();) {
  client.createTimeSeries(request);
}
System.out.println("Done writing time series value.");

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.

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

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

use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\CreateTimeSeriesRequest;
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 = 'projects/' . $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);
    $createTimeSeriesRequest = (new CreateTimeSeriesRequest())
        ->setName($projectName)
        ->setTimeSeries([$timeSeries]);

    $metrics->createTimeSeries($createTimeSeriesRequest);

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

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 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-c"
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

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

# 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."

Lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen, wenn Sie Schwierigkeitsgrad.

Benutzerdefinierte Messwerte löschen

Wenn Sie einen benutzerdefinierten Messwert löschen möchten, löschen Sie seinen Messwertdeskriptor. Sie können die in Ihrem Google Cloud-Projekt gespeicherten Zeitreihendaten nicht löschen. Allerdings Das Löschen des Messwertdeskriptors macht die Daten unzugänglich. Die Daten laufen ab und werden gemäß der Datenaufbewahrungsrichtlinie gelöscht.

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

Hinweis :Durch das Löschen eines Messwertdeskriptors wird die vorhandene Zeitachse erstellt. Daten unzugänglich sind. Wenn Sie einen gelöschten Messwertdeskriptor neu erstellen, genau wie vor dem Löschen, erhalten Sie möglicherweise wieder Zugriff auf die Daten. Verlassen Sie sich nicht auf dieses Verhalten.

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

Protokoll

Verwenden Sie zum Löschen eines Messwertdeskriptors die Methode metricDescriptors.delete. Sie können diese Methode mit dem APIs Explorer-Widget auf der Referenzseite der Methode. Siehe APIs Explorer .

So löschen Sie den Messwert stores/daily_sales, der in folgendem Ordner erstellt wurde: Messwertdeskriptoren manuell erstellen:

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

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

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

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

Jetzt testen

Hinweis: Klicken Sie im APIs Explorer auf Vollbild, um die Anfrage als cURL-Befehl, als HTTP-Anfrage oder in JavaScript aufzurufen.

C#

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

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

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

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
)

// 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: %w", err)
	}
	fmt.Fprintf(w, "Deleted metric: %q\n", name)
	return nil
}

Java

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

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

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.

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

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

use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\DeleteMetricDescriptorRequest;

/**
 * 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);
    $deleteMetricDescriptorRequest = (new DeleteMetricDescriptorRequest())
        ->setName($metricPath);
    $metrics->deleteMetricDescriptor($deleteMetricDescriptorRequest);

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

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 google.cloud import monitoring_v3

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

Ruby

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

# 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}."

Lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen, wenn Sie Schwierigkeitsgrad.

Benutzerdefinierten Messwert ändern

Um einen benutzerdefinierten Messwert zu ändern, müssen Sie den MetricDescriptor-Objekt, das den Messwert definiert. Die einzige unterstützte Änderung besteht im Hinzufügen von Labels.

Um einem vorhandenen benutzerdefinierten Messwert Labels hinzuzufügen, verwenden Sie die Methode timeSeries.create-Methode und schließen Sie das neue mit den Zeitreihendaten. Die Labels werden dem Messwert hinzugefügt. wenn die Labels, die Sie schreiben möchten, gültig sind, und die Gesamtzahl der Labels sind kleiner als 30.

Die Zeitachsendaten werden dann so geschrieben, als wäre das Label von Anfang an vorhanden gewesen.

Wenn Sie nicht nur neue Labels hinzufügen möchten, müssen Sie Labels löschen und neu erstellen den Messwertdeskriptor. In diesem Fall gehen alle Zeitachsendaten verloren, die zuvor für den alten Messwertdeskriptor erfasst wurden. Weitere Informationen finden Sie unter Löschen Sie benutzerdefinierte Messwerte, um weitere Informationen zu erhalten.

Messwerte können nicht umbenannt werden.

Nächste Schritte

• Messwertnutzung ansehen und verwalten
• Liste der integrierten Messwerte
• Liste der überwachten Ressourcen