OpenCensus의 커스텀 측정항목

Cloud Monitoring은 긴 모니터링 리소스 목록에서 1,000개 이상의 기본 제공 측정항목을 자동으로 수집합니다. 그러나 이러한 측정항목은 애플리케이션별 데이터 또는 클라이언트 시스템 데이터를 캡처할 수 없습니다. 이러한 측정항목은 백엔드 지연 시간 또는 디스크 사용량에 대한 정보를 제공할 수 있지만 애플리케이션이 생성한 백그라운드 루틴 수를 알려줄 수 없습니다.

애플리케이션별 측정항목은 Cloud Monitoring 기본 제공 측정항목에서 수집할 수 없는 정보를 캡처하기 위해 정의하고 수집하는 측정항목입니다. 라이브러리에서 제공하는 API로 코드를 사용하여 이러한 측정항목을 캡처한 다음 Cloud Monitoring과 같은 백엔드 애플리케이션에 측정항목을 전송합니다.

Cloud Monitoring에서 애플리케이션별 측정항목은 일반적으로 '커스텀 측정항목'이라고 합니다. 용어는 서로 바꿔서 사용할 수 있으며, '사용자 정의 측정항목'이라고도 합니다.

Cloud Monitoring과 관련하여 커스텀 측정항목은 기본 제공 측정항목처럼 사용할 수 있습니다. 차트를 작성하고 경고를 설정하고 모니터링할 수 있습니다. 차이점은 사용자가 측정항목을 정의하고 데이터를 작성하거나 삭제할 수 있다는 것입니다. 기본 측정항목으로는 이러한 작업을 수행할 수 없습니다.

Cloud Monitoring API 사용 등 커스텀 측정항목을 캡처하는 방법은 많습니다. Cloud Monitoring에서는 OpenCensus를 이용해 커스텀 측정항목을 수집하기 위한 코드를 사용하는 것이 좋습니다.

OpenCensus란 무엇인가요?

OpenCensus는 무료 오픈소스 프로젝트로, 라이브러리에서

  • 다양한 언어로 측정항목 및 trace 데이터 수집에 대한 공급업체 중립적인 지원을 제공합니다.
  • 수집된 데이터를 Cloud Monitoring을 포함한 다양한 백엔드 애플리케이션으로 내보낼 수 있습니다.

현재 지원되는 언어 목록을 보려면 Language Support를 참조하세요. 현재 내보내기를 사용할 수 있는 백엔드 애플리케이션 목록을 보려면 Exporters를 참조하세요.

OpenCensus를 사용해야 하는 이유

Cloud Monitoring이 커스텀 측정항목을 정의하고 수집하는 API를 제공하긴 하지만 이는 낮은 수준의 독점 API입니다. OpenCensus는 Monitoring API를 통해 훨씬 자연스러운 API를 제공할 뿐만 아니라 Cloud Monitoring에 측정항목을 전송하는 내보내기를 제공합니다.

또한 OpenCensus는 오픈소스 프로젝트입니다. 독점 라이브러리 대신 공급업체 중립적인 라이브러리를 사용하여 수집된 데이터를 내보낼 수 있습니다.

OpenCensus는 애플리케이션 추적 기능도 훌륭히 지원합니다. 이에 대한 정보는 OpenCensus Tracing을 참조하세요. Cloud Trace는 OpenCensus를 사용하여 추적을 수행하도록 권장합니다. 단일 라이브러리 분산을 사용하여 서비스에서 측정항목 및 추적 데이터를 모두 수집할 수 있습니다. Cloud Trace에서 OpenCensus 사용에 대한 자세한 내용은 Trace용 클라이언트 라이브러리를 참조하세요.

시작하기 전에

Cloud Monitoring을 사용하려면 결제가 사용 설정된 Google Cloud 프로젝트가 있어야 합니다. 또한 프로젝트가 작업공간에 연결되어 있어야 합니다. Cloud Monitoring은 작업공간을 사용하여 모니터링 대상의 Google Cloud 프로젝트를 정리합니다.

