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

Avertissement:Le projet OpenCensus est obsolète. Nous vous recommandons d'utiliser OpenTelemetry.

Vous pouvez utiliser l'agent Ops pour collecter les métriques et les traces du protocole OpenTelemetry à partir d'applications instrumentées avec OpenTelemetry et exécutées sur Compute Engine. Pour en savoir plus, consultez Collectez les métriques et les traces OTLP.

Pour plus d'informations sur OpenTelemetry, consultez la section Qu'est-ce qu'OpenTelemetry ?

OpenCensus est un projet Open Source gratuit bibliothèques:

• fournir une assistance neutre du fournisseur pour la collecte des données de métriques et de trace ; en plusieurs langues.
• Possibilité d'exporter les données collectées vers diverses applications backend, y compris Cloud Monitoring à l'aide d'exportateurs.

Bien que Cloud Monitoring propose une API compatible avec la définition et permettant de collecter des métriques définies par l'utilisateur, il s'agit d'une API propriétaire de bas niveau. OpenCensus fournit une API qui suit le style et un exportateur qui envoie vos données de métriques Cloud Monitoring via l'API Monitoring pour vous.

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. Pour collecter des données de métriques et de trace à partir de vos services, procédez comme suit : vous pouvez utiliser une seule distribution de bibliothèques. Pour en savoir plus sur l'utilisation d'OpenCensus avec Cloud Trace, consultez la page Bibliothèques clientes pour Trace.

Remarque :Les métriques définies par l'utilisateur sont une fonctionnalité payante de Cloud Monitoring. Pour en savoir plus sur les tarifs, consultez la page Synthèse des tarifs de Cloud Monitoring.

Avant de commencer

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

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Go to project selector

2. Make sure that billing is enabled for your Google Cloud project.

3. Vérifiez que l'API Monitoring est activée. Pour en savoir plus, consultez la page Activer l'API Monitoring.

4. Pour les applications s'exécutant en dehors de Google Cloud, Le projet Google Cloud doit authentifier votre application. En règle générale, vous configurez l'authentification en créant un compte de service pour votre projet et en configurant une variable d'environnement.

   Pour en savoir plus sur la création d'un compte de service, consultez la page Premiers pas avec l'authentification.

Installer OpenCensus

Pour utiliser les métriques collectées par OpenCensus dans votre projet Google Cloud, vous devez Mettre à disposition les bibliothèques de métriques OpenCensus et l'exportateur Stackdriver à votre application. L'exportateur Stackdriver exporte les métriques OpenCensus collecte des données dans votre projet Google Cloud. Vous pouvez ensuite utiliser Cloud Monitoring pour les représenter sous forme de graphique ou de surveillance.

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.

L'utilisation d'OpenCensus nécessite Go version 1.11 ou ultérieure. Les dépendances sont gérées automatiquement à votre place.

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.

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-exporter-stats-stackdriver</artifactId>
  <version>${opencensus.version}</version>
</dependency>

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.

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

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.

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

pip install -r opencensus/requirements.txt

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

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

Pour instrumenter votre code afin d'utiliser OpenCensus pour les métriques, vous devez étapes:

1. Importez les statistiques OpenCensus et les packages OpenCensus de l'exportateur Stackdriver.
2. Initialisez l'exportateur Stackdriver.
3. Utiliser l'API OpenCensus pour instrumenter votre code

