Membuat metrik yang ditentukan pengguna dengan OpenCensus

OpenCensus adalah project open source gratis dengan library yang:

  • Berikan dukungan yang tidak bergantung pada vendor untuk pengumpulan metrik dan data trace dalam berbagai bahasa.
  • Dapat mengekspor data yang dikumpulkan ke berbagai aplikasi backend, termasuk Cloud Monitoring, menggunakan pengekspor.

Meskipun Cloud Monitoring menyediakan API yang mendukung penentuan dan pengumpulan metrik yang ditentukan pengguna, Cloud Monitoring adalah API eksklusif tingkat rendah. OpenCensus menyediakan API yang mengikuti gaya komunitas bahasa, bersama dengan pengekspor yang mengirimkan data metrik ke Cloud Monitoring melalui Monitoring API untuk Anda.

OpenCensus juga memiliki dukungan yang baik untuk pelacakan aplikasi; lihat Pelacakan OpenCensus untuk ringkasan umum. Cloud Trace merekomendasikan penggunaan OpenCensus untuk instrumentasi rekaman aktivitas. Untuk mengumpulkan data metrik dan trace dari layanan, Anda dapat menggunakan satu distribusi library. Untuk informasi tentang penggunaan OpenCensus dengan Cloud Trace, lihat Library Klien untuk Trace.

Sebelum memulai

Untuk menggunakan Cloud Monitoring, Anda harus memiliki project Google Cloud dengan penagihan yang diaktifkan. Jika perlu, lakukan hal berikut:

  1. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  2. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

  3. Pastikan Monitoring API diaktifkan. Untuk mengetahui detailnya, lihat Mengaktifkan Monitoring API.

  4. Untuk aplikasi yang berjalan di luar Google Cloud, project Google Cloud Anda harus mengautentikasi aplikasi Anda. Biasanya, Anda mengonfigurasi autentikasi dengan membuat akun layanan untuk project dan mengonfigurasi variabel lingkungan.

    Untuk aplikasi yang Anda jalankan pada instance Amazon Elastic Compute Cloud (Amazon EC2), buat akun layanan untuk project AWS Connector instance.

    Untuk informasi tentang cara membuat akun layanan, lihat Mulai menggunakan autentikasi.

Instal OpenCensus

Untuk menggunakan metrik yang dikumpulkan oleh OpenCensus di project Google Cloud, Anda harus menyediakan library metrik OpenCensus dan pengekspor Stackdriver untuk aplikasi Anda. Pengekspor Stackdriver mengekspor metrik yang dikumpulkan OpenCensus ke project Google Cloud Anda. Anda kemudian dapat menggunakan Cloud Monitoring untuk membuat diagram atau memantau metrik tersebut.

Go

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Penggunaan OpenCensus memerlukan Go versi 1.11 atau yang lebih tinggi. Dependensi ditangani secara otomatis untuk Anda.

Java

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Untuk Maven, tambahkan kode berikut ke elemen dependencies di file pom.xml Anda: 
<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

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

  1. Sebelum menginstal library inti dan pengekspor OpenCensus, pastikan Anda telah menyiapkan lingkungan untuk pengembangan Node.js.
  2. Cara termudah untuk menginstal OpenCensus adalah dengan npm: 
    npm install @opencensus/core
npm install @opencensus/exporter-stackdriver
  3. Tempatkan pernyataan require yang ditampilkan di bawah ini di bagian atas skrip utama atau titik entri aplikasi Anda, sebelum kode lainnya:
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Instal library pengekspor inti dan Stackdriver OpenCensus menggunakan perintah berikut:

pip install -r opencensus/requirements.txt

File requirements.txt ada di repositori GitHub untuk contoh ini, python-docs-samples.

Menulis metrik buatan pengguna dengan OpenCensus

Melengkapi kode untuk menggunakan OpenCensus untuk metrik melibatkan tiga langkah:

  1. Impor statistik OpenCensus dan paket pengekspor OpenCensus Stackdriver.
  2. Lakukan inisialisasi pengekspor Stackdriver.
  3. Menggunakan OpenCensus API untuk menginstrumentasikan kode Anda.

Contoh berikut adalah program minimal yang menulis data metrik menggunakan OpenCensus. Program ini menjalankan loop dan mengumpulkan pengukuran latensi, lalu setelah loop selesai, statistik akan diekspor ke Cloud Monitoring dan keluar:

