Membuat metrik yang ditentukan pengguna dengan OpenCensus

OpenCensus adalah project open source gratis yang memiliki library:

  • Berikan dukungan yang tidak terikat dengan vendor untuk pengumpulan metrik dan data trace dalam berbagai bahasa.
  • Dapat mengekspor data yang dikumpulkan ke berbagai aplikasi backend, termasuk Cloud Monitoring, dengan 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 mengirim data metrik ke Cloud Monitoring melalui Monitoring API untuk Anda.

OpenCensus juga memiliki dukungan yang baik untuk pelacakan aplikasi; lihat Pelacakan OpenCensus untuk mengetahui ringkasan umum. Cloud Trace merekomendasikan penggunaan OpenCensus untuk instrumentasi rekaman aktivitas. Untuk mengumpulkan data metrik dan trace dari layanan, Anda dapat menggunakan distribusi library tunggal. 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 Anda dan dengan 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 Memulai 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. 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 informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Java

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

Untuk Maven, tambahkan kode berikut ke elemen dependencies dalam 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 informasi selengkapnya, lihat 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 informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Instal library pengekspor Stackdriver dan OpenCensus core menggunakan perintah berikut:

pip install -r opencensus/requirements.txt

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

Menulis metrik yang ditentukan pengguna dengan OpenCensus

Menginstrumentasikan kode untuk menggunakan OpenCensus untuk metrik melibatkan tiga langkah:

  1. Impor statistik OpenCensus dan paket pengekspor OpenCensus Stackdriver.
  2. Lakukan inisialisasi pengekspor Stackdriver.
  3. Gunakan 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, dan setelah loop selesai, statistik mengekspor statistik ke Cloud Monitoring dan keluar:

Go

Untuk mengautentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk informasi selengkapnya, lihat 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 informasi selengkapnya, lihat 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 informasi selengkapnya, lihat 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 informasi selengkapnya, lihat 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. Baca bagian Mengambil deskripsi metrik untuk mengetahui cara tampilan OpenCensus direalisasikan sebagai deskriptor metrik Cloud Monitoring. Oleh karena itu, Anda dapat menggunakan nama tampilan sebagai string penelusuran saat memilih metrik yang akan dibuat diagram.

Jika telah menjalankan program contoh, Anda dapat menggunakan Metrics Explorer untuk melihat data Anda:
  1. Pada 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 queue distribution.
    4. Klik Apply.

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

Metrik dari OpenCensus di Cloud Monitoring.

Setiap batang di peta panas mewakili satu kali eksekusi program, dan komponen berwarna di setiap batang mewakili 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, menetapkan pemberitahuan, membaca, dan memantaunya.

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

Misalnya, screenshot yang ditampilkan di bagian sebelumnya berasal dari Metrics Explorer. Saat Anda 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 mengetahui detail tentang deskripsi metrik, lihat MetricDescriptor.

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

  1. Buka halaman referensi metricDescriptors.list.
  2. Di widget Coba API ini pada 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 deskriptif metrik dalam sebuah proyek. Pemfilteran memungkinkan Anda menghilangkan deskriptor 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 utama adalah kolom dalam jenis yang disematkan dalam deret waktu. Lihat TimeSeries untuk mengetahui detailnya.

    3. Klik Jalankan.

Berikut 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 dalam deskriptor metrik memberi tahu Anda nama jenis metrik di Cloud Monitoring:

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

Sekarang Anda 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 hal berikut:

  1. Buka halaman referensi timeSeries.list.
  2. Di widget Coba API ini pada 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.

Berikut 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 pada instance Compute Engine. Untuk informasi tentang penggunaan 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 mewakili metrik OpenCensus

Penggunaan langsung Cloud Monitoring API untuk metrik yang ditentukan pengguna didukung. Penggunaannya dijelaskan dalam 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 beberapa penggunaan terminologi. Jika Cloud Monitoring merujuk pada “metrik”, OpenCensus terkadang merujuk pada “statistik”. Misalnya, komponen OpenCensus yang mengirimkan 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 ada di masing-masing konsep, tetapi mereka tidak dapat dipertukarkan secara langsung.

  • Tampilan OpenCensus serupa 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.

  • Pengukuran 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 dianalogikan dengan Point di Monitoring API. Saat pengukuran digabungkan dalam tampilan, data gabungan akan disimpan sebagai data tampilan, serupa dengan TimeSeries di Monitoring API.

Langkah selanjutnya