L'exemple suivant est un programme minimal qui écrit des données de métriques à l'aide de OpenCensus. Le programme exécute une boucle et collecte les mesures de latence. la boucle est terminée, les statistiques sont exportées vers Cloud Monitoring et le système se ferme:

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.

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

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

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

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 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(f"Fake latency recorded ({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. qui s'appelle task_latency_distribution. Cette chaîne fait partie du le nom du 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.

Si vous avez exécuté l'exemple de programme, vous pouvez utiliser l'Explorateur de métriques pour vos données: <ph type="x-smartling-placeholder">

</ph>

1. Dans la console Google Cloud, accédez à la page Explorateur de métriques :

   Accéder à l'explorateur de métriques

   Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Monitoring.

2. Dans l'élément Métrique, développez le menu Sélectionner une métrique, saisissez OpenCensus/task_latency_distribution dans la barre de filtre, puis utilisez les sous-menus pour sélectionner un type de ressource et des métriques spécifiques :
   1. Dans le menu Ressources actives, sélectionnez la ressource surveillée. Si vous exécutez le programme dans un environnement local, puis sélectionnez Monde.
   2. Dans le menu Catégories de métriques actives, sélectionnez Personnalisée.
   3. Dans le menu Métriques actives, sélectionnez Répartition de la latence des tâches.
   4. Cliquez sur Appliquer.

La capture d'écran suivante montre les séries temporelles collectées après l'exécution de dans un environnement local:

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.

Lire les métriques OpenCensus dans Cloud Monitoring

Vous utilisez des métriques définies par l'utilisateur, y compris celles écrites par OpenCensus, comme des métriques intégrées. Vous pouvez les représenter sous forme de graphique, et les surveiller.

Cette section explique comment utiliser l'explorateur d'API pour effectuer les opérations suivantes : pour lire les données de métriques. Pour en savoir plus sur la lecture des données de métrique à l'aide de l'API Cloud Monitoring ou à l'aide de bibliothèques clientes, consultez les documents suivants:

• Répertorier les types de métriques et de ressources : explique comment répertorier et examiner les types de ressources et de métriques de votre système.
• Découvrez comment récupérer les données de séries temporelles. comment récupérer des données de séries temporelles à partir de métriques à l'aide de API Monitoring.

Par exemple, la capture d'écran de la section précédente depuis l'Explorateur de métriques. Lorsque vous utilisez des outils de graphique, nous vous recommandons Utilisez le nom de la vue OpenCensus pour filtrer la liste des métriques. Pour en savoir plus, consultez Sélectionnez des métriques lorsque vous utilisez l'Explorateur de métriques.

Récupérer des descripteurs de métrique

Pour récupérer les données de métriques en utilisant directement l'API Monitoring, vous devez connaître les noms vers lequel les métriques OpenCensus ont été exportées. Vous pouvez déterminer ces noms en récupérant les descripteurs de métrique créés par l'exportateur, en examinant le champ type. Pour en savoir plus sur les descripteurs de métrique, consultez la page MetricDescriptor.

Pour afficher les descripteurs de métrique créés pour les métriques exportées, procédez comme suit:

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

2. Dans le widget Essayer cette API de la page de référence, procédez comme suit : :

   1. Saisissez le nom de votre projet dans le champ name. Utilisez le la structure de noms suivante projects/PROJECT_ID. Ce document utilise un projet portant l'ID a-gcp-project.

   2. Saisissez un filtre dans le champ filter. Il existe de nombreuses métriques de descripteurs dans un projet. Le filtrage vous permet de les éliminer les descripteurs qui ne présentent pas d'intérêt.

      Par exemple, comme le nom de la vue OpenCensus devient une partie nom de la métrique, vous pouvez ajouter un filtre comme celui-ci:

      metric.type=has_substring("task_latency_distribution")

      La clé metric.type est un champ d'un type intégré à un de séries temporelles. Pour en savoir plus, consultez la page TimeSeries.

   3. Cliquez sur 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"

Vous disposez désormais des informations nécessaires pour récupérer manuellement les données associées au type de métrique. La valeur du champ type est également indiqué dans la console Google Cloud lorsque vous représentez la métrique sous forme de graphique.

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

Pour récupérer manuellement des données de séries temporelles à partir d'un type de métrique, procédez comme suit:

1. Accédez à la page de référence sur timeSeries.list.

2. Dans le widget Essayer cette API de la page de référence, procédez comme suit : :

   1. Saisissez le nom de votre projet dans le champ name. Utilisez le la structure de noms suivante projects/PROJECT_ID.

   2. Dans le champ filter, saisissez la valeur suivante :

      metric.type="custom.googleapis.com/opencensus/task_latency_distribution"

   3. Renseignez les champs interval.startTime et interval.endTime. Ces valeurs doivent être saisies sous forme de code temporel (par exemple, 2018-10-11T15:48:38-04:00 Assurez-vous que la valeur startTime est antérieure que la valeur 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 de métriques renvoyées 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é

Comment Monitoring représente les métriques OpenCensus

L'utilisation directe de l'API Cloud Monitoring pour les métriques définies par l'utilisateur est possible. son utilisation est décrite dans Créer des métriques définies par l'utilisateur avec l'API En fait, l'exportateur OpenCensus pour Cloud Monitoring utilise cette API pour vous. Cette section fournit des informations sur le fonctionnement de Cloud Monitoring qui représente les métriques écrites par OpenCensus.

Les constructions utilisées par l'API OpenCensus diffèrent de celles utilisées par Cloud Monitoring, tout comme l'utilisation de la terminologie. 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 en savoir plus sur le modèle OpenCensus pour les métriques, consultez 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 analogue à la vue MetricDescriptor dans l'API Monitoring. Elle décrit la manière de collecter et d'agréger des "measurements" individuels. Balises sont incluses dans toutes les mesures enregistrées.

• Un tag (balise) OpenCensus est une paire clé/valeur, Une balise OpenCensus correspond généralement à LabelDescriptor dans l'API Monitoring. Les tags vous permettent de capturer des informations contextuelles que vous pouvez utiliser pour filtrer et regrouper les 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. Ces fonctions sont utilisées lors de l'exportation pour déterminer MetricKind, ValueType et unité indiquées dans le descripteur de la métrique Cloud Monitoring.

• Un measurement (mesure) OpenCensus est un point de données collecté. Les measurements doivent être agrégées dans des views. Sinon, les measurements individuels sont supprimés. Une mesure OpenCensus est analogue à un 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.

Étape suivante

• Afficher l'utilisation des métriques et les diagnostics

• 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