Go

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

'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

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


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()
Saat data metrik ini diekspor ke Cloud Monitoring, Anda dapat menggunakannya seperti data lainnya.

Program ini membuat tampilan OpenCensus yang disebut task_latency_distribution. String ini menjadi bagian dari nama metrik saat diekspor ke Cloud Monitoring. Lihat bagian Mengambil deskriptor metrik untuk melihat cara tampilan OpenCensus direalisasikan sebagai deskriptor metrik Cloud Monitoring. Oleh karena itu, Anda dapat menggunakan nama tampilan sebagai string penelusuran saat memilih metrik untuk dibuat diagram.

Jika telah menjalankan program contoh, Anda dapat menggunakan Metrics Explorer untuk melihat data Anda:

  1. Di panel navigasi Konsol Google Cloud, pilih Monitoring, lalu pilih  Metrics Explorer:

    Buka Metrics Explorer

  2. Pada elemen Metrik, luaskan menu Pilih metrik, masukkan OpenCensus/task_latency_distribution di panel filter, lalu gunakan submenu untuk memilih jenis dan metrik resource tertentu:
    1. Di menu Active resources, pilih resource yang dipantau. Jika Anda menjalankan program di lingkungan lokal, pilih Global.
    2. Di menu Kategori metrik aktif, pilih Kustom.
    3. Di menu Active metrics, pilih Task latency distribution.
    4. Klik Terapkan.

Screenshot berikut menunjukkan deret waktu yang dikumpulkan setelah menjalankan program di lingkungan lokal:

Metrik dari OpenCensus di Cloud Monitoring.

Setiap batang dalam peta panas menyatakan satu kali program dijalankan, dan komponen yang berwarna di setiap batang merepresentasikan bucket dalam distribusi latensi.

Membaca metrik OpenCensus di Cloud Monitoring

Anda menggunakan metrik yang ditentukan pengguna, termasuk metrik yang ditulis oleh OpenCensus, seperti metrik bawaan. Anda dapat membuat diagram, menyetel pemberitahuan, membacanya, dan memantaunya.

Bagian ini menggambarkan cara menggunakan APIs Explorer untuk membaca data metrik. Untuk informasi tentang cara membaca data metrik dengan menggunakan Cloud Monitoring API atau menggunakan library klien, lihat dokumen berikut:

Misalnya, screenshot yang ditampilkan di bagian sebelumnya berasal dari Metrics Explorer. Saat menggunakan alat diagram, sebaiknya gunakan nama tampilan OpenCensus untuk memfilter daftar metrik. Untuk mengetahui informasi selengkapnya, lihat Memilih metrik saat menggunakan Metrics Explorer.

Mengambil deskriptor metrik

Untuk mengambil data metrik dengan menggunakan Monitoring API secara langsung, Anda perlu mengetahui nama Cloud Monitoring yang menjadi tujuan ekspor metrik OpenCensus. Anda dapat menentukan nama-nama ini dengan mengambil deskripsi metrik yang dibuat oleh pengekspor, lalu melihat kolom type. Untuk detail tentang deskripsi metrik, lihat MetricDescriptor.

Untuk melihat deskripsi metrik yang dibuat untuk metrik yang diekspor, lakukan tindakan berikut:

  1. Buka halaman referensi metricDescriptors.list.

  2. Dalam widget Coba API ini di halaman referensi, lengkapi kolom berikut:

    1. Masukkan nama project Anda di kolom name. Gunakan struktur nama berikut projects/PROJECT_ID. Dokumen ini menggunakan project dengan ID a-gcp-project.

    2. Masukkan filter ke kolom filter. Ada banyak deskriptor metrik dalam sebuah proyek. Pemfilteran memungkinkan Anda menghilangkan penjelasan yang tidak menarik.

      Misalnya, karena nama tampilan OpenCensus menjadi bagian dari nama metrik, Anda dapat menambahkan filter seperti ini:

      metric.type=has_substring("task_latency_distribution")

      metric.type kunci adalah kolom dalam jenis yang disematkan dalam deret waktu. Lihat TimeSeries untuk mengetahui detailnya.

    3. Klik Jalankan.

Berikut ini adalah deskripsi metrik yang ditampilkan:

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

Baris pada deskriptor metrik ini memberi tahu Anda nama jenis metrik di Cloud Monitoring:

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

