Métricas personalizadas com OpenCensus

O Cloud Monitoring coleta automaticamente mais de mil métricas integradas de uma longa lista de recursos monitorados. No entanto, essas métricas não capturam dados específicos do aplicativo ou dados do sistema do lado do cliente. Essas métricas informam a latência de back-end ou o uso do disco, mas não quantas rotinas em segundo plano seu aplicativo gerou.

As métricas específicas do aplicativo são definidas e coletadas por você para receber informações que as métricas do Cloud Monitoring incorporadas não conseguem coletar. Essas métricas são coletadas usando uma API fornecida por uma biblioteca para instrumentar seu código. Depois, as métricas são enviadas para um aplicativo de back-end, como o Cloud Monitoring.

No Cloud Monitoring, as métricas específicas do aplicativo costumam ser chamadas "métricas personalizadas". Os termos são intercambiáveis. Elas também são chamadas “métricas definidas pelo usuário”.

No que diz respeito ao Cloud Monitoring, as métricas personalizadas podem ser usadas como as métricas incorporadas. Represente em gráficos, crie alertas para elas e monitore. A diferença é que você define as métricas, grava dados nelas e pode excluí-las. Não é possível fazer isso com as métricas integradas.

Há muitas maneiras de capturar métricas personalizadas, incluindo o uso direto da API Cloud Monitoring. O Cloud Monitoring recomenda que você use o OpenCensus para instrumentar seu código para coletar métricas personalizadas.

O que é o OpenCensus?

O OpenCensus é um projeto gratuito de código aberto com bibliotecas que:

  • dão suporte neutro de fornecedor para a coleta de dados de métricas e rastreamento em vários idiomas;
  • podem exportar os dados coletados para uma variedade de aplicativos de back-end, incluindo o Cloud Monitoring.

Para ver a lista atual de idiomas compatíveis, leia a página Language Support (em inglês). Para ver a lista atual de aplicativos de back-end para os quais os exportadores estão disponíveis, consulte Exporters (em inglês).

Por que usar o OpenCensus?

Embora o Cloud Monitoring forneça uma API compatível com definição e coleta de métricas personalizadas, trata-se de uma API reservada de nível inferior. O OpenCensus oferece uma API muito mais idiomática, com um exportador que envia seus dados de métrica para o Cloud Monitoring por meio da API Monitoring.

Além disso, o OpenCensus é um projeto de código aberto. É possível exportar os dados coletados usando uma biblioteca neutra de fornecedores em vez de uma biblioteca reservada.

O OpenCensus também tem um bom suporte para o rastreamento de aplicativos. Veja OpenCensus Tracing (em inglês) para ter uma visão geral. O Cloud Trace recomenda o uso do OpenCensus para instrumentação de rastreamento. Você pode usar uma única distribuição de bibliotecas para coletar dados de métrica e rastreamento dos seus serviços. Para informações sobre como usar o OpenCensus com Cloud Trace, consulte Bibliotecas de cliente para o Trace.

Antes de começar

Para usar o Cloud Monitoring, você precisa ter um projeto do Google Cloud com faturamento ativado. O projeto também precisa estar associado a um espaço de trabalho. O Cloud Monitoring usa espaços de trabalho para organizar projetos monitorados do Google Cloud.

Se você não tiver um projeto do Google Cloud, faça o seguinte:

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. Ative a API Monitoring. Para ver detalhes, leia Como ativar a API Monitoring.
  5. Se seu aplicativo estiver sendo executado fora do Google Cloud, o aplicativo deverá ser autenticado pelo projeto do Google Cloud. Para ver detalhes, leia Primeiros passos com autenticação.

Para ver informações sobre como associar seu projeto a um espaço de trabalho, leia Espaços de trabalho.

Como instalar o OpenCensus

Para usar o OpenCensus, você precisa disponibilizar as bibliotecas de métricas e o exportador do Stackdriver.

Go

O uso do OpenCensus requer o Go versão 1.11 ou posterior. As dependências são tratadas automaticamente para você.

Java

Para o Maven, adicione o seguinte ao elemento dependencies a seu arquivo pom.xml:
Ver no GitHub (em inglês) Feedback
<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 as bibliotecas do núcleo e do exportador do OpenCensus, prepare seu ambiente para o desenvolvimento do Node.js.
  2. A maneira mais fácil de instalar o OpenCensus é com o NPM:
    npm install @opencensus/core
    npm install @opencensus/exporter-stackdriver
  3. Coloque as instruções require mostradas abaixo na parte superior do script principal ou do ponto de entrada do seu aplicativo, antes de qualquer outro código:
