Créer des métriques personnalisées

Les métriques personnalisées sont des métriques définies par les utilisateurs. Cette page explique comment créer des descripteurs de métriques personnalisées et comment écrire des données de métriques personnalisées.

Elles utilisent les mêmes éléments que les métriques Cloud Monitoring intégrées:

  • Un ensemble de points de données
  • Des informations sur les types de métriques, qui vous indiquent ce que les points de données représentent
  • Des informations sur les ressources surveillées, qui vous indiquent l'origine des points de données

Les métriques personnalisées peuvent être utilisées de la même manière que les métriques intégrées. En d'autres termes, vous pouvez créer des graphiques et des alertes pour vos données de métriques personnalisées.

Avant de commencer

Si vous ne connaissez pas les structures sous-jacentes de toutes les métriques, consultez la page Métriques, séries temporelles et ressources.

Premiers pas avec les métriques personnalisées

Pour utiliser une métrique personnalisée, vous devez disposer d'un descripteur de métrique pour votre nouveau type de métrique. Le descripteur de la métrique définit l'organisation de vos données. Avant de commencer à écrire des données de métriques personnalisées, déterminez comment vous souhaitez utiliser les données que vous collectez et assurez-vous que l'organisation des données respecte ces objectifs.

Créer un descripteur de métrique

Cloud Monitoring peut créer automatiquement le descripteur de métrique, ou vous pouvez utiliser la méthode metricDescriptors.create de l'API Monitoring pour le créer vous-même. Vous ne pouvez pas manipuler les descripteurs de métriques à l'aide de Google Cloud Console pour Monitoring.

Pour que Cloud Monitoring crée le descripteur de métrique à votre place, il vous suffit d'écrire des données de séries temporelles pour votre métrique. Cloud Monitoring crée un descripteur basé sur les données que vous écrivez. Pour en savoir plus, consultez la section Créer automatiquement des descripteurs de métrique. Comme la création automatique présente des limites, il est utile de savoir quelles informations une définition de métrique contient. Une fois un descripteur de métrique personnalisée créé, que ce soit par vous ou par Monitoring, vous pouvez l'utiliser à l'aide des méthodes API de descripteurs de métriques et des méthodes API de séries temporelles.

Que vous créiez explicitement le descripteur de métrique ou que Monitoring le crée à votre place en fonction de vos données, vous devez toujours vous assurer que l'organisation des données correspond à la manière dont vous souhaitez les interroger.

Organiser vos données

Supposons que vous disposiez d'un programme qui s'exécute sur une seule machine et que ce programme appelle les programmes auxiliaires A et B. Vous souhaitez comptabiliser la fréquence d'appel des programmes A et B. Vous souhaitez également savoir quand le programme A est appelé plus de 10 fois par minute et que le programme B est appelé plus de 5 fois par minute.

Pour simplifier la discussion, supposons que vous ayez un seul projet Google Cloud et que vous prévoyiez d'utiliser la ressource surveillée global. Pour plus d'informations sur ce choix, consultez la section Ressources surveillées pour les métriques personnalisées.

Voici quelques exemples d'approches :

  • Vous utilisez deux métriques personnalisées: Metric-type-A comptabilise les appels au programme A et Metric-type-B comptabilise les appels au programme B. Dans ce cas, Metric-type-A contient une série temporelle et Metric-type-B contient une série temporelle.

    Avec ce modèle de données, vous pouvez créer une règle d'alerte unique avec deux conditions ou deux règles d'alerte chacune avec une condition. Une règle d'alerte peut accepter plusieurs conditions, mais elle possède une configuration unique pour les canaux de notification.

    Ce modèle peut être approprié lorsque vous n'êtes pas intéressé par des similitudes entre les données des activités surveillées. Dans cet exemple, les activités correspondent au taux d'appels aux programmes A et B.

  • Vous stockez les identifiants d'un programme à l'aide d'une seule métrique personnalisée et d'un libellé. Par exemple, le libellé peut stocker la valeur A ou B. Monitoring crée une série temporelle pour chaque combinaison unique de libellés. Il existe deux séries temporelles pour ce type de métrique unique.

    Comme avec le modèle précédent, vous pouvez créer une ou deux règles d'alerte. Cependant, les conditions de la règle d'alerte sont plus complexes. Pour créer une condition qui génère un incident si le taux d'appels du programme A dépasse un seuil, la condition doit inclure un filtre qui inclut des points de données dont la valeur du libellé est A et exclut tous les autres points de données.

    L'un des avantages de ce modèle est qu'il facilite le calcul des ratios. Par exemple, vous pouvez déterminer la somme totale due aux appels à A.

  • Vous utilisez une seule métrique personnalisée pour comptabiliser le nombre d'appels, mais vous n'utilisez pas de libellé pour enregistrer le programme qui a été appelé. Dans ce modèle, il existe une seule série temporelle qui combine les données des deux programmes. Cependant, vous ne pouvez pas créer une règle d'alerte qui répond à vos objectifs, car les données de deux programmes ne peuvent pas être séparées.

