Benutzerdefinierte Messwerte mit der API erstellen

Wenn Sie benutzerdefinierte Messwerte (auch benutzerdefinierte Messwerte genannt) mit der Cloud Monitoring API erstellen, können Sie anwendungsspezifische Messwerte erfassen und in Diagrammen darstellen oder Benachrichtigungen dafür einrichten, genau wie bei integrierten Cloud Monitoring-Messwerten. Wie integrierte Messwerte kombiniert jeder benutzerdefinierte Messwert Datenpunkte, einen Messwerttyp, der definiert, was die Punkte darstellen, und eine überwachte Ressource, die angibt, woher die Daten stammen.

Wir empfehlen, für die Instrumentierung Ihrer Anwendung ein anbieterneutrales als Open Source veröffentliches Instrumentierungs-Framework wie OpenTelemetry anstelle von anbieter- und produktspezifischen APIs oder Clientbibliotheken zu verwenden. Informationen zu diesen Frameworks finden Sie unter Beobachtbarkeit für Anwendungsentwickler und Instrumentierungsansatz auswählen.

Sie können die Monitoring API nicht verwenden, um logbasierte Messwerte zu erstellen, die Messwertdaten aus Logeinträgen ableiten. Stattdessen erstellt Cloud Logging die Messwertstrukturen und sendet die Daten für Sie an Cloud Monitoring. Weitere Informationen finden Sie unter Zählermesswerte erstellen und Verteilungsmesswerte erstellen.

Hinweis

Informationen zu den Strukturen, die allen Messwerten zugrunde liegen, finden Sie unter Messwerte, Zeitreihen und Ressourcen.

Wenn Sie Cloud Monitoring verwenden möchten, benötigen Sie ein Google Cloud -Projekt mit aktivierter Abrechnung. Gehen Sie bei Bedarf so vor:

  1. Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Projekt von Google Cloud aus oder erstellen Sie eines.

    Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

    • Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
    • Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Informationen zum Zuweisen von Rollen

    Zur Projektauswahl

  2. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud -Projekt aktiviert ist.

  3. Prüfen Sie, ob die Monitoring API aktiviert ist. Weitere Informationen finden Sie unter Monitoring-API aktivieren.
  4. Bei Anwendungen, die außerhalb von Google Cloudausgeführt werden, muss Ihr Google Cloud -Projekt Ihre Anwendung mit lokalen Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) authentifizieren. Weitere Informationen finden Sie unter ADC für lokale Umgebungen oder andere Cloud-Anbieter einrichten.

Benutzerdefinierten Messwerttyp erstellen

Wenn Sie einen benutzerdefinierten Messwert erstellen möchten, definieren Sie entweder ein MetricDescriptor-Objekt, das verschiedene Informationen zum Messwert angibt, oder Sie schreiben Messwertdaten. Wenn Sie Messwertdaten schreiben, erstellt Monitoring den Messwert-Deskriptor für Sie basierend auf der Struktur der von Ihnen bereitgestellten Daten. Informationen zum Entwerfen eines Messwert-Deskriptors finden Sie unter Messwert-Deskriptoren für benutzerdefinierte Messwerte.

Messwertdeskriptoren automatisch erstellen

Wenn Sie Messwertdaten schreiben, obwohl noch kein Messwertdeskriptor für diesen 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.

Cloud Monitoring erstellt einen neuen MetricDescriptor, wenn das in einem Aufruf von timeSeries.create enthaltene TimeSeries-Objekt auf ein Metric-Objekt verweist, das einen nicht vorhandenen Messwerttypnamen angibt. Cloud Monitoring verwendet die folgenden Regeln, um die MetricDescriptor zu füllen:

  • type: Der Typ wird aus dem Feld type des Metric-Objekts kopiert.
  • 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 Metric-Objekt 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 nicht den Parameter metricKind des Objekts TimeSeries angeben. Wenn Sie metricKind angeben, hat der neue Messwert diese Art. Sie können nur die Arten GAUGE und CUMULATIVE angeben.
  • valueType: Der Werttyp wird aus dem typisierten Wert des geschriebenen Point übernommen. Der Werttyp muss BOOL, INT64, DOUBLE oder DISTRIBUTION sein. Wenn Sie im Feld valueType des TimeSeries einen Werttyp angeben, muss dieser Typ mit dem Typ des 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 bestehen die Labels im neuen Messwertdeskriptor aus der Vereinigung aller Labels in den Metric-Objekten in allen Zeitreihen in diesem Aufruf von create.

Nächster Schritt: Benutzerdefinierte Messwerte schreiben.

Manuelle Erstellung von Messwertdeskriptoren