Ver no GitHub (em inglês) Feedback
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

Instale o núcleo do OpenCensus e as bibliotecas do exportador do Stackdriver usando o seguinte comando:

pip install -r opencensus/requirements.txt

O arquivo requirements.txt está no repositório do GitHub para essas amostras, python-docs-samples.

Como usar o OpenCensus para métricas

Instrumentar seu código para usar o OpenCensus para métricas envolve três etapas gerais:

  1. Importar as estatísticas do OpenCensus e os pacotes exportadores do OpenCensus Stackdriver
  2. Inicializar o exportador do Stackdriver
  3. Usar a API OpenCensus para instrumentar seu código

Um exemplo simples

A seguir, veja um programa mínimo que ilustra essas etapas. Ele executa um loop e coleta as medidas de latência. Quando o loop termina, ele exporta as estatísticas para o Cloud Monitoring e é encerrado:

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

Ver no GitHub (em inglês) Feedback

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 no GitHub (em inglês) Feedback
'use strict';

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

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

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

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

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

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

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

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

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

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

Python


from random import random
import time

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

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()
Quando esses dados de métricas são exportados para o Cloud Monitoring, você pode usá-los como qualquer outro dado.

O programa cria uma visualização do OpenCensus chamada task_latency_distribution. Essa string se torna parte do nome da métrica quando é exportada para o Cloud Monitoring. Consulte Como recuperar descritores de métrica para ver como a visualização do OpenCensus é notada como um descritor de métrica do Cloud Monitoring.

Portanto, use o nome da visualização como uma string de pesquisa ao selecionar uma métrica para o gráfico. Por exemplo, é possível digitá-lo no campo Find resource type and metric do Metrics Explorer. A captura de tela abaixo mostra o resultado:

Métricas do OpenCensus no Cloud Monitoring.

Cada barra no mapa de calor representa uma execução do programa, e os componentes coloridos de cada barra representam os buckets na distribuição de latência. Veja métricas do OpenCensus no Cloud Monitoring para mais detalhes sobre os dados por trás do gráfico.

Documentação do OpenCensus

O OpenCensus apresenta a documentação de referência oficial para sua API de métricas e para o exportador do Stackdriver. A tabela a seguir apresenta links para esses documentos de referência:

Idioma Documentação de referência de APIs Documentação do exportador Guia de início rápido
Go API Go Stats and Trace Exporters (em inglês) Metrics (em inglês)
Java API Java Stats Exporter (em inglês) Metrics (em inglês)
NodeJS API NodeJS Stats Exporter (em inglês) Metrics (em inglês)
Python API Python Stats Exporter (em inglês) Metrics (em inglês)

Como mapear os modelos

O uso direto da API Cloud Monitoring para métricas personalizadas é compatível. O uso é descrito em Como usar métricas personalizadas. Na verdade, o exportador do OpenCensus para o Cloud Monitoring usa essa API.

Mesmo que você não precise saber as especificidades do uso da API Cloud Monitoring, a familiaridade com as construções e terminologia é útil para entender como o Cloud Monitoring representa as métricas. Esta seção apresenta algumas dessas informações.

Depois que suas métricas forem processadas no Cloud Monitoring, elas serão armazenadas nas construções do Cloud Monitoring. Você pode, por exemplo, recuperar o descritor de métrica (um tipo da API Monitoring) de uma métrica personalizada. Consulte MetricDescriptor para ver mais informações. Você encontra esses descritores de métrica, por exemplo, ao criar gráficos para seus dados.

Terminologia e conceitos

As construções usadas pela API OpenCensus diferem daquelas usadas pelo Cloud Monitoring, assim como parte da terminologia. Enquanto o Cloud Monitoring se refere a “métricas”, o OpenCensus às vezes se refere a “estatísticas”. Por exemplo, o componente do OpenCensus que envia dados de métrica para o Cloud Monitoring é chamado “exportador de estatísticas do Stackdriver”.

Veja OpenCensus Metrics (em inglês) para ter uma visão geral do modelo do OpenCensus para métricas.

