Crea metriche definite dall'utente con OpenCensus

OpenCensus è un progetto open source gratuito la cui librerie:

  • Fornire un supporto indipendente dal fornitore per la raccolta di dati di metriche e traccia in più lingue.
  • Consente di esportare i dati raccolti in varie applicazioni di backend, tra cui Cloud Monitoring mediante esportatori.

Sebbene Cloud Monitoring fornisca un'API che supporta la definizione e raccogliendo metriche definite dall'utente, è un'API proprietaria di basso livello. OpenCensus fornisce un'API che segue lo stile del community linguistica, oltre a un esportatore che invia i dati delle metriche a Cloud Monitoring tramite l'API Monitoring.

OpenCensus offre anche un buon supporto per il tracciamento delle applicazioni; vedi Tracciamento OpenCensus per informazioni generali panoramica. Cloud Trace consiglia di utilizzare OpenCensus per la traccia la strumentazione di lavoro. Per raccogliere dati di metriche e di traccia dai tuoi servizi, puoi usare un'unica distribuzione di librerie. Per informazioni sull'utilizzo OpenCensus con Cloud Trace, vedi Librerie client per Trace.

Prima di iniziare

Per utilizzare Cloud Monitoring, devi avere un progetto Google Cloud con e la fatturazione mensile abilitata. Se necessario, procedi nel seguente modo:

  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. Assicurati che l'API Monitoring sia abilitata. Per maggiori dettagli, vedi Attivazione dell'API Monitoring.

  4. Per le applicazioni in esecuzione al di fuori di Google Cloud, Il progetto Google Cloud deve autenticare la tua applicazione. In genere, si configura l'autenticazione creando un per il tuo progetto e configurando un ambiente .

    Per informazioni sulla creazione di un account di servizio, consulta Guida introduttiva all'autenticazione.

Installare OpenCensus

Per utilizzare le metriche raccolte da OpenCensus nel tuo progetto Google Cloud, devi: rendi disponibili le librerie delle metriche di OpenCensus e l'esportatore di Stackdriver alla tua applicazione. L'esportatore di Stackdriver esporta le metriche le raccolte di OpenCensus nel tuo progetto Google Cloud. Puoi quindi utilizzare Cloud Monitoring per tracciare o monitorare queste metriche.

Go

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

L'utilizzo di OpenCensus richiede Go 1.11 o versioni successive. La le dipendenze vengono gestite automaticamente.

Java

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Per Maven, aggiungi quanto segue all'elemento dependencies nel tuo File 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

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

  1. Prima di installare le librerie di esportazione principali e di esportazione di OpenCensus, assicurati Avere preparato l'ambiente per lo sviluppo Node.js.
  2. Il modo più semplice per installare OpenCensus è con npm: 
    npm install @opencensus/core
npm install @opencensus/exporter-stackdriver
  3. Inserisci le istruzioni require mostrate di seguito nella parte superiore dello script principale o del punto di ingresso dell'applicazione, prima di qualsiasi altro codice:
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Installa il core OpenCensus e le librerie di esportazione di Stackdriver mediante il comando seguente comando:

pip install -r opencensus/requirements.txt

Il file requirements.txt si trova nel repository GitHub per questi esempi, python-docs-samples.

Scrivere metriche definite dall'utente con OpenCensus

La strumentazione del codice per l'utilizzo di OpenCensus per le metriche prevede tre passaggi:

  1. Importa le statistiche di OpenCensus e i pacchetti di esportazione di Stackdriver OpenCensus.
  2. Inizializza l'utilità di esportazione di Stackdriver.
  3. Usa l'API OpenCensus per instrumentare il tuo codice.

L'esempio seguente è un programma minimo che scrive dati delle metriche utilizzando OpenCensus. Il programma esegue un ciclo e raccoglie le misure di latenza, termina il ciclo, esporta le statistiche in Cloud Monitoring ed esce:

Go

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 


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

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 


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

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

'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

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 


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()
Quando i dati di queste metriche vengono esportati in Cloud Monitoring, puoi utilizzare come qualsiasi altro dato.