Nommer les métriques personnalisées

Lorsque vous créez une métrique personnalisée, vous définissez un identifiant de chaîne qui représente le type de métrique. Cette chaîne doit être unique parmi les métriques personnalisées de votre projet Google Cloud et utiliser un préfixe qui la marque comme étant une métrique définie par l'utilisateur. Pour Monitoring, les préfixes autorisés sont custom.googleapis.com/ et external.googleapis.com/prometheus. Le préfixe est suivi d'un nom qui décrit ce que vous collectez. Pour en savoir plus sur la méthode recommandée pour nommer une métrique personnalisée, consultez la section Conventions d'attribution de noms. Voici des exemples des deux genres d'identifiants employés pour les types de métriques :

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

Tous les types de métriques ont des identifiants uniques appelés noms de ressources. La structure d'un nom de ressource pour un type de métrique est la suivante:

projects/[PROJECT_ID]/metricDescriptors/[METRIC_TYPE]

METRIC_TYPE est l'identifiant de chaîne du type de métrique. En supposant que les exemples de métriques personnalisées précédents ont été créés dans le projet my-project-id, leurs noms de ressource pour ces métriques seraient les suivants:

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

Nom ou type ? Dans le descripteur de métrique, le champ name enregistre le nom de ressource du type de métrique et le champ type enregistre la chaîne METRIC_TYPE.

Sélectionner un type de ressource surveillée

Lorsque vous écrivez vos données dans une série temporelle, vous devez indiquer leur origine. Pour ce faire, vous devez choisir un type de ressource surveillée qui représente l'origine de vos données, puis l'utiliser pour décrire l'origine spécifique. La ressource surveillée ne fait pas partie du type de métrique. La série temporelle dans laquelle vous écrivez des données inclut une référence au type de métrique, qui décrit les données et une référence à la ressource surveillée, qui indique l'origine des données.

Examinez la ressource surveillée avant de créer votre descripteur de métrique. Le type de ressource surveillée que vous utilisez a une incidence sur les libellés que vous devez inclure dans le descripteur de métrique. Par exemple, si vous utilisez une ressource surveillée d'instance de VM avec vos données, vous n'avez pas besoin d'un libellé de métrique pour spécifier l'instance. Pour plus d'informations, consultez la page Ressources surveillées pour les métriques personnalisées.

Chacun des points de données de votre métrique doit être associé à un objet de type "ressource surveillée". Les points de données des différents objets de type "ressource surveillée" sont stockés dans des séries temporelles distinctes.

Ressources surveillées pour les métriques personnalisées

Pour vos métriques personnalisées, vous ne pouvez utiliser que les types de ressources surveillées suivants :

Une pratique courante consiste à utiliser les objets de type "ressource surveillée" représentant les ressources physiques sur lesquelles le code de votre application est exécuté. Cette approche présente plusieurs avantages :

  • Vous obtenez de meilleures performances par rapport à l'utilisation d'un seul type de ressource.
  • Vous évitez les données hors service causées par plusieurs processus écrivant dans la même série temporelle.
  • Vous pouvez regrouper vos données de métriques personnalisées avec d'autres données de métriques provenant des mêmes ressources.

Ressource de type global et ressources génériques

