Créer des métriques définies par l'utilisateur avec l'API

La création de métriques définies par l'utilisateur (également appelées métriques personnalisées) avec l'API Cloud Monitoring vous permet de capturer des mesures spécifiques à l'application, et de les représenter sous forme de graphique ou de créer des alertes, tout comme les métriques Cloud Monitoring intégrées. Comme les métriques intégrées, chaque métrique définie par l'utilisateur combine des points de données, un type de métrique qui définit ce que les points représentent et une ressource surveillée qui identifie l'origine des données.

Pour instrumenter votre application, nous vous recommandons d'utiliser un framework d'instrumentation Open Source neutre du point du vue du fournisseur, tel qu'OpenTelemetry, plutôt que des API spécifiques aux fournisseurs et aux produits ou des bibliothèques clientes. Pour en savoir plus sur ces frameworks, consultez Observabilité pour les développeurs d'applications et Choisir une approche d'instrumentation.

Vous ne pouvez pas utiliser l'API Monitoring pour créer des métriques basées sur les journaux, qui dérivent les données de métriques à partir des entrées de journal. À la place, Cloud Logging crée les structures de métriques et envoie les données à Cloud Monitoring pour vous. Consultez Créer des métriques de compteur et Créer des métriques de distribution.

Avant de commencer

Pour en savoir plus sur les structures qui sous-tendent toutes les métriques, consultez Métriques, séries temporelles et ressources.

Pour utiliser Cloud Monitoring, vous devez disposer d'un projet Google Cloud avec la facturation activée. Si nécessaire, procédez comme suit :

1. Dans la console Google Cloud , sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud .

   Rôles requis pour sélectionner ou créer un projet

   • Sélectionner un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
   • Créer un projet : pour créer un projet, vous devez disposer du rôle "Créateur de projet" (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.

   Accéder au sélecteur de projet

2. Vérifiez que la facturation est activée pour votre projet Google Cloud .

3. Assurez-vous que l'API Monitoring est activée. Pour en savoir plus, consultez la page Activer l'API Monitoring.
4. Pour les applications exécutées en dehors de Google Cloud, votre projet Google Cloud doit authentifier votre application à l'aide des Identifiants par défaut de l'application (ADC) locaux. Pour en savoir plus, consultez Configurer les ADC pour un fournisseur de services cloud sur site ou pour un autre fournisseur.

Créer un type de métrique défini par l'utilisateur

Pour créer une métrique définie par l'utilisateur, vous devez soit définir un objet MetricDescriptor qui spécifie diverses informations sur la métrique, soit écrire des données de métrique. Lorsque vous écrivez des données de métriques, Monitoring crée le descripteur de la métrique pour vous en fonction de la structure des données que vous fournissez. Pour en savoir plus sur la conception d'un descripteur de la métrique, consultez Descripteurs de métriques pour les métriques définies par l'utilisateur.

Création automatique de descripteurs de métriques

Si vous écrivez des données de métrique alors qu'un descripteur de la métrique pour cette métrique définie par l'utilisateur n'existe pas encore, un descripteur de la métrique est créé automatiquement. Toutefois, ce nouveau descripteur de la métrique peut ne pas correspondre exactement à ce que vous souhaitez. La création automatique de descripteurs de métriques implique certaines hypothèses et valeurs par défaut.

Cloud Monitoring crée un MetricDescriptor lorsque l'objet TimeSeries inclus dans un appel à timeSeries.create fait référence à un objet Metric qui spécifie un nom de type de métrique inexistant. Cloud Monitoring utilise les règles suivantes pour renseigner le champ MetricDescriptor :

• type : le type est copié à partir du champ type de l'objet Metric.
• name : le nom est créé à partir de l'ID du projet dans l'appel de méthode et de la valeur de type dans l'objet Metric.
• labels : étiquettes qui s'affichent dans l'objet Metric. Chaque descripteur de libellé du nouveau descripteur de métrique comporte les champs suivants :
  • key : clé de libellé dans l'objet Metric
  • valueType : STRING
  • description : non défini
• metricKind : le genre de métrique est défini sur GAUGE, sauf si vous spécifiez le paramètre metricKind de l'objet TimeSeries. Lorsque vous spécifiez metricKind, la nouvelle métrique est de ce genre. Vous ne pouvez spécifier que les types GAUGE et CUMULATIVE.
• valueType : le type de valeur est extrait de la valeur saisie de l'Point en cours d'écriture. Le type de valeur doit être BOOL, INT64, DOUBLE ou DISTRIBUTION. Lorsque vous spécifiez un type de valeur dans le champ valueType de TimeSeries, ce type doit correspondre au type de Point.
• unit : non défini
• description : "Auto created custom metric.".
• displayName : non défini

Vous pouvez, dans un seul appel timeSeries.create, inclure plusieurs objets TimeSeries faisant référence au même type de métrique inexistant. Dans ce cas, les étiquettes du nouveau descripteur de la métrique sont constituées de l'union de toutes les étiquettes des objets Metric de toutes les séries temporelles de cet appel à create.

Étape suivante : consultez Écrire des métriques définies par l'utilisateur.

Création manuelle de descripteurs de métriques

Pour créer un descripteur de la métrique, procédez comme suit :

1. Déterminez la structure de votre descripteur de la métrique. Pour vous aider à faire ces choix, vous pouvez parcourir les métriques intégrées et examiner leurs données de séries temporelles :

   1. Choisissez un nom de métrique pour votre métrique définie par l'utilisateur.

   2. Choisissez le nom à afficher et la description de votre métrique. Le nom à afficher est utilisé dans la console Google Cloud .

   3. Choisissez un ou plusieurs projets dans lesquels définir votre métrique définie par l'utilisateur et écrire ses données de série temporelle. Lorsque vous avez besoin de la même métrique dans plusieurs projets, créez des définitions identiques de la métrique dans chaque projet.

   4. Déterminez le type, le type de valeur et (facultatif) les unités de la métrique. Tous les types de valeurs et de métriques ne sont pas compatibles avec les métriques définies par l'utilisateur. Pour en savoir plus sur ces champs, consultez la page Types de valeurs et genres de métriques.

   5. Définissez les libellés de la métrique : noms, types de valeur et descriptions.

2. Déterminez les ressources surveillées sur lesquelles les données de métriques sont écrites. Faites votre choix dans la liste suivante :

   • aws_ec2_instance : instance Amazon EC2.
   • dataflow_job : job Dataflow.
   • gae_instance : instance App Engine.
   • gce_instance : instance Compute Engine.
   • generic_node : nœud de calcul spécifié par l'utilisateur.
   • generic_task : tâche définie par l'utilisateur.
   • gke_container : instance de conteneur GKE.
   • global : utilisez cette ressource lorsqu'aucun autre type de ressource ne convient. Pour la plupart des cas d'utilisation, generic_node ou generic_task sont de meilleurs choix que global.
   • k8s_cluster : cluster Kubernetes.
   • k8s_container : conteneur Kubernetes.
   • k8s_node : nœud Kubernetes.
   • k8s_pod : pod Kubernetes.

3. Créez un objet MetricDescriptor, puis transmettez-le en tant qu'argument à un appel de la méthode metricDescriptors.create.

L'appel de metricDescriptors.create avec le même nom de type qu'un descripteur de la métrique existant est généralement une erreur. Notez qu'une erreur ne survient pas si tous les champs du nouvel objet MetricDescriptor correspondent exactement aux champs du descripteur existant, mais l'appel n'a alors aucun effet.

Dans l'exemple suivant, vous allez créer une métrique de jauge.

Protocole

Pour créer un descripteur de la métrique, utilisez la méthode metricDescriptors.create. Vous pouvez exécuter cette méthode à l'aide du widget APIs Explorer sur la page de référence de la méthode. Pour en savoir plus, consultez APIs Explorer.

Voici des exemples de paramètres pour metricDescriptors.create :

• name (URL) : projects/[PROJECT_ID]

• Corps de la requête : fournissez un objet MetricDescriptor, comme suit :

  {
    "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."
      },
    ],
  }
  

