Métricas personalizadas con OpenCensus

Cloud Monitoring recopila automáticamente más de mil métricas integradas de una larga lista de recursos supervisados. No obstante, esas métricas no pueden abarcar datos específicos de la aplicación o datos del sistema del lado del cliente. Esas métricas pueden darte información sobre la latencia de backend o el uso del disco, pero no pueden decirte cuántas rutinas en segundo plano generó tu aplicación.

Las métricas específicas de la aplicación son métricas que defines y recopilas para capturar información que las métricas integradas de Cloud Monitoring no pueden capturar. Debes capturar estas métricas mediante una API proporcionada por una biblioteca para instrumentar tu código y, luego, enviar las métricas a una aplicación de backend como Cloud Monitoring.

En Cloud Monitoring, las métricas específicas de la aplicación se suelen llamar “métricas personalizadas”. Los términos son intercambiables. También se las llama “métricas definidas por el usuario”.

En lo que respecta a Cloud Monitoring, las métricas personalizadas se pueden usar como las métricas integradas. Puedes realizar gráficos y establecer alertas con ellas, y puedes supervisarlas. La diferencia es que tú defines las métricas, escribes datos en ellas y puedes borrarlas. No se puede hacer nada de eso con las métricas integradas.

Hay muchas formas de capturar métricas personalizadas, incluido el uso directo de la API de Cloud Monitoring. Cloud Monitoring recomienda que uses OpenCensus para instrumentar tu código con el fin de recopilar métricas personalizadas.

Nota: Las métricas personalizadas son una función con cargo de Cloud Monitoring y podría haber costos para tus métricas personalizadas. Para obtener más información sobre los precios, consulta Precios de Google Cloud's operations suite.

¿Qué es OpenCensus?

OpenCensus es un proyecto gratuito de código abierto cuyas bibliotecas poseen las siguientes características:

• Proporcionan compatibilidad independiente del proveedor para la recopilación de datos de métricas y de seguimiento en una variedad de lenguajes.
• Puedes exportar los datos recopilados a una variedad de aplicaciones de backend, incluida Cloud Monitoring.

Si quieres obtener la lista actual de lenguajes compatibles, consulta Lenguajes admitidos. Si deseas obtener la lista actual de aplicaciones de backend para las que hay exportadores disponibles, consulta Exportadores.

¿Por qué elegir OpenCensus?

Si bien Cloud Monitoring proporciona una API que admite la definición y recopilación de métricas personalizadas, es una API propietaria de bajo nivel. OpenCensus proporciona una API mucho más idiomática, junto con un exportador que envía tus datos de métricas a Cloud Monitoring a través de la API de Monitoring.

Además, OpenCensus es un proyecto de código abierto. Puedes exportar los datos recopilados mediante una biblioteca independiente del proveedor en lugar de una biblioteca propietaria.

OpenCensus también tiene una buena asistencia para el seguimiento de aplicaciones; consulta Seguimiento de OpenCensus a fin de obtener una descripción general. Cloud Trace recomienda que uses OpenCensus para la instrumentación de seguimiento. Puedes usar una única distribución de bibliotecas para recopilar datos de métricas y de seguimiento de tus servicios. Si quieres obtener información sobre el uso de OpenCensus con Cloud Trace, consulta Bibliotecas cliente para Trace.

Antes de comenzar

Para usar Cloud Monitoring, debes tener un proyecto de Google Cloud con la facturación habilitada. El proyecto también debe estar asociado a un espacio de trabajo. Cloud Monitoring usa lugares de trabajo para organizar proyectos de Google Cloud supervisados.

Si no tienes un proyecto de Google Cloud, haz lo siguiente:

1. Accede a tu Cuenta de Google.

   Si todavía no tienes una cuenta, regístrate para obtener una nueva.

2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir a la página Selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

4. Habilita la API de Monitoring. Para obtener más información, consulta Habilita la API de Monitoring.
5. Si tu aplicación se ejecuta fuera de Google Cloud, tu proyecto de Google Cloud debe autenticar tu aplicación. Para obtener más información, consulta Introducción a la autenticación.

Para obtener información sobre cómo asociar tu proyecto a un espacio de trabajo, consulta Espacios de trabajo.

Instala OpenCensus

Para usar OpenCensus, debes habilitar las bibliotecas de métricas y el exportador de Stackdriver.

Go

Usar OpenCensus requiere la versión 1.11 de Go o una superior. Las dependencias se administran de forma automática.

Java

Para Maven, agrega lo siguiente al elemento dependencies en tu archivo pom.xml:

Ver en GitHub Comentarios

<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. Antes de instalar las bibliotecas centrales y de exportador de OpenCensus, asegúrate de haber preparado tu entorno para el desarrollo de Node.js.
2. La forma más fácil de instalar OpenCensus es con npm:

   npm install @opencensus/core
   npm install @opencensus/exporter-stackdriver