Anda sekarang memiliki informasi yang diperlukan untuk mengambil data yang terkait dengan jenis metrik secara manual. Nilai kolom type juga ditampilkan di Konsol Google Cloud saat Anda membuat diagram metrik.

Mengambil data metrik

Untuk mengambil data deret waktu secara manual dari jenis metrik, lakukan tindakan berikut:

  1. Buka halaman referensi timeSeries.list.

  2. Dalam widget Coba API ini di halaman referensi, lengkapi kolom berikut:

    1. Masukkan nama project Anda di kolom name. Gunakan struktur nama berikut projects/PROJECT_ID.

    2. Di kolom filter, masukkan nilai berikut:

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

    3. Masukkan nilai untuk kolom interval.startTime dan interval.endTime. Nilai ini harus dimasukkan sebagai stempel waktu, misalnya 2018-10-11T15:48:38-04:00. Pastikan nilai startTime lebih awal dari nilai endTime.

    4. Klik tombol Execute.

Tabel berikut menunjukkan hasil dari salah satu pengambilan tersebut:

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

Data metrik yang ditampilkan mencakup hal berikut:

  • Informasi tentang resource yang dimonitor tempat data dikumpulkan. OpenCensus dapat otomatis mendeteksi resource yang dimonitor gce_instance, k8s_container, dan aws_ec2_instance. Data ini berasal dari program yang dijalankan di instance Compute Engine. Untuk mengetahui informasi tentang cara menggunakan resource lain yang dimonitor, lihat Menetapkan resource yang dimonitor untuk pengekspor.
  • Deskripsi jenis metrik dan jenis nilai.
  • Titik data aktual yang dikumpulkan dalam interval waktu yang diminta.

Cara Monitoring merepresentasikan metrik OpenCensus

Penggunaan langsung Cloud Monitoring API untuk metrik yang ditentukan pengguna didukung. Penggunaannya dijelaskan dalam artikel Membuat metrik yang ditentukan pengguna dengan API. Bahkan, pengekspor OpenCensus untuk Cloud Monitoring menggunakan API ini untuk Anda. Bagian ini memberikan beberapa informasi tentang cara Cloud Monitoring merepresentasikan metrik yang ditulis oleh OpenCensus.

Konstruksi yang digunakan oleh OpenCensus API berbeda dengan konstruksi yang digunakan oleh Cloud Monitoring, begitu juga dengan beberapa penggunaan terminologi. Jika Cloud Monitoring merujuk pada “metrik”, OpenCensus terkadang mengacu pada “statistik”. Misalnya, komponen OpenCensus yang mengirim data metrik ke Cloud Monitoring disebut “pengekspor statistik untuk Stackdrdiver”.

Untuk ringkasan model OpenCensus untuk metrik, lihat Metrik OpenCensus.

Model data untuk statistik OpenCensus dan metrik Cloud Monitoring tidak termasuk dalam pemetaan 1:1 yang rapi. Banyak konsep yang sama terdapat di masing-masing konsep, tetapi mereka tidak dapat dipertukarkan secara langsung.

  • Tampilan OpenCensus setara dengan MetricDescriptor di Monitoring API. Tampilan menjelaskan cara mengumpulkan dan menggabungkan pengukuran individual. Tag disertakan dengan semua pengukuran yang dicatat.

  • Tag OpenCensus adalah pasangan nilai kunci. Tag OpenCensus umumnya sesuai dengan LabelDescriptor di Monitoring API. Tag memungkinkan Anda menangkap informasi kontekstual yang dapat digunakan untuk memfilter dan mengelompokkan metrik.

  • Ukuran OpenCensus menjelaskan data metrik yang akan dicatat. Agregasi OpenCensus adalah fungsi yang diterapkan pada data yang digunakan untuk meringkasnya. Fungsi ini digunakan dalam mengekspor untuk menentukan MetricKind, ValueType, dan unit yang dilaporkan dalam deskriptor metrik Cloud Monitoring.

  • Pengukuran OpenCensus adalah titik data yang dikumpulkan. Pengukuran harus digabungkan ke dalam tampilan. Jika tidak, setiap pengukuran akan dihapus. Pengukuran OpenCensus serupa dengan Point di Monitoring API. Jika pengukuran digabungkan dalam tampilan, data gabungan akan disimpan sebagai data tampilan, yang setara dengan TimeSeries di Monitoring API.

Langkah selanjutnya