Indiquez ces valeurs dans les champs du widget, en utilisant l'ID de votre projet à la place de [PROJECT_ID] :

Cliquez sur le bouton Execute (Exécuter) pour exécuter la méthode.

Essayer

Remarque : Pour afficher la requête sous forme de commande curl, de requête HTTP ou en JavaScript, cliquez sur Plein écran dans APIs Explorer.

Lors de la création d'une métrique, le champ name de MetricDescriptor est ignoré et peut être omis. La méthode create affiche le nouveau descripteur de métrique avec le champ name renseigné qui, dans cet exemple, se présente comme suit :

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

Par exemple, si vous souhaitez obtenir le descripteur d'une métrique, vous devez utiliser ce nom.

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

En cas de problème, consultez Résoudre les problèmes liés aux appels d'API.

Étape suivante : consultez Écrire des métriques définies par l'utilisateur.

Écrire des métriques définies par l'utilisateur

Vous ne pouvez écrire des données que dans des types de métriques définis par l'utilisateur. Pour écrire vos données, utilisez la méthode timeSeries.create. Lorsque la série temporelle existe, cette méthode ajoute un nouveau point de données à la série temporelle existante. Si la série temporelle n'existe pas, cette méthode la crée et ajoute les données.

Vous pouvez écrire des points de données en spécifiant une liste d'objets TimeSeries avec la méthode timeSeries.create. La taille maximale de la liste est de 200 objets, et chacun doit spécifier une série temporelle différente :

• Les valeurs des champs metric et resource identifient un objet TimeSeries spécifique. Ces champs représentent le type de métrique des données et la ressource surveillée à partir de laquelle les données ont été collectées.
• Il est inutile de renseigner les champs metricKind et valueType, car ils sont ignorés lors de l'écriture des points de données.