3. Coloca las declaraciones require que se muestran a continuación en la parte superior de la secuencia de comandos principal o punto de entrada de tu aplicación antes de colocar cualquier otro código:

Ver en GitHub Comentarios

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

Python

Instala las bibliotecas centrales de OpenCensus y las bibliotecas de exportador de Stackdriver con el siguiente comando:

pip install -r opencensus/requirements.txt

El archivo requirements.txt está en el repositorio de GitHub para estos ejemplos, python-docs-samples.

Usa OpenCensus para métricas

La instrumentación de tu código para usar OpenCensus con tus métricas implica tres pasos generales que debes seguir:

1. Importa los paquetes de estadísticas de OpenCensus y del exportador de Stackdriver en OpenCensus.
2. Inicializa el exportador de Stackdriver.
3. Usa la API de OpenCensus para instrumentar tu código.

Un ejemplo básico

El siguiente es un programa mínimo que ilustra estos pasos. Ejecuta un bucle y recopila medidas de latencia; cuando finaliza el ciclo, exporta las estadísticas a Cloud Monitoring y sale:

Go

Ver en GitHub Comentarios

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

Ver en GitHub Comentarios

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

Ver en GitHub Comentarios

'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

Ver en GitHub Comentarios

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

Cuando estos datos de métricas se exportan a Cloud Monitoring, puedes usarlos como cualquier otro dato.

El programa crea una vista de OpenCensus llamada task_latency_distribution. Esta string pasa a formar parte del nombre de la métrica cuando se exporta a Cloud Monitoring. Consulta Recupera descriptores de métricas para ver cómo se realiza la vista de OpenCensus como un descriptor de métrica de Cloud Monitoring.

A continuación, puedes usar el nombre de la vista como una string de búsqueda cuando seleccionas una métrica para representar. Por ejemplo, puedes escribirla en el campo Find resource type and metric (Buscar tipo de recurso y métrica) en el explorador de métricas. La siguiente captura de pantalla muestra el resultado:

Cada barra en el mapa de calor representa una ejecución del programa, y los componentes en colores de cada barra representan depósitos en la distribución de latencia. Consulta Métricas de OpenCensus en Cloud Monitoring para obtener más detalles sobre los datos del gráfico.

Documentación de OpenCensus

OpenCensus proporciona la documentación de referencia autorizada para tu API de métricas y el exportador de Stackdriver. La siguiente tabla proporciona vínculos a estos documentos de referencia:

Lenguaje	Documentación de referencia de la API	Documentación del exportador	Guía de inicio rápido
Go	API de Go	Exportadores de seguimiento y estadísticas	Métricas
Java	API de Java	Exportador de estadísticas	Métricas
NodeJS	API de NodeJS	Exportador de estadísticas	Métricas
Python	API de Python	Exportador de estadísticas	Métricas

Asigna los modelos

Se admite el uso directo de la API de Cloud Monitoring para las métricas personalizadas. Su uso se describe en Usa métricas personalizadas. De hecho, el exportador de OpenCensus para Cloud Monitoring usa esta API.

Incluso si no necesitas conocer los detalles específicos del uso de la API de Cloud Monitoring, la familiaridad con sus construcciones y terminología es útil para entender cómo Cloud Monitoring representa las métricas. Esta sección proporciona parte de esa información.

Una vez que tus métricas se transfieren a Cloud Monitoring, se almacenan dentro de las construcciones de Cloud Monitoring. Por ejemplo, puedes recuperar el descriptor de métrica (un tipo de la API de Monitoring) de una métrica personalizada. Consulta MetricDescriptor para obtener más información. Encuentras estos descriptores de métricas, por ejemplo, cuando creas gráficos para tus datos.

Terminología y conceptos

Las construcciones que usa la API de OpenCensus difieren de las que usa Cloud Monitoring; lo mismo sucede con algunos usos de la terminología. En los casos en los que Cloud Monitoring usa el término “métricas”, OpenCensus algunas veces usa el término “estadísticas”. Por ejemplo, el componente de OpenCensus que envía datos de métricas a Cloud Monitoring se denomina “exportador de estadísticas para Stackdrdiver”.

Consulta Métricas de OpenCensus a fin de obtener una descripción general del modelo de OpenCensus para métricas.

Los modelos de datos para las estadísticas de OpenCensus y las métricas de Cloud Monitoring no pertenecen a una asignación de 1:1. Muchos de los mismos conceptos existen en cada uno, pero no son directamente intercambiables.

• Por lo general, una vista de OpenCensus es análoga a MetricDescriptor en la API de Monitoring. Una vista describe cómo recopilar y agregar mediciones individuales. Todas las mediciones registradas se desglosan por etiquetas.

• Una etiqueta de OpenCensus es un par clave-valor. Esto corresponde, en general, a LabelDescriptor en la API de Monitoring. Las etiquetas te permiten abarcar información contextual que se puede usar para filtrar y agrupar métricas