Il programma crea una vista OpenCensus che si chiama task_latency_distribution. Questa stringa diventa parte della nome del quando viene esportato in Cloud Monitoring. Consulta la sezione Recupero della metrica in corso... descrittori per vedere come viene realizzata la vista OpenCensus come descrittore della metrica di Cloud Monitoring. Puoi quindi utilizzare il nome della vista come stringa di ricerca quando selezioni una metrica per creare un grafico.

Se hai eseguito il programma di esempio, puoi utilizzare Metrics Explorer per esamina i tuoi dati:

  1. Nella console Google Cloud, vai alla pagina  Esplora metriche:

    Vai a Esplora metriche

    Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

  2. Nell'elemento Metrica, espandi il menu Seleziona una metrica, inserisci OpenCensus/task_latency_distribution nella barra dei filtri, poi utilizza i sottomenu per selezionare un tipo di risorsa e una metrica specifici:
    1. Nel menu Risorse attive, seleziona la risorsa monitorata. Se esegui il programma in un ambiente locale, e seleziona Globale.
    2. Nel menu Categorie di metriche attive, seleziona Personalizzata.
    3. Nel menu Metriche attive, seleziona Distribuzione della latenza delle attività.
    4. Fai clic su Applica.

Il seguente screenshot mostra le serie temporali raccolte dopo l'esecuzione in un ambiente locale:

Metriche di OpenCensus in Cloud Monitoring.

Ogni barra della mappa termica rappresenta un'esecuzione del programma e i colori i componenti di ogni barra rappresentano i bucket nella distribuzione della latenza.

Leggere le metriche OpenCensus in Cloud Monitoring

Utilizzi metriche definite dall'utente, incluse quelle scritte da OpenCensus, come e metriche integrate. Potete creare grafici, impostare avvisi, leggere per poi monitorarli.

Questa sezione illustra come utilizzare Explorer API per per leggere i dati delle metriche. Per informazioni su come leggere i dati delle metriche utilizzando l'API Cloud Monitoring o utilizzando librerie client, consulta i seguenti documenti:

Ad esempio, lo screenshot mostrato nella sezione precedente è da Metrics Explorer. Quando utilizzi gli strumenti per la creazione di grafici, ti consigliamo di: utilizza il nome della vista OpenCensus per filtrare l'elenco delle metriche. Per ulteriori informazioni, vedi Seleziona le metriche quando utilizzi Esplora metriche.

Recupera i descrittori delle metriche

Per recuperare i dati delle metriche utilizzando direttamente l'API Monitoring, devi conoscere i nomi di Cloud Monitoring in cui sono state esportate le metriche di OpenCensus. Puoi determinare questi nomi recuperando i descrittori delle metriche creati dall'esportatore e quindi esaminando il campo type. Per maggiori dettagli sui descrittori delle metriche, consulta MetricDescriptor

Per visualizzare i descrittori delle metriche creati per le metriche esportate:

  1. Vai alla pagina di riferimento metricDescriptors.list.

  2. Nel widget Prova questa API della pagina di riferimento, completa quanto segue. campi:

    1. Inserisci il nome del progetto nel campo name. Utilizza la la seguente struttura del nome projects/PROJECT_ID. Questo documento utilizza un progetto con ID a-gcp-project.

    2. Inserisci un filtro nel campo filter. Esistono molte metriche in un progetto. L'applicazione di filtri ti consente di eliminarli descrittori che non sono interessanti.

      Ad esempio, perché il nome della vista OpenCensus diventa parte nome della metrica, puoi aggiungere un filtro come questo:

      metric.type=has_substring("task_latency_distribution")

      La chiave metric.type è un campo di un tipo incorporato in una serie temporali. Per informazioni dettagliate, visita la pagina TimeSeries.

    3. Fai clic su Execute (Esegui).

Di seguito viene mostrato il descrittore della metrica restituito:

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

Questa linea nel descrittore della metrica indica il nome del tipo di metrica In Cloud Monitoring:

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