Google Cloud 프로젝트가 없는 경우 다음을 수행합니다.

  1. Google 계정으로 로그인합니다.

    아직 계정이 없으면 새 계정을 등록하세요.

  2. Cloud Console의 프로젝트 선택기 페이지에서 Cloud 프로젝트를 선택하거나 만듭니다.

    프로젝트 선택기 페이지로 이동

  3. Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다. 프로젝트에 결제가 사용 설정되어 있는지 확인하는 방법을 알아보세요.

  4. Monitoring API를 사용 설정합니다. 자세한 내용은 Monitoring API 사용 설정을 참조하세요.
  5. 애플리케이션이 Google Cloud 외부에서 실행되는 경우 Google Cloud 프로젝트에서 애플리케이션을 인증해야 합니다. 자세한 내용은 인증 시작하기를 참조하세요.

프로젝트를 작업공간과 연결하는 방법에 대한 자세한 내용은 작업공간을 참조하세요.

OpenCensus 설치하기

OpenCensus를 사용하려면 측정항목 라이브러리와 Stackdriver 내보내기 도구를 사용하도록 설정해야 합니다.

Go

OpenCensus를 사용하려면 Go 버전 1.11 이상이 필요합니다. 종속 항목은 자동으로 처리됩니다.

자바

Maven을 사용하는 경우 pom.xml 파일의 dependencies 요소에 다음을 추가합니다.
<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. OpenCensus 코어 및 내보내기 라이브러리를 설치하기 전에 Node.js 개발을 위한 환경이 준비되었는지 확인합니다.
  2. OpenCensus를 설치하는 가장 쉬운 방법은 npm을 사용하는 것입니다.
    npm install @opencensus/core
    npm install @opencensus/exporter-stackdriver
  3. 다음과 같이 애플리케이션의 기본 스크립트 맨 위 또는 진입점에 표시된 require 문을 다른 모든 코드 앞에 배치합니다.
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');

Python

다음 명령어를 사용하여 OpenCensus 코어 및 Stackdriver 내보내기 라이브러리를 설치합니다.

pip install -r opencensus/requirements.txt

requirements.txt 파일은 python-docs-samples 샘플의 GitHub 저장소에 있습니다.

측정항목에 OpenCensus 사용하기

측정항목에 OpenCensus를 사용하기 위한 코드를 설치하려면 다음 3단계를 거칩니다.

  1. OpenCensus 통계와 OpenCensus Stackdriver 내보내기 도구 패키지를 불러옵니다.
  2. Stackdriver 내보내기 도구를 초기화합니다.
  3. OpenCensus API를 사용하여 코드를 설치합니다.

기본 예제

다음은 이 단계를 최소화하여 설명하는 프로그램입니다. 루프를 실행하고 지연 시간 값을 수집하며 루프가 끝나면 Cloud Monitoring으로 통계를 내보내고 종료합니다.

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")
}

자바


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

        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()
이 측정항목 데이터를 Cloud Monitoring으로 내보낼 때 다른 데이터와 마찬가지로 사용할 수 있습니다.

프로그램에서 task_latency_distribution라는 OpenCensus 를 만듭니다. 이 문자열은 Cloud Monitoring으로 내보낼 때 측정항목 이름의 일부가 됩니다. OpenCensus 뷰가 Cloud Monitoring 측정항목 설명으로 구현되는 방법을 보려면 측정항목 설명 검색을 참조하세요.

따라서 차트에서 측정항목을 선택할 때 보기 이름을 검색 문자열로 사용할 수 있습니다. 측정항목 내보내기에서 리소스 유형 및 측정항목 필드에 이 문자열을 입력할 수 있습니다. 다음 스크린샷은 그 결과를 보여줍니다.

Cloud Monitoring의 OpenCensus에서 가져온 측정항목

히트맵의 각 줄은 프로그램 1회 실행을, 각 줄의 색상 요소는 지연 시간 분배 버킷을 나타냅니다. 차트 뒤에 있는 데이터에 대한 자세한 내용은 Cloud Monitoring의 OpenCensus 측정항목을 참조하세요.

OpenCensus 문서

OpenCensus는 측정항목 API 및 Stackdriver 내보내기 도구에 대한 신뢰할 수 있는 참조 문서를 제공합니다. 다음 표에서 이러한 참조 문서 링크를 참조하세요.

