Métricas personalizadas con OpenCensus

Stackdriver Monitoring recopila de forma automática más de mil métricas incorporadas 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 abarcar información que las métricas de Stackdriver Monitoring incorporadas no pueden. Puedes abarcar estas métricas mediante una API que proporciona una biblioteca para instrumentar tu código y, luego, enviar las métricas a una aplicación de backend como Stackdriver Monitoring.

En Stackdriver 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 Stackdriver Monitoring, las métricas personalizadas se pueden utilizar como las métricas integradas. Puedes realizar gráficos y establecer alertas con ellas, y puedes supervisarlas. La diferencia es que 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 abarcar métricas personalizadas, incluido el uso de la API nativa de Stackdriver Monitoring. Stackdriver Monitoring recomienda que uses OpenCensus para instrumentar tu código con el fin de recopilar métricas personalizadas.

¿Qué es OpenCensus?

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

  • Proporcionan asistencia 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 Stackdriver 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 Stackdriver 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 Stackdriver 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. Stackdriver 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 Stackdriver Trace, consulta Bibliotecas cliente para Trace.

Antes de comenzar

Para usar Stackdriver 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. Stackdriver 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 GCP Console, en la página de selección de proyecto, selecciona o crea un proyecto de GCP.

    Ir a la página de selección de proyecto

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  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:
<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:
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 el ciclo finaliza, exporta las estadísticas a Stackdriver Monitoring y sale:

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
        print("Latency {}: {}".format(num, ms))

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

    # 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 Stackdriver Monitoring, puedes usarlos como cualquier otro dato.

El programa crea una vista de OpenCensus llamada task_latency_distribution. Esta string se convierte en parte del nombre de la métrica cuando se exporta a Stackdriver Monitoring. Consulta Recupera descriptores de métricas para ver cómo se realiza la vista de OpenCensus como un descriptor de métrica de Stackdriver 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. En la siguiente captura de pantalla, se muestra el resultado:

Métricas de OpenCensus en Stackdriver Monitoring

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 las métricas de OpenCensus en Stackdriver 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

La API de Stackdriver Monitoring nativa es compatible con las métricas personalizadas; su uso se describe en Usa métricas personalizadas. De hecho, el exportador de OpenCensus para Stackdriver Monitoring usa esta API.

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

Una vez que tus métricas se transfieren a Stackdriver Monitoring, se almacenan dentro de las construcciones de Stackdriver 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 Stackdriver Monitoring; lo mismo sucede con algunos usos de la terminología. Cuando Stackdriver Monitoring hace referencia a “métricas”, OpenCensus algunas veces hace referencia a “estadísticas”. Por ejemplo, el componente de OpenCensus que envía datos de métricas a Stackdriver 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 Stackdriver Monitoring no se incluyen en 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. Estos se usan en la exportación para determinar MetricKind, ValueType y la unidad sobre la que se informa en el descriptor de métricas de Stackdriver 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 Stackdriver Monitoring

Puedes examinar las métricas exportadas en Stackdriver 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. Si el Explorador de métricas aparece en el panel de navegación, haz clic en Explorador de métricas. De lo contrario, selecciona Recursos y, luego, selecciona 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 la métrica, debes conocer los nombres de Stackdriver 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 Stackdriver 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"
  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.