Ora hai le informazioni necessarie per recuperare manualmente i dati associati al tipo di metrica. Anche il valore del campo type è mostrata nella console Google Cloud quando crei un grafico della metrica.

Recupera i dati delle metriche

Per recuperare manualmente i dati delle serie temporali da un tipo di metrica:

  1. Vai alla timeSeries.listpagina di riferimento.

  2. Nel widget Prova questa API della pagina di riferimento, completa quanto segue. campi:

    1. Inserisci il nome del progetto nel campo name. Utilizza la la seguente struttura del nome projects/PROJECT_ID.

    2. Nel campo filter, inserisci il seguente valore:

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

    3. Inserisci i valori nei campi interval.startTime e interval.endTime. Questi valori devono essere inseriti come timestamp, ad esempio 2018-10-11T15:48:38-04:00. Assicurati che il valore startTime sia precedente rispetto al valore endTime.

    4. Fai clic sul pulsante Esegui.

Di seguito viene mostrato il risultato di uno di questi recuperi:

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

I dati delle metriche restituiti includono quanto segue:

  • Informazioni sulla risorsa monitorata su cui sono stati raccolti i dati. OpenCensus può rilevare automaticamente gce_instance, k8s_container, e aws_ec2_instance risorse monitorate. Questi dati provengono da un programma su un'istanza Compute Engine. Per informazioni sull'utilizzo di altre le risorse monitorate, Imposta la risorsa monitorata per l'esportatore.
  • Descrizione del tipo di metrica e del tipo di valori.
  • I punti dati effettivi raccolti nell'intervallo di tempo richiesto.

Rappresentazione delle metriche di OpenCensus da parte di Monitoring

È supportato l'uso diretto dell'API Cloud Monitoring per le metriche definite dall'utente. viene descritto Crea metriche definite dall'utente con l'API. Infatti, l'esportatore OpenCensus per Cloud Monitoring utilizza questa API per te. Questa sezione fornisce alcune informazioni su come Cloud Monitoring rappresenta le metriche scritte da OpenCensus.

I costrutti utilizzati dall'API OpenCensus sono diversi da quelli utilizzati Cloud Monitoring, così come alcuni usi della terminologia. Dove Cloud Monitoring si riferisce a "metriche", OpenCensus a volte si riferisce "stats". Ad esempio, il componente di OpenCensus che invia delle metriche in Cloud Monitoring è chiamato "esportatore di statistiche per Stack Drdiver".

Per una panoramica del modello OpenCensus per le metriche, consulta Metriche di OpenCensus.

I modelli dei dati per le statistiche OpenCensus e le metriche di Cloud Monitoring non in una mappatura 1:1. Molti degli stessi concetti esistono in entrambi i casi, non sono direttamente intercambiabili.

  • Una vista OpenCensus è analoga a MetricDescriptor nell'API Monitoring. Una vista descrive come raccogliere e aggregare le singole misurazioni. Tag sono incluse in tutte le misurazioni registrate.

  • Un tag OpenCensus è una coppia chiave-valore. Un tag OpenCensus corrisponde in generale in LabelDescriptor nell'API Monitoring. I tag ti consentono di acquisire informazioni contestuali che puoi utilizzare per filtrare e raggruppare le metriche.

  • Una misura OpenCensus descrive i dati delle metriche da registrare. Un'aggregazione OpenCensus è una funzione applicata ai dati utilizzati: riassumilo. Queste funzioni sono utilizzate nell'esportazione per determinare MetricKind, ValueType e unità riportato nel descrittore della metrica di Cloud Monitoring.

  • Una misurazione OpenCensus è un punto dati raccolto. Le misurazioni devono essere aggregate in visualizzazioni. Altrimenti, il privato le misurazioni vengono eliminate. Una misurazione OpenCensus è analoga a una Point nell'API Monitoring. Quando le misurazioni sono aggregate in visualizzazioni, i dati aggregati vengono archiviati come dati di visualizzazione, in modo analogo a TimeSeries nell'API Monitoring.

Passaggi successivi