Os modelos de dados para as estatísticas do OpenCensus e as métricas do Cloud Monitoring não se enquadram em um mapeamento 1:1 puro. Muitos dos mesmos conceitos existem em cada um deles, mas não são diretamente intercambiáveis.

  • Uma visualização do OpenCensus é, geralmente, análoga a MetricDescriptor na API Monitoring. Uma visualização descreve como coletar e agregar medições individuais. Todas as medições registradas são divididas por tags.

  • Uma tag do OpenCensus é um par de chave-valor. Isso, geralmente corresponde, a LabelDescriptor na API Monitoring. Com as tags, é possível capturar informações contextuais que podem ser usadas para filtrar e agrupar métricas

  • Uma medida do OpenCensus descreve os dados da métrica a serem registrados. Uma agregação do OpenCensus é uma função aplicada aos dados usados para resumi-los. Eles são usados na exportação para determinar MetricKind, ValueType e a unidade informada no descritor de métrica do Cloud Monitoring.

  • Uma medição do OpenCensus é um ponto de dados coletado para a medida. As medições precisam ser agregadas em visualizações. Caso contrário, as medições individuais serão descartadas. Essa construção é análoga a um Point na API Monitoring. Quando as medidas são agregadas nas visualizações, os dados agregados são armazenados como dados de exibição, de maneira análoga a um TimeSeries na API Monitoring.

Métricas do OpenCensus no Cloud Monitoring

Você pode examinar as métricas exportadas no Cloud Monitoring. A captura de tela em um exemplo básico foi retirada do Metrics Explorer. Se você executou o programa de amostra, poderá usar o Metrics Explorer para examinar seus dados.

Para visualizar as métricas de um recurso monitorado usando o Metrics Explorer, faça o seguinte:

  1. No Console do Google Cloud, acesse Monitoring ou use o botão
    Acessar Monitoring
  2. No painel de navegação do Monitoring, clique em Metrics Explorer.
  3. Digite o nome do recurso monitorado na caixa de texto Find resource type and metric.

Digite o nome da visualização do OpenCensus ao especificar a métrica para restringir a pesquisa. Consulte Como selecionar métricas para ver mais informações.

Como recuperar descritores de métrica

Recupere os dados da métrica usando diretamente a API Monitoring. Para recuperar os dados de métricas, você precisa saber os nomes do Cloud Monitoring para os quais as métricas do OpenCensus foram exportadas.

Uma maneira de conseguir essas informações é recuperar os descritores de métrica que foram criados pelo exportador e encontrar o valor do campo type. Esse valor incorpora o nome da visualização do OpenCensus da qual ele foi exportado. Para ver mais detalhes sobre os descritores de métrica, consulte MetricDescriptor.

É possível ver os descritores de métrica criados para as métricas exportadas usando o widget da API Explorer (Try this API) na página de referência para o método metricDescriptors.list. Para recuperar os descritores de métricas para as métricas do OpenCensus usando essa ferramenta:

  1. Digite o nome do projeto no campo name: projects/[PROJECT_ID] Este documento usa um projeto com o ID a-gcp-project.

  2. Digite um filtro no campo filter. O nome da visualização do OpenCensus se torna parte do nome da métrica. Assim, é possível usar esse nome para restringir a listagem, fornecendo um filtro como este:

    metric.type=has_substring("task_latency_distribution")

    Há muitos descritores de métricas em qualquer projeto. Fazer a filtragem em uma substring do nome da visualização do OpenCensus elimina a maioria deles.

  3. Clique em Execute.

O exemplo seguinte mostra o descritor de métrica retornado:

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

Essa linha no descritor de métrica informa o nome do tipo de métrica no Cloud Monitoring:

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

Com essas informações, é possível recuperar manualmente os dados associados a esse tipo de métrica. Esses também são os dados exibidos em um gráfico para essa métrica.

Como recuperar dados de métrica

Para recuperar manualmente dados de série temporal de um tipo de métrica, use a ferramenta Try this API na página de referência do método timeSeries.list:

  1. Digite o nome do projeto no campo name: projects/[PROJECT_ID]
  2. Digite um filtro no campo filter para o tipo de métrica desejado: metric.type="custom.googleapis.com/opencensus/task_latency_distribution"
  3. Digite os limites de tempo para a recuperação especificando valores para estes campos:
    • interval.endTime como carimbo de data/hora, por exemplo: 2018-10-11T15:48:38-04:00
    • interval.startTime (precisa ser anterior a interval.endTime)
  4. Clique em Execute.

A seguir, é mostrado o resultado de uma dessas recuperações:

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

Esses dados retornados aqui incluem:

  • informações sobre o recurso monitorado do qual os dados foram coletados. O OpenCensus detecta automaticamente os recursos monitorados gce_instance, k8s_container e aws_ec2_instance. Esses dados são provenientes de um programa executado em uma instância do Compute Engine. Para ver informações sobre como usar outros recursos monitorados, leia Set monitored resource for exporter (em inglês);
  • a descrição do tipo de métrica e o tipo dos valores;
  • os pontos de dados reais coletados no intervalo de tempo solicitado.