Métriques personnalisées avec OpenCensus

Cloud Monitoring collecte automatiquement plus d'un millier de métriques intégrées à partir d'une longue liste de ressources surveillées. Toutefois, ces métriques ne peuvent pas capturer des données spécifiques à une application ou des données système côté client. Elles peuvent vous donner des informations sur la latence du backend ou l'utilisation du disque, mais elles ne peuvent pas vous donner le nombre de routines d'arrière-plan générées par votre application.

Les métriques spécifiques à l'application sont définies et collectées pour capturer des informations que les métriques Cloud Monitoring intégrées ne peuvent pas obtenir. Vous pouvez capturer ces métriques à l'aide d'une API fournie par une bibliothèque pour qu'elle instrumente votre code, puis envoyer les métriques à une application backend telle que Cloud Monitoring.

Dans Cloud Monitoring, les métriques spécifiques à une application sont généralement appelées "métriques personnalisées". Les termes sont interchangeables. Elles sont également appelées "métriques définies par l'utilisateur".

En ce qui concerne Cloud Monitoring, les métriques personnalisées peuvent être utilisées comme les métriques intégrées. Vous pouvez les représenter, y définir des alertes et les surveiller. La différence est que vous définissez les métriques, y écrivez des données et pouvez les supprimer. Toutes ces actions sont impossibles avec les métriques intégrées.

Il existe de nombreuses façons de capturer des métriques personnalisées. Vous pouvez par exemple utiliser directement l'API Cloud Monitoring. Cloud Monitoring vous recommande d'utiliser OpenCensus pour instrumenter votre code en vue de la collecte des métriques personnalisées.

Qu'est-ce qu'OpenCensus ?

OpenCensus est un projet gratuit et Open Source dont les bibliothèques :

  • fournissent une compatibilité indépendante des fournisseurs pour collecter les données métriques et de trace dans plusieurs langages ;
  • peuvent exporter les données collectées vers différentes applications backend, y compris Cloud Monitoring.

Pour obtenir la liste des langages actuellement compatibles, consultez la page Langages compatibles. Pour obtenir la liste actuelle des applications backend pour lesquelles les exportateurs sont disponibles, consultez la page Exportateurs.

Pourquoi utiliser OpenCensus ?

Cloud Monitoring fournit une API acceptant la définition et la collecte de métriques personnalisées. Toutefois, il s'agit d'une API propriétaire de bas niveau. OpenCensus fournit une API beaucoup plus idiomatique, ainsi qu'un exportateur qui se charge d'envoyer vos données métriques à Cloud Monitoring via l'API Monitoring.

De plus, OpenCensus est un projet Open Source. Vous pouvez exporter les données collectées à l'aide d'une bibliothèque indépendante des fournisseurs, au lieu d'utiliser une bibliothèque propriétaire.

OpenCensus offre également une bonne prise en charge du traçage des applications. Pour obtenir des informations générales à ce sujet, consultez la page relative au traçage dans OpenCensus. Cloud Trace recommande d'utiliser OpenCensus pour l'instrumentation de trace. Vous pouvez utiliser une seule distribution de bibliothèques pour collecter des données métriques et de trace à partir de vos services. Pour en savoir plus sur l'utilisation d'OpenCensus avec Cloud Trace, consultez la page Bibliothèques clientes pour Trace.

Avant de commencer

Pour utiliser Cloud Monitoring, vous devez disposer d'un projet Google Cloud pour lequel la facturation est activée. Le projet doit également être associé à un espace de travail. Cloud Monitoring se sert des espaces de travail pour organiser les projets Google Cloud surveillés.

Si vous n'avez pas de projet Google Cloud, procédez comme suit :

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activez l'API Monitoring. Pour en savoir plus, consultez la page Activer l'API Monitoring.
  5. Si votre application s'exécute en dehors de Google Cloud, elle doit être authentifiée par votre projet Google Cloud. Pour en savoir plus, consultez la page Premiers pas avec l'authentification.

Pour plus d'informations sur l'association de votre projet à un espace de travail, consultez la page Espace de travail.

Installer OpenCensus

Pour utiliser OpenCensus, vous devez rendre disponibles les bibliothèques des métriques et l'exportateur Stackdriver.

Go

Pour pouvoir utiliser OpenCensus, vous devez disposer de Go version 1.11 ou supérieure. Les dépendances sont gérées automatiquement à votre place.

Java