언어 API 참조 문서 내보내기 문서 빠른 시작
Go Go API 통계 및 Trace 내보내기 측정항목
자바 Java API 통계 내보내기 측정항목
NodeJS NodeJS API 통계 내보내기 측정항목
Python Python API 통계 내보내기 측정항목

모델 매핑하기

커스텀 측정항목에 Cloud Monitoring API를 직접 사용할 수 있습니다. 사용 방법은 커스텀 측정항목 사용을 참조하세요. 실제로 Cloud Monitoring의 OpenCensus 내보내기에서 이 API를 사용합니다.

Cloud Monitoring API 사용에 대해 자세히 알 필요가 없더라도 API의 구문과 용어를 익히면 Cloud Monitoring이 측정항목을 나타내는 방식을 이해하는 데 유용합니다. 이 섹션에서는 몇 가지 배경 정보를 제공합니다.

측정항목이 Cloud Monitoring에 수집되면 Cloud Monitoring 구문 내에 저장됩니다. 예를 들어 커스텀 측정항목의 Monitoring API 유형인 측정항목 설명자를 검색할 수 있습니다. 자세한 내용은 MetricDescriptor를 참조하세요. 예를 들어 데이터 차트를 작성할 때 이러한 측정항목 설명자가 나타납니다.

용어 및 개념

OpenCensus API에서 사용하는 구문은 Cloud Monitoring에서 사용하는 구문과 다르며, 일부 용어의 사용에도 차이가 있습니다. Cloud Monitoring이 '측정항목'을 참조하는 경우 OpenCensus는 '통계'를 의미합니다. 예를 들어 Cloud Monitoring에 측정항목 데이터를 전송하는 OpenCensus 구성요소를 'Stackdrdiver의 통계 내보내기'라고 합니다.

측정항목에 대한 OpenCensus 모델 개요는 OpenCensus 측정항목을 참조하세요.

OpenCensus 통계 및 Cloud Monitoring 측정항목의 데이터 모델은 1:1로 깔끔하게 매핑되지 않습니다. 동일한 개념도 다수 존재하긴 하지만 서로 바꾸어 사용할 수는 없습니다.

  • OpenCensus 는 일반적으로 Monitoring API의 MetricDescriptor와 유사합니다. 뷰는 개별 측정값을 수집하고 집계하는 방법을 설명합니다. 기록된 모든 측정 값은 태그별로 분류됩니다.

  • OpenCensus 태그는 키-값 쌍입니다. 이 태그는 일반적으로 Monitoring API의 LabelDescriptor에 해당합니다. 태그를 사용하여 측정항목을 필터링하고 그룹화하는 데 사용할 수 있는 컨텍스트 정보를 캡처할 수 있습니다.

  • OpenCensus 측정 값은 기록할 측정항목 데이터를 설명합니다. OpenCensus 집계는 요약 데이터에 적용되는 기능입니다. 이 기능은 내보내기에 사용되어 Cloud Monitoring 측정항목 설명에 보고된 MetricKind, ValueType, 단위를 결정합니다.

  • OpenCensus 측정 값은 측정하기 위해 수집된 데이터 포인트입니다. 측정 값은 보기로 집계되어야 합니다. 그렇지 않으면 개별 측정 값이 삭제됩니다. 이 구문은 Monitoring API의 Point와 유사합니다. 뷰에서 측정값이 집계되면 수집 데이터는 Monitoring API의 TimeSeries와 유사한 뷰 데이터로 저장됩니다.

Cloud Monitoring의 OpenCensus 측정항목

Cloud Monitoring에서 내보낸 측정항목을 확인할 수 있습니다. 기본 예제의 스크린샷은 측정항목 탐색기 화면을 나타냅니다. 샘플 프로그램을 실행하면 측정항목 탐색기로 데이터를 볼 수 있습니다.

측정항목 탐색기를 사용하여 모니터링 리소스의 측정항목을 확인하려면 다음을 수행하세요.

  1. Google Cloud Console에서 Monitoring으로 이동하거나 다음 버튼을 사용합니다.
    Monitoring으로 이동
  2. Monitoring 탐색창에서 측정항목 탐색기를 클릭합니다.
  3. 모니터링 리소스 이름을 리소스 유형 및 측정항목 찾기 텍스트 상자에 입력합니다.