• Chaque objet TimeSeries ne doit contenir qu'un seul objet Point :

  • La valeur et l'intervalle de temps spécifiés pour le point doivent être cohérents avec la définition du type de métrique. Pour en savoir plus sur les intervalles de temps correspondant aux différents genres de métriques, consultez la page TimeInterval.
  • L'intervalle de temps du point doit être ultérieur à tout point déjà présent dans la série temporelle.
  • L'heure de fin de l'intervalle ne doit pas aller au-delà de 25 heures dans le passé ou de 5 minutes dans le futur.

• Pour écrire plusieurs points dans la même série temporelle, utilisez un appel distinct à la méthode timeSeries.create pour chaque point. N'écrivez pas de données dans une série temporelle unique plus rapidement qu'un point pour chaque tranche de 5 secondes. Lorsque vous ajoutez des points de données à différentes séries temporelles, il n'y a pas de limitation du débit.

Protocole

Pour écrire des données de métrique, utilisez la méthode timeSeries.create. Vous pouvez exécuter cette méthode à l'aide du widget APIs Explorer sur la page de référence de la méthode. Pour en savoir plus, consultez APIs Explorer.

Pour écrire un point dans la métrique stores/daily_sales créée dans Création manuelle de descripteurs de métriques :

1. Accédez à la page de référence sur timeSeries.create.
2. Indiquez les paramètres ci-dessous au widget APIs Explorer.
3. Cliquez sur le bouton Execute (Exécuter).

Utilisez les exemples de paramètres suivants :

• name : projects/[PROJECT_ID]

• Corps de la requête : incluez une liste d'objets TimeSeries. L'exemple suivant ne comporte qu'une seule série temporelle.

  Remarque : Vous devez modifier les valeurs project_id et endTime dans le corps de requête suivante. Utilisez l'ID de votre projet. La valeur endTime doit être proche de l'heure actuelle. date -Iseconds renvoie l'heure actuelle dans un format utilisable.

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

Essayer

Remarque : Pour afficher la requête sous forme de commande curl, de requête HTTP ou en JavaScript, cliquez sur Plein écran dans APIs Explorer.

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

En cas de problème, consultez Résoudre les problèmes liés aux appels d'API.

Supprimer des métriques définies par l'utilisateur

Pour supprimer une métrique définie par l'utilisateur, supprimez son descripteur de la métrique. Vous ne pouvez pas supprimer les données de séries temporelles stockées dans votre projet Google Cloud . Toutefois, la suppression du descripteur de la métrique rend les données inaccessibles. Les données expirent et sont supprimées conformément aux règles de conservation des données.

Vous ne pouvez pas supprimer le descripteur de la métrique d'une métrique intégrée.

Remarque : La suppression d'un descripteur de la métrique rend ses données de séries temporelles existantes inaccessibles. Si vous recréez un descripteur de la métrique supprimé, exactement tel qu'il était avant la suppression, vous pourrez peut-être récupérer l'accès aux données. Cette opération ne doit être envisagée qu'en dernier recours.

Pour supprimer votre descripteur de la métrique, appelez la méthode metricDescriptors.delete.

Protocole

Pour supprimer un descripteur de la métrique, utilisez la méthode metricDescriptors.delete. Vous pouvez exécuter cette méthode à l'aide du widget APIs Explorer sur la page de référence de la méthode. Pour en savoir plus, consultez APIs Explorer.

Pour supprimer la métrique stores/daily_sales créée dans Création manuelle de descripteurs de métriques :

1. Accédez à la page de référence de metricDescriptors.delete.

2. Indiquez le nom du descripteur de la métrique dans le widget APIs Explorer :

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

3. Cliquez sur le bouton Execute (Exécuter).

Essayer

Remarque : Pour afficher la requête sous forme de commande curl, de requête HTTP ou en JavaScript, cliquez sur Plein écran dans APIs Explorer.

C#

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de Monitoring, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

En cas de problème, consultez Résoudre les problèmes liés aux appels d'API.

Modifier une métrique définie par l'utilisateur

Pour modifier une métrique définie par l'utilisateur, vous devez mettre à jour l'objet MetricDescriptor qui définit la métrique. La seule modification possible est l'ajout de libellés.

Pour ajouter des étiquettes à une métrique existante définie par l'utilisateur, utilisez la méthode timeSeries.create et incluez les nouvelles étiquettes avec les données de séries temporelles. Les étiquettes sont ajoutées au descripteur de métrique lorsque les étiquettes que vous tentez d'écrire sont valides et que le nombre total d'étiquettes est inférieur à 30.

Les données de séries temporelles sont ensuite écrites comme si l'étiquette avait été présente depuis le début.

Si vous souhaitez effectuer d'autres opérations que l'ajout d'étiquettes, vous devez supprimer et recréer le descripteur de la métrique. Dans ce cas, vous perdez toutes les données de séries temporelles précédemment collectées pour l'ancien descripteur de la métrique. Pour en savoir plus, consultez Supprimer des métriques définies par l'utilisateur.

Vous ne pouvez pas renommer une métrique.

Étapes suivantes

• Affichez et gérez l'utilisation des métriques
• Liste des métriques intégrées
• Liste des ressources surveillées