Pour Maven, ajoutez le code suivant à l'élément dependencies de votre fichier pom.xml :
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-api</artifactId>
  <version>${opencensus.version}</version>
</dependency>
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-impl</artifactId>
  <version>${opencensus.version}</version>
</dependency>
<dependency>
  <groupId>io.opencensus</groupId>
  <artifactId>opencensus-exporter-stats-stackdriver</artifactId>
  <version>${opencensus.version}</version>
</dependency>

Node.js

  1. Avant d'installer les bibliothèques principales et d'exportateurs OpenCensus, assurez-vous d'avoir préparé votre environnement pour le développement Node.js.
  2. Le moyen le plus simple d'installer OpenCensus est d'utiliser npm :
    npm install @opencensus/core
    npm install @opencensus/exporter-stackdriver
  3. Placez les instructions require indiquées ci-dessous en haut du point d'entrée ou du script principal de votre application, avant tout autre code :
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

Installez les bibliothèques principales d'OpenCensus et celles de l'exportateur Stackdriver à l'aide de la commande suivante :

pip install -r opencensus/requirements.txt

Le fichier requirements.txt se trouve dans le dépôt GitHub de ces exemples, python-docs-samples.

Utiliser OpenCensus pour les métriques

Pour instrumenter votre code afin d'utiliser OpenCensus pour les métriques, vous devez suivre trois étapes générales :

  1. Importer les stats (statistiques) OpenCensus et les packages OpenCensus de l'exportateur Stackdriver
  2. Initialiser l'exportateur Stackdriver
  3. Utiliser l'API OpenCensus pour instrumenter votre code

Exemple de base

Voici un programme minimal qui permet d'illustrer ces étapes. Il exécute une boucle et collecte les mesures de latence. Une fois la boucle terminée, il exporte les stats dans Cloud Monitoring et s'interrompt :

Go


// metrics_quickstart is an example of exporting a custom metric from
// OpenCensus to Stackdriver.
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"contrib.go.opencensus.io/exporter/stackdriver"
	"go.opencensus.io/stats"
	"go.opencensus.io/stats/view"
	"golang.org/x/exp/rand"
)

var (
	// The task latency in milliseconds.
	latencyMs = stats.Float64("task_latency", "The task latency in milliseconds", "ms")
)

func main() {
	ctx := context.Background()

	// Register the view. It is imperative that this step exists,
	// otherwise recorded metrics will be dropped and never exported.
	v := &view.View{
		Name:        "task_latency_distribution",
		Measure:     latencyMs,
		Description: "The distribution of the task latencies",

		// Latency in buckets:
		// [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
		Aggregation: view.Distribution(0, 100, 200, 400, 1000, 2000, 4000),
	}
	if err := view.Register(v); err != nil {
		log.Fatalf("Failed to register the view: %v", err)
	}

	// Enable OpenCensus exporters to export metrics
	// to Stackdriver Monitoring.
	// Exporters use Application Default Credentials to authenticate.
	// See https://developers.google.com/identity/protocols/application-default-credentials
	// for more details.
	exporter, err := stackdriver.NewExporter(stackdriver.Options{})
	if err != nil {
		log.Fatal(err)
	}
	// Flush must be called before main() exits to ensure metrics are recorded.
	defer exporter.Flush()

	if err := exporter.StartMetricsExporter(); err != nil {
		log.Fatalf("Error starting metric exporter: %v", err)
	}
	defer exporter.StopMetricsExporter()

	// Record 100 fake latency values between 0 and 5 seconds.
	for i := 0; i < 100; i++ {
		ms := float64(5*time.Second/time.Millisecond) * rand.Float64()
		fmt.Printf("Latency %d: %f\n", i, ms)
		stats.Record(ctx, latencyMs.M(ms))
		time.Sleep(1 * time.Second)
	}

	fmt.Println("Done recording metrics")
}

Java