• Una medida de OpenCensus describe datos de métricas para registrar. Una agregación de OpenCensus es una función que se aplica a los datos que se usan para resumirla. Se usan en la exportación para determinar la MetricKind, el ValueType y la unidad que se informan en el descriptor de métrica de Cloud Monitoring.

• Una medición de OpenCensus es un dato recopilado para medición. Las mediciones deben ser agregadas en vistas. De lo contrario, las mediciones individuales se descartan. Esta construcción es análoga a Point en la API de Monitoring. Cuando las mediciones se agregan en las vistas, los datos agregados se almacenan como datos para la visualización, análogos a TimeSeries en la API de Monitoring.

Métricas de OpenCensus en Cloud Monitoring

Puedes examinar las métricas exportadas en Cloud Monitoring. La captura de pantalla en Un ejemplo básico se tomó del Explorador de métricas. Si ejecutaste el programa de ejemplo, puedes usar el Explorador de métricas para ver tus datos.

Para consultar las métricas de un recurso supervisado con el Explorador de métricas, haz lo siguiente:

1. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:
   Ir a Monitoring
2. En el panel de navegación de Monitoring, haz clic en  Explorador de métricas.
3. Ingresa el nombre del recurso supervisado en el cuadro de texto Buscar tipo de recurso y métrica.

Puedes proporcionar el nombre de la vista de OpenCensus cuando especificas la métrica para restringir la búsqueda. Consulta Seleccionar métricas para obtener más información.

Cómo recuperar descriptores de métricas

Puedes recuperar datos de métricas mediante la API de Monitoring directamente. Para recuperar los datos de métricas, debes conocer los nombres de Cloud Monitoring en los que se exportaron las métricas de OpenCensus.

Una forma de obtener esta información es recuperar los descriptores de métricas que creó el exportador y encontrar el valor del campo type. Este valor incorpora el nombre de la vista de OpenCensus desde la que se exportó. Para obtener detalles sobre los descriptores de métricas, consulta MetricDescriptor.

Puedes ver los descriptores de métricas creados para las métricas exportadas mediante el widget Explorador de API (Prueba esta API) en la página de referencia del método metricDescriptors.list. Si quieres recuperar los descriptores de métricas para las métricas de OpenCensus mediante esta herramienta, haz lo siguiente:

1. Ingresa el nombre de tu proyecto en el campo name: projects/[PROJECT_ID]. Este documento usa un proyecto con el ID a-gcp-project.

2. Ingresa un filtro en el campo filter. El nombre de la vista de OpenCensus se convierte en parte del nombre de la métrica, por lo que puedes usar ese nombre para restringir la lista mediante un filtro como el siguiente:

   metric.type=has_substring("task_latency_distribution")

   Hay muchos descriptores de métricas en cualquier proyecto. El filtrado en una substring desde el nombre de la vista de OpenCensus los elimina en su mayoría.

3. Haz clic en el botón Ejecutar.

A continuación, se muestra el descriptor de métrica mostrado:

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

Esta línea en el descriptor de métrica te indica el nombre del tipo de métrica en Cloud Monitoring:

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

Con esta información, puedes recuperar manualmente los datos asociados con este tipo de métrica. Estos son también los datos que aparecen en un gráfico para esta métrica.

Recupera datos de métricas

Para recuperar de forma manual datos de series temporales de un tipo de métrica, puedes usar la herramienta Prueba esta API en la página de referencia del método timeSeries.list:

1. Ingresa el nombre de tu proyecto en el campo name: projects/[PROJECT_ID]
2. Ingresa un filtro en el campo filter para el tipo de métrica deseado: metric.type="custom.googleapis.com/opencensus/task_latency_distribution"
   • La clave, metric.type, es un campo en un tipo incorporado en una serie temporal. Consulta TimeSeries para obtener más detalles.
   • El valor es el valor type extraído del descriptor de métrica en Recuperación de descriptores de métrica.
3. Ingresa los límites temporales de la recuperación mediante la siguiente especificación de los valores para estos campos:
   • interval.endTime como una marca de tiempo, por ejemplo: 2018-10-11T15:48:38-04:00
   • interval.startTime (debe ser anterior a interval.endTime)
4. Haz clic en el botón Ejecutar.

A continuación, se muestra el resultado de la recuperación:

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

Estos datos mostrados aquí incluyen lo siguiente:

• Información acerca del recurso supervisado sobre el cual se recopilaron los datos. OpenCensus puede detectar de forma automática los recursos supervisados gce_instance, k8s_container y aws_ec2_instance. Estos datos provienen de un programa que se ejecuta en una instancia de Compute Engine. Para obtener información sobre el uso de otros recursos supervisados, consulta Establece recursos supervisados para el exportador.
• Descripción de la clase de métrica y el tipo de los valores.
• Los datos reales recopilados dentro del intervalo de tiempo solicitado.