Benutzerdefinierte Messwerte erstellen

Benutzerdefinierte Messwerte sind von Nutzern definierte Messwerte. 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.

Eine Einführung in die Strukturen, die sowohl den integrierten als auch den benutzerdefinierten Messwerten zugrunde liegen, finden Sie unter Messdaten, Zeitachsen und Ressourcen. Informationen zu den integrierten Messwerten finden Sie in der Messwertliste. Informationen zu den verfügbaren überwachten Ressourcen finden Sie in der Ressourcenliste.

Benutzerdefinierte Messwerte verwenden

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 API-Methode metricDescriptors.create verwenden, um ihn selbst zu erstellen.

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 Messwerttyp und verwenden ein Label mit dem Wert A oder B. 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 Messwerttyp, um die Anzahl der Aufrufe zu zählen, aber Sie nutzen kein Label, um aufzuzeichnen, 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 Messwertnamen

Beim Erstellen eines benutzerdefinierten Messwerts wird eine String-ID erstellt, die den Messwerttyp darstellt. Dieser String muss unter den benutzerdefinierten Messwerten in Ihrem Google Cloud-Projekt eindeutig sein. Er muss mit einem Präfix beginnen, das ihn als benutzerdefinierten Messwert kennzeichnet. Bei Monitoring werden nur custom.googleapis.com/ und external.googleapis.com/ unterstützt. Die Verwendung von Präfixen wird nicht unterstützt. Dem Präfix folgt ein Name, der beschreibt, was Sie erfassen. Weitere Informationen 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

Benutzerdefinierte Messwerttypen haben Ressourcennamen, die in allen Projekten bei allen Google Cloud-Ressourcen eindeutig sind. Das Format eines Ressourcennamens für einen Messwerttyp ist:

projects/[PROJECT_ID]/metricDescriptors/[METRIC_TYPE]

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

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.

Benutzerdefinierten Messwertdeskriptor definieren

Zum Erfassen benutzerdefinierter Messwertdaten müssen Sie ein MetricDescriptor-Objekt bereitstellen, mit dem verschiedene Informationen über den Messwert angegeben werden. Cloud Monitoring kann den Deskriptor automatisch für Sie erstellen. Weitere Informationen finden Sie unter Automatische Erstellung von Messwertdeskriptoren.

Wenn Sie den Messwertdeskriptor explizit erstellen möchten, benötigen Sie folgende Informationen:

  • Wählen Sie wie im vorherigen Abschnitt beschrieben eine ID für den benutzerdefinierten Messwerttyp aus.

  • Wählen Sie ein Projekt aus, in dem Sie den benutzerdefinierten Messwert festlegen und in das seine Zeitachsendaten geschrieben werden.

    Das verwendete Projekt muss außerdem zum Arbeitsbereich gehören, in dem Sie den Messwert beobachten. Wenn Sie denselben Messwert in mehreren Projekten benötigen, geben Sie in jedem Projekt dieselbe Definition dafür an.

    Benutzerdefinierte Messwerte für AWS sollten im AWS-Verbindungsprojekt für Ihr AWS-Konto erstellt werden.

  • 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 die Art, den Werttyp und optional Einheiten für den Messwert aus. Nicht alle Werttypen und Messwertarten werden für benutzerdefinierte Messwerte unterstützt. Siehe Werttypen und Messwertarten.

  • 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 anzeigen und sich ihre Zeitachsendaten ansehen.

Unter Messwertdeskriptoren manuell erstellen finden Sie auch Codebeispiele zum manuellen Erstellen eines Messwertdeskriptors.

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. Die Zeitachsen, in die Sie Daten schreiben, enthalten stattdessen einen Verweis auf den Messwerttyp, der die Daten beschreibt, und einen Verweis auf die überwachte Ressource, der den Ursprung der Daten angibt.

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 einem Deskriptor für einen benutzerdefinierten Messwerttyp zugeordnet sein. 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

Wenn Sie Messwertdaten in einen benutzerdefinierten Messwerttyp schreiben, der noch nicht existiert, wird automatisch ein neuer benutzerdefinierter 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

In einem einzigen timeSeries.create-Aufruf können Sie mehrere TimeSeries-Objekte einschließen, die auf denselben nicht vorhandenen benutzerdefinierten 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

Nachdem Sie die Informationen erfasst haben, die Sie zum Erstellen Ihres benutzerdefinierten Messwerttyps benötigen, rufen Sie die Methode metricDescriptors.create auf und übergeben Sie ein MetricDescriptor-Objekt. Weitere Informationen finden Sie unter Messwertdeskriptoren ändern.

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 mit den Feldern des vorhandenen Deskriptors identisch sind, wird kein Fehler zurückgegeben, aber der Vorgang ist wirkungslos.

Im folgenden Beispiel erstellen Sie einen benutzerdefinierten Messwert vom Typ "gauge": custom.googleapis.com/stores/daily_sales. Der Messwert enthält ein einzelnes Dimensionslabel namens store_id.

Protokoll

Verwenden Sie zum Erstellen eines Messwertdeskriptors die Methode metricDescriptors.create. Sie können diese Methode mithilfe des API Explorer-Widgets auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter API 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
	}
	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';

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}`);
});

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

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."
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. Es ist nicht möglich, die Zeitachsendaten aus Ihrem benutzerdefinierten Messwert zu löschen. Durch Löschen des Messwertdeskriptors werden die Daten jedoch unzugänglich. Die Daten laufen ab und werden gemäß der Datenaufbewahrungsrichtlinie gelöscht.

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 API Explorer-Widgets auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter API Explorer.

Sie können nur benutzerdefinierte Messwerttypen löschen.

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

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
	}
	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();

/**
 * 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);

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

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

Daten können nur in benutzerdefinierte Messwerttypen geschrieben werden. 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. Ist die Zeitachse nicht vorhanden, wird sie durch diese 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 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 API Explorer-Widgets auf der Referenzseite der Methode ausführen. Weitere Informationen finden Sie unter API 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 im API 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 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
	}
	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();

/**
 * 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);

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

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

Sie können auch timeSeries.create aufrufen, um neue Labels zu benutzerdefinierten Messwerten hinzuzufügen. Zum Hinzufügen von Labels zum benutzerdefinierten Messwertdeskriptor beziehen Sie diese Labels in die Zeitachsendaten ein.

Wenn das zu schreibende Label gültig ist und nicht dazu führt, dass die Anzahl der Labels im Messwertdeskriptor das Limit von zehn Labels überschreitet, wird das Label 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.

Ein Messwert kann nicht umbenannt werden.