import com.google.common.collect.Lists;
import io.opencensus.exporter.stats.stackdriver.StackdriverStatsExporter;
import io.opencensus.stats.Aggregation;
import io.opencensus.stats.BucketBoundaries;
import io.opencensus.stats.Measure.MeasureLong;
import io.opencensus.stats.Stats;
import io.opencensus.stats.StatsRecorder;
import io.opencensus.stats.View;
import io.opencensus.stats.View.Name;
import io.opencensus.stats.ViewManager;
import java.io.IOException;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Quickstart {
  private static final int EXPORT_INTERVAL = 70;
  private static final MeasureLong LATENCY_MS =
      MeasureLong.create("task_latency", "The task latency in milliseconds", "ms");
  // Latency in buckets:
  // [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
  private static final BucketBoundaries LATENCY_BOUNDARIES =
      BucketBoundaries.create(Lists.newArrayList(0d, 100d, 200d, 400d, 1000d, 2000d, 4000d));
  private static final StatsRecorder STATS_RECORDER = Stats.getStatsRecorder();

  public static void main(String[] args) throws IOException, InterruptedException {
    // Register the view. It is imperative that this step exists,
    // otherwise recorded metrics will be dropped and never exported.
    View view =
        View.create(
            Name.create("task_latency_distribution"),
            "The distribution of the task latencies.",
            LATENCY_MS,
            Aggregation.Distribution.create(LATENCY_BOUNDARIES),
            Collections.emptyList());

    ViewManager viewManager = Stats.getViewManager();
    viewManager.registerView(view);

    // Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
    // Exporters use Application Default Credentials to authenticate.
    // See https://developers.google.com/identity/protocols/application-default-credentials
    // for more details.
    StackdriverStatsExporter.createAndRegister();

    // Record 100 fake latency values between 0 and 5 seconds.
    Random rand = new Random();
    for (int i = 0; i < 100; i++) {
      long ms = (long) (TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS) * rand.nextDouble());
      System.out.println(String.format("Latency %d: %d", i, ms));
      STATS_RECORDER.newMeasureMap().put(LATENCY_MS, ms).record();
    }

    // The default export interval is 60 seconds. The thread with the StackdriverStatsExporter must
    // live for at least the interval past any metrics that must be collected, or some risk being
    // lost if they are recorded after the last export.

    System.out.println(
        String.format(
            "Sleeping %d seconds before shutdown to ensure all records are flushed.",
            EXPORT_INTERVAL));
    Thread.sleep(TimeUnit.MILLISECONDS.convert(EXPORT_INTERVAL, TimeUnit.SECONDS));
  }
}

Node.js

'use strict';

const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

const EXPORT_INTERVAL = process.env.EXPORT_INTERVAL || 60;
const LATENCY_MS = globalStats.createMeasureInt64(
  'task_latency',
  MeasureUnit.MS,
  'The task latency in milliseconds'
);

// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
const view = globalStats.createView(
  'task_latency_distribution',
  LATENCY_MS,
  AggregationType.DISTRIBUTION,
  [],
  'The distribution of the task latencies.',
  // Latency in buckets:
  // [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
  [0, 100, 200, 400, 1000, 2000, 4000]
);

// Then finally register the views
globalStats.registerView(view);

// Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
// Exporters use Application Default Credentials (ADCs) to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
// Expects ADCs to be provided through the environment as ${GOOGLE_APPLICATION_CREDENTIALS}
// A Stackdriver workspace is required and provided through the environment as ${GOOGLE_PROJECT_ID}
const projectId = process.env.GOOGLE_PROJECT_ID;

// GOOGLE_APPLICATION_CREDENTIALS are expected by a dependency of this code
// Not this code itself. Checking for existence here but not retaining (as not needed)
if (!projectId || !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
  throw Error('Unable to proceed without a Project ID');
}

// The minimum reporting period for Stackdriver is 1 minute.
const exporter = new StackdriverStatsExporter({
  projectId: projectId,
  period: EXPORT_INTERVAL * 1000,
});

// Pass the created exporter to Stats
globalStats.registerExporter(exporter);

// Record 100 fake latency values between 0 and 5 seconds.
for (let i = 0; i < 100; i++) {
  const ms = Math.floor(Math.random() * 5);
  console.log(`Latency ${i}: ${ms}`);
  globalStats.record([
    {
      measure: LATENCY_MS,
      value: ms,
    },
  ]);
}

/**
 * The default export interval is 60 seconds. The thread with the
 * StackdriverStatsExporter must live for at least the interval past any
 * metrics that must be collected, or some risk being lost if they are recorded
 * after the last export.
 */
setTimeout(() => {
  console.log('Done recording metrics.');
  globalStats.unregisterExporter(exporter);
}, EXPORT_INTERVAL * 1000);

Python


from random import random
import time

from opencensus.ext.stackdriver import stats_exporter
from opencensus.stats import aggregation
from opencensus.stats import measure
from opencensus.stats import stats
from opencensus.stats import view

