OpenCensus의 커스텀 측정항목

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

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

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

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

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

OpenCensus란 무엇인가요?

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

  • 공급업체와 상관없이 다양한 언어로 측정항목 수집 및 데이터 추적을 지원합니다.
  • 수집된 데이터를 Stackdriver를 포함한 다양한 백엔드 애플리케이션으로 내보낼 수 있습니다.

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

OpenCensus를 사용해야 하는 이유

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

또한 OpenCensus는 오픈소스 프로젝트입니다. 독점 라이브러리 대신 공급업체를 가리지 않는 라이브러리를 사용해 수집한 데이터를 내보낼 수 있습니다.

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

시작하기 전에

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

GCP 프로젝트가 없는 경우 다음을 수행하세요.

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

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

  2. Google Cloud Platform 프로젝트를 선택하거나 만듭니다.

    리소스 관리 페이지로 이동

  3. Google Cloud Platform 프로젝트에 결제가 사용 설정되어 있는지 확인하세요.

    결제 사용 설정 방법 알아보기

작업공간에 프로젝트를 연결하려면 작업공간을 참조하세요.

커스텀 측정항목은 Stackdriver Monitoring의 유료 기능이므로 측정항목을 내부 데이터화하는 것에 대한 비용이 발생할 수 있습니다. 가격 책정에 대한 자세한 내용은 Stackdriver 가격 책정을 참조하세요.

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

측정항목에 OpenCensus 사용하기

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

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

기본 예제

다음은 이 단계를 최소화하여 설명하는 프로그램입니다. 루프를 실행하고 지연시간 값을 수집하며 루프가 끝나면 Stackdriver 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 = 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.');
}, 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))

    # Record 100 fake latency values between 0 and 5 seconds.
    for num in range(100):
        ms = random() * 5 * 1000
        print("Latency {}: {}".format(num, ms))

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

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

if __name__ == '__main__':
    main()
이 측정항목 데이터를 Stackdriver로 내보낸 후에는 다른 데이터처럼 사용할 수 있습니다.

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

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

Stackdriver Monitoring의 OpenCeusus에서 가져온 측정항목

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

OpenCensus 문서

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

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

모델 매핑하기

커스텀 측정항목용 기본 Stackdriver Monitoring API도 지원됩니다. 사용 방법은 커스텀 측정항목 사용을 참조하세요. 실제로 Stackdriver의 OpenCensus 내보내기 도구에서 이 API를 사용합니다.

Stackdriver Monitoring API 사용에 대한 세부 사항을 알 필요가 없더라도 구문 및 용어를 이해하면 Stackdriver Monitoring이 측정항목을 나타내는 방법을 이해하는 데 도움이 됩니다. 이 섹션에서는 몇 가지 배경 정보를 제공합니다.

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

용어 및 개념

OpenCensus API에서 사용되는 구문은 Stackdriver Monitoring에서 사용되는 구문과 다르며, 일부 용어의 사용에도 차이가 있습니다. Stackdriver Monitoring의 '측정항목'을 OpenCensus에서는 가끔 '통계'라고 표현합니다. 예를 들어 Stackdriver에서 측정항목 데이터를 보내는 OpenCensus 구성요소를 'Stackdriver의 통계 내보내기'라고 합니다.

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

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

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

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

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

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

Stackdriver의 OpenCensus 측정항목

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

측정항목 탐색기 페이지로 이동

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

측정항목 설명자 검색

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

이 정보를 확인하려면 내보내기 도구에서 생성된 측정항목 설명자를 검색하여 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"
    }
  ]
}

측정항목 설명자의 이 열은 Stackdriver 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.startTime(interval.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 인스턴스에서 실행되는 프로그램에서 이 데이터를 가져옵니다. 다른 모니터링 리소스 사용에 대한 자세한 내용은 내보내기에 모니터링 리소스 설정을 참조하세요.
  • 측정항목 종류와 값 유형에 대한 설명
  • 요청된 시간 간격 내에서 수집된 실제 데이터 포인트
이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

Stackdriver Monitoring
도움이 필요하시나요? 지원 페이지를 방문하세요.