Les types de ressources generic_task et generic_node sont utiles lorsqu'aucun des types de ressources plus spécifiques n'est approprié. Le type generic_task sert à définir des ressources de type "tâche", telles que des applications. Le type generic_node sert à définir des ressources de type "nœud", telles que des machines virtuelles. Les deux types generic_* ont plusieurs libellés communs dont vous pouvez vous servir pour définir des objets de ressource uniques. Cela facilite leur utilisation dans les filtres de métriques pour les agrégations et les réductions.

En revanche, le type de ressource global ne dispose que des libellés project_id et location. Si vous avez plusieurs sources de métriques dans un projet, l'utilisation du même objet de ressource global peut provoquer des conflits et des écrasements de vos données de métriques.

Créer des descripteurs de métrique

Les données collectées pour une métrique personnalisée doivent être associées à un objet MetricDescriptor qui spécifie diverses informations sur la métrique.

Vous pouvez créer vous-même ce descripteur ou laisser Monitoring s'en charger.

Les modifications que vous pouvez apporter à un descripteur existant sont limitées. Pour plus d'informations, consultez la section Modifier des descripteurs de métrique.

Créer automatiquement des descripteurs de métrique

Si vous écrivez des données de métrique lorsqu'un descripteur de métrique pour cette métrique personnalisée n'existe pas, un descripteur de métrique est automatiquement créé. Toutefois, ce nouveau descripteur pourrait ne pas ressembler exactement à ce que vous imaginiez. La création automatique de descripteurs de métrique implique certaines hypothèses et certains paramètres par défaut.

Plus spécifiquement, lorsque vous appelez la méthode timeSeries.create, si un objet TimeSeries inclut un objet Metric indiquant un nom de type de métrique inexistant, Cloud Monitoring crée un objet MetricDescriptor avec les champs suivants :

  • type : le type est copié à partir du champ Metric de l'objet type.
  • 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 : il s'agit des libellés qui apparaissent 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 par défaut est GAUGE. Toutefois, si vous spécifiez le paramètre metricKind de l'objet TimeSeries, la nouvelle métrique sera alors du même genre. Vous ne pouvez spécifier que les genres GAUGE et CUMULATIVE.
  • valueType : le type de valeur provient de la valeur de l'objet Point en cours d'écriture. Il doit correspondre à BOOL, INT64, DOUBLE ou DISTRIBUTION. Si vous spécifiez un type de valeur dans le champ valueType de l'objet TimeSeries, ce type doit correspondre à celui de l'objet 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 champs du nouveau type sont définis de la même manière, si ce n'est que les libellés du nouveau descripteur de métrique consistent en l'union de tous les libellés des objets Metric de l'ensemble des séries temporelles de cet appel de la méthode create.

Étape suivante : consultez la section Écrire des données de métrique.

Créer manuellement des descripteurs de métrique

Cette section explique comment créer le descripteur de votre métrique personnalisée.

Avant de commencer

Procédez comme suit :

  • Choisissez le nom ou l'identifiant de la métrique pour la métrique personnalisée.

  • Choisissez un nom à afficher et une description pour votre métrique. Le nom à afficher est utilisé dans Google Cloud Console.

  • Choisissez un ou plusieurs projets dans lesquels définir la métrique personnalisée et écrire les données de la série temporelle. Si vous avez besoin de la même métrique pour plusieurs projets, définissez-la à l'identique dans chaque projet.

    Pour écrire des métriques personnalisées à partir de ressources gérées par un compte AWS, créez le descripteur de métrique dans le projet de connecteur AWS pour ce compte.

  • Déterminez le genre, le type de valeur et (facultatif) les unités de la métrique. Tous les genres de métrique et types de valeur ne sont pas compatibles avec les métriques personnalisées. Pour en savoir plus sur ces champs, consultez la section Types de valeurs et genres de métriques.

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

Pour obtenir de l'aide dans ces choix, vous pouvez parcourir les métriques intégrées et consulter leurs données de séries temporelles.

Créer un descripteur de métrique

Pour créer le descripteur de votre métrique personnalisée, appelez la méthode metricDescriptors.create, en transmettant un objet MetricDescriptor.

Appeler metricDescriptors.create en utilisant le même nom de type qu'un descripteur de métrique personnalisée existant renvoie généralement une erreur. Notez qu'il ne s'agit pas d'une erreur, si tous les champs du nouvel objet MetricDescriptor correspondent exactement aux champs du descripteur existant, mais cela n'a aucun effet.

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