# A measure that represents task latency in ms.
LATENCY_MS = measure.MeasureFloat(
    "task_latency",
    "The task latency in milliseconds",
    "ms")

# A view of the task latency measure that aggregates measurements according to
# a histogram with predefined bucket boundaries. This aggregate is periodically
# exported to Stackdriver Monitoring.
LATENCY_VIEW = view.View(
    "task_latency_distribution",
    "The distribution of the task latencies",
    [],
    LATENCY_MS,
    # Latency in buckets: [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
    aggregation.DistributionAggregation(
        [100.0, 200.0, 400.0, 1000.0, 2000.0, 4000.0]))

def main():
    # Register the view. Measurements are only aggregated and exported if
    # they're associated with a registered view.
    stats.stats.view_manager.register_view(LATENCY_VIEW)

    # Create the Stackdriver stats exporter and start exporting metrics in the
    # background, once every 60 seconds by default.
    exporter = stats_exporter.new_stats_exporter()
    print('Exporting stats to project "{}"'
          .format(exporter.options.project_id))

    # Register exporter to the view manager.
    stats.stats.view_manager.register_exporter(exporter)

    # Record 100 fake latency values between 0 and 5 seconds.
    for num in range(100):
        ms = random() * 5 * 1000

        mmap = stats.stats.stats_recorder.new_measurement_map()
        mmap.measure_float_put(LATENCY_MS, ms)
        mmap.record()

        print("Fake latency recorded ({}: {})".format(num, ms))

    # Keep the thread alive long enough for the exporter to export at least
    # once.
    time.sleep(65)

if __name__ == '__main__':
    main()
Lorsque ces données métriques sont exportées vers Cloud Monitoring, vous pouvez les utiliser comme toute autre donnée.

Le programme crée une view (vue) OpenCensus appelée task_latency_distribution. Cette chaîne devient une partie du nom de la métrique lors de son exportation vers Cloud Monitoring. Pour découvrir comment la view (vue) OpenCensus est réalisée en tant que descripteur de métrique Cloud Monitoring, consultez la section Récupérer des descripteurs de métrique.

Vous pouvez donc utiliser le nom de la view comme chaîne de recherche lors de la sélection d'une métrique à représenter graphiquement. Par exemple, vous pouvez le saisir dans le champ Find resource type and metric (Rechercher par type de ressource et par métrique) de l'explorateur de métriques. La capture d'écran suivante montre le résultat obtenu :

Métriques d'OpenCensus dans Cloud Monitoring.

Chaque barre de la carte de densité représente une seule exécution du programme. Les composants colorés de chaque barre représentent les buckets de la répartition de la latence. Pour en savoir plus sur les données utilisées pour ce graphique, consultez la section Métriques OpenCensus dans Cloud Monitoring.

Documentation OpenCensus

OpenCensus fournit la documentation de référence primaire pour son API relative aux métriques et pour l'exportateur Stackdriver. Le tableau suivant fournit des liens vers ces documents de référence :

Langage Documentation de référence sur les API Documentation sur l'exportateur Démarrage rapide
Go API Go Stats and Trace Exporters (Exportateurs de statistiques et de traces) Métriques
Java API Java Stats Exporter (Exportateur de statistiques) Métriques
NodeJS API NodeJS Stats Exporter (Exportateur de statistiques) Métriques
Python API Python Stats Exporter (Exportateur de statistiques) Métriques

Mapper les modèles

Vous pouvez utiliser directement l'API Cloud Monitoring pour les métriques personnalisées. Les conditions d'utilisations sont décrites à la page Utiliser des métriques personnalisées. En fait, l'exportateur OpenCensus pour Cloud Monitoring utilise cette API pour vous.

Même si vous n'avez pas besoin de connaître les spécificités de l'utilisation de l'API Cloud Monitoring, familiarisez-vous avec ses concepts et sa terminologie pour comprendre comment Cloud Monitoring représente les métriques. Cette section fournit certaines informations à ce sujet.