검색을 제한하는 측정항목을 지정할 때 OpenCensus 보기의 이름을 입력할 수 있습니다. 자세한 정보는 측정항목 선택을 참조하세요.

측정항목 설명자 검색

Monitoring API를 직접 사용하여 측정항목 데이터를 검색할 수 있습니다. 측정항목 데이터를 검색하려면 OpenCensus 측정항목을 내보낸 Cloud Monitoring 이름을 알아야 합니다.

이 정보를 얻는 한 가지 방법은 내보내기에서 만든 측정항목 설명을 검색하고 type 필드의 값을 찾는 것입니다. 이 값에는 내보낸 OpenCensus 보기 이름이 포함되어 있습니다. 측정항목 설명에 대한 자세한 내용은 MetricDescriptor를 참조하세요.

metricDescriptors.list 메서드의 참조 페이지에서 API 탐색기(API 사용해보기) 위젯을 사용하여 내보낸 측정항목에 생성된 측정항목 설명을 볼 수 있습니다. 이 도구를 사용하여 OpenCensus 측정항목의 측정항목 설명자를 검색하려면 다음을 수행합니다.

  1. name 필드에 프로젝트 이름인 projects/[PROJECT_ID]를 입력합니다. 이 문서는 ID가 a-gcp-project인 프로젝트를 사용합니다.

  2. filter 필드에 필터를 입력합니다. OpenCensus 보기 이름이 측정항목 이름에 포함되어 있으므로 이를 사용하여 목록을 제한할 수 있습니다. 다음과 같은 필터를 적용합니다.

    metric.type=has_substring("task_latency_distribution")

    모든 프로젝트에는 측정항목 설명자가 많습니다. OpenCensus 보기 이름의 하위 문자열을 필터링하면 대부분이 제거됩니다.

  3. 실행 버튼을 클릭합니다.

다음은 반환된 측정항목 설명자를 나타냅니다.

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

측정항목 설명의 이 줄은 Cloud Monitoring에서 측정항목 유형의 이름을 알려줍니다.

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

이 정보를 사용하면 측정항목 유형과 관련한 데이터를 수동으로 검색할 수 있습니다. 이 데이터는 측정항목 차트에 표시되는 데이터이기도 합니다.

측정항목 데이터 검색

측정항목 유형에서 시계열 데이터를 수동으로 검색하려면 timeSeries.list 메서드의 참조 페이지에서 API 사용해보기 도구를 사용합니다.

  1. name 필드에 프로젝트 이름인 projects/[PROJECT_ID]를 입력합니다.
  2. 원하는 측정항목 유형으로 filter 필드에 필터인 metric.type="custom.googleapis.com/opencensus/task_latency_distribution"를 입력합니다.
    • metric.type 키는 시계열에 삽입된 유형의 필드를 나타냅니다. 자세한 내용은 TimeSeries를 참조하세요.
    • 이 값은 측정항목 설명 검색의 측정항목 설명에서 추출된 type 값입니다.
  3. 이 필드 값을 구체적으로 입력하여 검색할 시간 범위를 입력합니다.
    • 타임스탬프로 interval.endTime를 입력합니다(예: 2018-10-11T15:48:38-04:00).
    • interval.startTimeinterval.endTime보다 이전이어야 합니다.
  4. 실행 버튼을 클릭합니다.

다음은 위와 같이 검색한 결과입니다.

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

반환된 데이터에는 다음이 포함됩니다.

  • 데이터가 수집된 모니터링 리소스 정보 OpenCensus는 gce_instance, k8s_container, aws_ec2_instance 모니터링 리소스를 자동으로 감지할 수 있습니다. Compute Engine 인스턴스에서 실행되는 프로그램에서 이 데이터를 가져옵니다. 다른 모니터링 리소스 사용에 대한 자세한 내용은 내보내기에 모니터링 리소스 설정을 참조하세요.
  • 측정항목 종류와 값 유형에 대한 설명
  • 요청된 시간 간격 내에서 수집된 실제 데이터 포인트