So erstellen Sie einen Messwertdeskriptor:

  1. Struktur des Messwert-Deskriptors bestimmen Wenn Sie Hilfe bei der Auswahl benötigen, können Sie die integrierten Messwerte durchsuchen und sich die zugehörigen Zeitreihendaten ansehen:

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

    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 Sie Ihren benutzerdefinierten Messwert definieren und die zugehörigen Zeitreihendaten schreiben möchten. Wenn Sie denselben Messwert in mehreren Projekten benötigen, erstellen Sie in jedem Projekt identische Definitionen des Messwerts.

    4. Legen Sie die Art, den Werttyp und optional die Einheiten des Messwerts fest. Nicht alle Werttypen und Messwertarten werden für benutzerdefinierte Messwerte unterstützt. 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. Bestimmen Sie die überwachten Ressourcen, für die die Messwertdaten geschrieben werden. Wählen Sie aus der folgenden Liste aus:

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

In der Regel ist es ein Fehler, metricDescriptors.create mit demselben Typnamen wie ein vorhandener Messwertdeskriptor aufzurufen. 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 Messgerät-Messwert.

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 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 wie das folgende an:

    {
  "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 im Widget ein und verwenden Sie dabei die ID Ihres Projekts anstelle von [PROJECT_ID]:

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

Klicken Sie auf den Button Ausführen, um die Methode auszuführen.

Jetzt testen

Beim Erstellen eines neuen Messwerts wird das Feld name in der MetricDescriptor 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 beispielsweise die Beschreibung eines Messwerts abrufen möchten, verwenden Sie diesen Namen.

C#

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC für eine lokale Entwicklungsumgebung einrichten. 

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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 Sie Probleme haben, lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen.

Nächster Schritt: 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, wird mit dieser Methode ein neuer Datenpunkt an die vorhandene Zeitreihe angehängt. Wenn die Zeitreihe 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 identifizieren ein bestimmtes 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 allen Punkten liegen, die bereits in der Zeitreihe vorhanden sind.
    • 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 Zeitreihe schreiben möchten, verwenden Sie für jeden Punkt einen separaten Aufruf der Methode timeSeries.create. Schreiben Sie Daten nicht schneller als einen Punkt alle 5 Sekunden in eine einzelne Zeitreihe. Wenn Sie Datenpunkte zu verschiedenen Zeitreihen hinzufügen, 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 ausführen. Weitere Informationen finden Sie unter APIs Explorer.

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

  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 den Button Ausführen.

Verwenden Sie folgende Beispielparameter:

  • Name: projects/[PROJECT_ID]

  • Anfragetext: Fügen Sie eine Liste von TimeSeries-Objekten ein. Das folgende Beispiel enthält nur eine Zeitreihe in der Liste.

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

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC für eine lokale Entwicklungsumgebung einrichten. 

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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 Sie Probleme haben, lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen.

Benutzerdefinierte Messwerte löschen

Wenn Sie einen benutzerdefinierten Messwert löschen möchten, löschen Sie den zugehörigen Messwertdeskriptor. Sie können die in Ihrem Google Cloud -Projekt gespeicherten Zeitreihendaten nicht löschen. Wenn Sie jedoch den Messwertdeskriptor löschen, sind die Daten nicht mehr zugänglich. Die Daten laufen gemäß den Richtlinien zur Datenaufbewahrung ab und werden gelöscht.

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

Rufen Sie zum Löschen des Messwert-Deskriptors die Methode metricDescriptors.delete auf.

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 ausführen. Weitere Informationen finden Sie unter APIs Explorer.

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

  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 den Button Ausführen.

Jetzt testen

C#

Richten Sie zur Authentifizierung bei Monitoring Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC 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 ADC für eine lokale Entwicklungsumgebung einrichten. 

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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 Sie Probleme haben, lesen Sie den Abschnitt Fehlerbehebung bei API-Aufrufen.

Benutzerdefinierten Messwert ändern

Wenn Sie einen benutzerdefinierten Messwert ändern möchten, müssen Sie das MetricDescriptor-Objekt aktualisieren, das den Messwert definiert. Die einzige unterstützte Änderung ist das Hinzufügen von Labels.

Wenn Sie Labels zu einem vorhandenen benutzerdefinierten Messwert hinzufügen möchten, verwenden Sie die Methode timeSeries.create und fügen Sie die neuen Labels den Zeitreihendaten hinzu. Die Labels werden dem Messwertdeskriptor hinzugefügt, wenn die Labels, die Sie schreiben möchten, gültig sind und die Gesamtzahl der Labels weniger als 30 beträgt.

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

Wenn Sie mehr als nur neue Labels hinzufügen möchten, müssen Sie den Messwertdeskriptor löschen und neu erstellen. In diesem Fall gehen alle Zeitreihendaten verloren, die zuvor für den alten Messwertdeskriptor erfasst wurden. Weitere Informationen finden Sie unter Benutzerdefinierte Messwerte löschen.

Messwerte können nicht umbenannt werden.

Nächste Schritte