Une fois vos métriques ingérées dans Cloud Monitoring, elles sont stockées dans des constructions Cloud Monitoring. Vous pouvez, par exemple, extraire le descripteur de métrique (un type de l'API Monitoring) d'une métrique personnalisée. Pour en savoir plus, consultez la page MetricDescriptor. Vous rencontrez ces descripteurs de métrique, par exemple, lors de la création de graphiques pour vos données.

Terminologie et concepts

Les constructions utilisées par l'API OpenCensus diffèrent de celles utilisées par Cloud Monitoring, à l'instar de certaines terminologies. Lorsque Cloud Monitoring fait référence à des "métriques", OpenCensus fait parfois référence à des "stats" (statistiques). Par exemple, le composant OpenCensus qui envoie des données métriques à Cloud Monitoring est appelé "stats exporter for Stackdriver" (exportateur de stats pour Stackdriver).

Pour découvrir le modèle OpenCensus pour les métriques, consultez la page relative aux métriques OpenCensus.

Les modèles de données pour les stats OpenCensus et les métriques Stackdriver Monitoring n'affichent pas une correspondance parfaite. Bon nombre des mêmes concepts existent chez chacun, mais ils ne sont pas directement interchangeables.

  • Une view (vue) OpenCensus est généralement analogue à la ressource MetricDescriptor dans l'API Monitoring. Elle décrit la manière de collecter et d'agréger des "measurements" individuels. Tous les measurements enregistrés sont répartis par tags.

  • Un tag (balise) OpenCensus est une paire clé/valeur, qui correspond généralement à la ressource LabelDescriptor dans l'API Monitoring. Les tags vous permettent de capturer des informations contextuelles pouvant être utilisées pour filtrer et grouper des métriques.

  • Une measure (type de mesure) OpenCensus décrit les données métriques à enregistrer. Une aggregation (agrégation) OpenCensus est une fonction appliquée aux données utilisées pour les résumer. Celles-ci sont utilisées lors de l'exportation pour déterminer le MetricKind, le ValueType et l'unité indiqués dans le descripteur de métrique Cloud Monitoring.

  • Un measurement (mesure) OpenCensus est un point de données collecté pour être mesuré. Les measurements doivent être agrégées dans des views. Sinon, les measurements individuels sont supprimés. Cette construction est analogue à une ressource Point dans l'API Monitoring. Lorsque les measurements sont agrégés dans des views, les données agrégées sont stockées en tant que view data (données de vue), à la manière d'une ressource TimeSeries dans l'API Monitoring.

Métriques OpenCensus dans Cloud Monitoring

Vous pouvez examiner les métriques exportées dans Cloud Monitoring. La capture d'écran dans la section Exemple de base provient de l'explorateur de métriques. Si vous avez exécuté l'exemple de programme, vous pouvez utiliser l'explorateur de métriques pour examiner vos données.

Pour afficher les métriques d'une ressource surveillée à l'aide de l'explorateur de métriques, procédez comme suit :

  1. Dans Google Cloud Console, accédez à Monitoring ou utilisez le bouton suivant :
    Accéder à Monitoring
  2. Dans le volet de navigation "Surveillance", cliquez sur  Explorateur de métriques.
  3. Saisissez le nom de la ressource surveillée dans la zone de texte Rechercher un type de ressource et une métrique.

Pour restreindre la recherche, vous pouvez indiquer le nom de la view OpenCensus lorsque vous spécifiez la métrique. Pour en savoir plus, consultez la page Sélectionner des métriques.

Récupérer des descripteurs de métrique

Vous pouvez récupérer les données métriques directement à l'aide de l'API Monitoring. Pour récupérer les données métriques, vous devez connaître les noms Cloud Monitoring vers lesquels les métriques OpenCensus ont été exportées.

Pour obtenir ces informations, vous pouvez extraire les descripteurs de métrique créés par l'exportateur et rechercher la valeur du champ type. Cette valeur intègre le nom de la view OpenCensus à partir duquel elle a été exportée. Pour en savoir plus sur les descripteurs de métrique, consultez la page MetricDescriptor.

Vous pouvez afficher les descripteurs de métrique créés pour les métriques exportées à l'aide du widget API Explorer (Essayer cette API) sur la page de référence de la méthode metricDescriptors.list. Pour récupérer les descripteurs des métriques OpenCensus à l'aide de cet outil, procédez comme suit :

  1. Saisissez le nom de votre projet dans le champ name : projects/[PROJECT_ID]. Ce document utilise un projet ayant l'identifiant a-gcp-project.

  2. Saisissez un filtre dans le champ filter. Le nom de la view OpenCensus devient une partie du nom de la métrique. Vous pouvez donc utiliser ce nom pour limiter la liste en indiquant un filtre comme celui-ci :

    metric.type=has_substring("task_latency_distribution")

    Il existe de nombreux descripteurs de métrique dans tout projet. En filtrant la liste à l'aide d'une sous-chaîne issue du nom de la view (vue) OpenCensus, vous pourrez en éliminer la plupart.

  3. Cliquez sur le bouton Exécuter.

Les lignes suivantes affichent le descripteur de métrique renvoyé :

    {
      "metricDescriptors": [
        {
          "name": "projects/a-gcp-project/metricDescriptors/custom.googleapis.com/opencensus/task_latency_distribution",
          "labels": [
            {
              "key": "opencensus_task",
              "description": "Opencensus task identifier"
            }
          ],
          "metricKind": "CUMULATIVE",
          "valueType": "DISTRIBUTION",
          "unit": "ms",
          "description": "The distribution of the task latencies",
          "displayName": "OpenCensus/task_latency_distribution",
          "type": "custom.googleapis.com/opencensus/task_latency_distribution"
        }
      ]
    }

Cette ligne du descripteur de métrique indique le nom du type de métrique dans Cloud Monitoring :

    "type": "custom.googleapis.com/opencensus/task_latency_distribution"

Grâce à ces informations, vous pouvez ensuite extraire manuellement les données associées à ce type de métrique. Ce sont également les données qui apparaissent sur un graphique pour cette métrique.

Récupérer des données métriques

Pour récupérer manuellement des données de séries temporelles à partir d'un type de métrique, vous pouvez utiliser l'outil Essayer cette API sur la page de référence de la méthode timeSeries.list. Pour ce faire, procédez comme suit :

  1. Saisissez le nom de votre projet dans le champ name : projects/[PROJECT_ID]
  2. Saisissez un filtre dans le champ filter pour le type de métrique souhaité : metric.type="custom.googleapis.com/opencensus/task_latency_distribution"
    • La clé, metric.type, est un champ dans un type intégré dans une série temporelle. Pour en savoir plus, consultez la page TimeSeries.
    • La valeur est celle du champ type extraite du descripteur de métrique dans la section Récupérer des descripteurs de métrique.
  3. Saisissez des limites temporelles pour la récupération en spécifiant des valeurs pour les champs suivants :
    • interval.endTime comme horodatage, par exemple : 2018-10-11T15:48:38-04:00
    • interval.startTime (obligatoirement antérieur à interval.endTime)
  4. Cliquez sur le bouton Exécuter.

Les lignes suivantes affichent le résultat d'une récupération de ce type :

    {
      "timeSeries": [
        {
          "metric": {
            "labels": {
              "opencensus_task": "java-3424@docbuild"
            },
            "type": "custom.googleapis.com/opencensus/task_latency_distribution"
          },
          "resource": {
            "type": "gce_instance",
            "labels": {
              "instance_id": "2455918024984027105",
              "zone": "us-east1-b",
              "project_id": "a-gcp-project"
            }
          },
          "metricKind": "CUMULATIVE",
          "valueType": "DISTRIBUTION",
          "points": [
            {
              "interval": {
                "startTime": "2019-04-04T17:49:34.163Z",
                "endTime": "2019-04-04T17:50:42.917Z"
              },
              "value": {
                "distributionValue": {
                  "count": "100",
                  "mean": 2610.11,
                  "sumOfSquaredDeviation": 206029821.78999996,
                  "bucketOptions": {
                    "explicitBuckets": {
                      "bounds": [
                        0,
                        100,
                        200,
                        400,
                        1000,
                        2000,
                        4000
                      ]
                    }
                  },
                  "bucketCounts": [
                    "0",
                    "0",
                    "1",
                    "6",
                    "13",
                    "15",
                    "44",
                    "21"
                  ]
                }
              }
            }
          ]
        },
        [ ... data from additional program runs deleted ...]
      ]
    }

Les données renvoyées ici incluent les éléments suivants :

  • Informations relatives à la ressource surveillée sur laquelle les données ont été collectées OpenCensus peut détecter automatiquement les ressources surveillées gce_instance, k8s_container et aws_ec2_instance. Ces données provenaient d'un programme exécuté sur une instance de Compute  Engine. Pour en savoir plus sur l'utilisation d'autres ressources surveillées, consultez la page Définir une ressource surveillée pour l'exportateur.
  • Description du type de métrique et du type des valeurs
  • Les points de données réels collectés dans l'intervalle de temps demandé