Protocole

Pour créer un descripteur de 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 la page Utiliser l'API Explorer.

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

  • name (URL) : projects/[PROJECT_ID]
  • Corps de la requête : fournissez un objet MetricDescriptor tel que :

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

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

Boîte de dialogue "Essayer cette API" incluant le corps de la requête de création d'un descripteur de métrique.

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

Essayer

Lorsque vous créez une métrique personnalisée, le champ name dans l'objet 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, vous pouvez utiliser ce nom si vous avez besoin d'obtenir un descripteur de métrique.

C#

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

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

Go


import (
	"context"
	"fmt"
	"io"

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

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

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

Java

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

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

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

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

client.createMetricDescriptor(request);

Node.js

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

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

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

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

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

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

Ruby

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

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

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

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

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

Consultez la section Dépanner l'API Monitoring si vous rencontrez des difficultés.

Étape suivante : consultez la section Écrire des données de métrique.

Supprimer des métriques

Pour supprimer une métrique personnalisée, supprimez son descripteur de 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 métrique les rend inaccessibles. Les données ont un délai d'expiration et sont supprimées conformément à la règle de conservation des données.

Vous ne pouvez pas supprimer le descripteur de métrique intégrée.

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

Protocole

Pour supprimer un descripteur de 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 la page Utiliser l'API Explorer.

Pour supprimer la métrique personnalisée stores/daily_sales créée grâce aux étapes de la section Créer manuellement des descripteurs de métrique, procédez comme suit :

  1. Accédez à la page de référence sur metricDescriptors.delete :
  2. Indiquez le nom du descripteur de 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

C#

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

Go


import (
	"context"
	"fmt"
	"io"

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

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

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

Java

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

Node.js

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

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

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

Consultez la section Dépanner l'API Monitoring si vous rencontrez des difficultés.

Écrire des données de métrique

Vous ne pouvez écrire des données que dans des types de métriques pour les métriques personnalisées. Pour écrire vos données, utilisez la méthode timeSeries.create. Si la série temporelle existe déjà, cette méthode ajoute un nouveau point de données à la série temporelle existante. Si elle 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 :

  • Chaque série temporelle est identifiée par les champs metric et resource de l'objet TimeSeries. 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.
  • Si vous souhaitez écrire plusieurs points sur une même série temporelle, appelez la méthode timeSeries.create pour chacun d'eux. N'écrivez pas de données dans une série temporelle unique plus rapidement qu'un point pour chaque tranche de 10 secondes. Si vous ajoutez des points de données à différentes séries temporelles, cette limitation de débit ne s'applique pas.

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 la page Utiliser l'API Explorer.

Pour écrire un point sur la métrique personnalisée stores/daily_sales, créée grâce aux étapes de la section Créer manuellement des descripteurs de métrique, procédez comme suit :

  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 Exécuter.

Utilisez les exemples de paramètres suivants :

  • name : projects/[PROJECT_ID]
  • Corps de la requête : inclut une liste d'objets TimeSeries. L'exemple suivant ne comporte qu'une seule série temporelle.

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

C#

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

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

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

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

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

Go


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

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

Java

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

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

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

ProjectName name = ProjectName.of(projectId);

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

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

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

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

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

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

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

Node.js

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

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

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

Consultez la section Dépanner l'API Monitoring si vous rencontrez des difficultés.

Modifier des descripteurs de métrique

Pour ajouter des libellés à une métrique personnalisée existante, utilisez la méthode timeSeries.create et incluez les nouveaux libellés dans les données de séries temporelles. Si les libellés que vous tentez d'écrire sont valides et que le nombre total de libellés dans le descripteur de métrique ne dépasse pas la limite de 10, les libellés sont ajoutés. Les données de séries temporelles sont ensuite écrites comme si le libellé était présent depuis le début.

Si vous voulez aller plus loin que le simple ajout de nouvelles étiquettes, vous devez supprimer et recréer le descripteur de métrique. Dans ce cas, vous perdez l'ensemble des données de séries temporelles précédemment collectées pour l'ancien descripteur de métrique. Pour en savoir plus, consultez la section Supprimer des métriques.

Vous ne pouvez pas renommer une métrique.

Étape suivante