커스텀 측정항목 만들기

커스텀 측정항목을 정의하려면 metricDescriptors.create API 메소드를 사용하여 커스텀 측정항목 설명을 만듭니다. 측정항목의 시계열 데이터를 작성하고 Monitoring에서 측정항목을 자동 생성할 수도 있지만 측정항목 정의에 포함될 정보를 알아야 합니다. 새 커스텀 측정항목 설명을 만든 후 측정항목 설명 API 메소드시계열 API 메소드와 함께 이 측정항목을 사용할 수 있습니다. Monitoring에서 차트 및 알림에 이 측정항목을 사용할 수도 있습니다.

커스텀 측정항목

커스텀 측정항목을 만들 때 GCP 프로젝트의 여러 커스텀 측정항목과는 다른 고유한 커스텀 측정항목 유형 이름을 할당합니다. 유형 이름은 custom.googleapis.com/으로 시작하고 그 뒤에 간단한 이름 또는 경로 이름이 나와야 합니다. 경로 이름은 커스텀 측정항목을 구성하는 데 도움이 될 수 있지만 간단한 이름처럼 처리됩니다. 자세한 내용은 이름 지정 규칙을 참조하세요. 유형 이름 2가지의 예를 소개합니다.

custom.googleapis.com/cpu_utilization
custom.googleapis.com/instance/cpu/utilization

커스텀 측정항목에는 모든 프로젝트의 전 GCP 리소스에서 고유한 리소스 이름도 있어야 합니다. 측정항목의 리소스 이름에 사용되는 형식은 다음과 같습니다.

projects/[PROJECT_ID]/metricDescriptors/[METRIC_TYPE]

앞서 다룬 커스텀 측정항목 예를 프로젝트 my-project-id에서 만들었다면 다음과 같은 리소스 이름을 지정합니다.

projects/my-project-id/metricDescriptors/custom.googleapis.com/cpu_utilization
projects/my-project-id/metricDescriptors/custom.googleapis.com/instance/cpu/utilization

이름 또는 유형. 일반적으로 Monitoring API에서 측정항목 유형 이름 필드에는 type 라벨이 지정되며 리소스 이름 필드에는 name 라벨이 지정됩니다. 하지만 대화 및 일부 문서에서는 이 유형 이름을 종종 '측정항목 이름'이라고 부릅니다.

커스텀 측정항목 정의

커스텀 측정항목을 만들려면 측정항목에 대한 다양한 정보가 지정된 MetricDescriptor 객체를 제공해야 합니다. 필요한 정보는 다음과 같습니다.

  • 이전 섹션의 설명대로 커스텀 측정항목의 유형 이름을 선택합니다.

  • 커스텀 측정항목을 정의하고 시계열 데이터를 작성할 프로젝트를 선택합니다. AWS의 커스텀 측정항목은 AWS 계정의 AWS 커넥터 프로젝트에서 만들어야 합니다. 선택한 프로젝트는 측정항목을 모니터링하는 작업공간의 구성원이어야 합니다. 여러 프로젝트에 동일한 측정항목이 필요하다면 프로젝트마다 측정항목을 똑같이 정의합니다.

  • 측정항목의 표시 이름 및 설명을 선택합니다. 표시 이름은 Monitoring의 사용자 인터페이스에서 사용됩니다.

  • 측정항목의 종류, 값 유형, 단위(선택사항)를 선택합니다. 커스텀 측정항목에서 지원되지 않는 값 유형 및 측정항목 종류도 일부 있습니다. 측정항목 종류를 참조하세요.

  • 측정항목 라벨(이름, 값 유형, 설명)을 선택합니다.

  • 측정항목의 시계열 데이터 포인트에 포함할 모니터링 리소스 객체를 선택합니다. 측정항목 설명자를 만들기 전에 생각해 두어야 합니다. 사용되는 모니터링 리소스 유형이 필요한 측정항목 라벨에 영향을 미칩니다. 예를 들어 데이터에 VM 인스턴스 객체를 포함하면 인스턴스를 지정하기 위해 측정항목 라벨이 필요하지 않습니다. 자세한 내용은 모니터링 리소스 유형 선택을 참조하세요.

기본 제공 측정항목을 찾아보고 시계열 데이터를 살펴보면 옵션을 선택하는 데 도움이 됩니다.

모니터링 리소스 유형 선택

측정항목의 데이터 요소마다 모니터링 리소스 객체가 포함되어 있어야 합니다. 다른 모니터링 리소스 객체의 요소는 다른 시계열에 유지됩니다.

커스텀 측정항목에서는 다음과 같은 모니터링 리소스 유형만 사용할 수 있습니다.

애플리케이션 코드가 실행되는 물리적 리소스를 나타내는 모니터링 리소스 객체를 사용하는 것이 일반적입니다. 이 방법에는 아래와 같은 이점이 있습니다.

  • 단일 리소스 유형을 사용할 때보다 성능이 향상됩니다.
  • 동일한 시계열에 작성된 여러 프로세스로 인해 데이터의 순서가 잘못되는 현상을 방지합니다.
  • 커스텀 측정항목 데이터를 동일한 리소스의 다른 측정항목 데이터와 그룹화할 수 있습니다.

global 리소스와 일반 리소스 비교

generic_taskgeneric_node 리소스 유형은 좀 더 적합한 특정 리소스 유형이 없는 상황에서 유용합니다. generic_task 유형은 애플리케이션 등의 작업과 같은 리소스를 정의할 때 유용합니다. generic_node 유형은 가상 머신 등 노드와 같은 리소스를 정의할 때 유용합니다. 두 generic_* 유형에는 고유한 리소스 객체를 정의할 때 사용할 수 있는 공통 라벨이 여러 개 있으므로, 집계 및 축소를 위한 측정항목 필터에서 이들을 간편하게 사용할 수 있습니다.

그에 반해 global 리소스 유형에는 project_idlocation 라벨만 있습니다. 프로젝트에 측정항목 소스가 여러 개 있는 경우, 동일한 global 리소스 객체를 사용하면 측정항목 데이터의 충돌 및 덮어쓰기가 발생할 수 있습니다.

만들기 메소드 호출

옵션을 적용해 metricDescriptors.create 메소드를 호출하여 MetricDescriptor 객체를 전달합니다. 또는 측정항목 설명자 자동 생성을 참조하세요. 제한된 방법으로만 기존 설명자를 변경할 수 있습니다. 자세한 내용은 측정항목 설명자 수정을 참조하세요.

일반적으로 기존 커스텀 측정항목 설명자와 동일한 유형 이름을 사용하여 metricDescriptors.create를 호출하면 오류가 발생합니다. 하지만 새 MetricDescriptor 객체의 모든 필드가 기존 설명자의 필드와 정확히 일치할 경우에는 오류에 해당하지 않으며 아무런 영향도 미치지 않습니다.

측정항목 설명자 만들기

다음 예에서는 게이지 커스텀 측정항목 custom.googleapis.com/stores/daily_sales를 만듭니다. 이 측정항목에는 단일 측정기준 라벨인 store_id가 사용됩니다.

프로토콜

측정항목 설명자를 만들려면 metricDescriptors.create 메소드를 사용합니다. 메소드의 참조 페이지에서 API 탐색기 위젯을 사용하여 이 메소드를 실행할 수 있습니다. 자세한 내용은 API 탐색기를 참조하세요.

다음은 metricDescriptors.create의 샘플 매개변수입니다.

  • name(URL): projects/[PROJECT_ID]
  • 요청 본문: 다음과 같은 MetricDescriptor 객체를 제공합니다.

    {
      "name": "",
      "description": "Daily sales records from all branch stores.",
      "displayName": "daily sales",
      "type": "custom.googleapis.com/stores/daily_sales",
      "metricKind": "GAUGE",
      "valueType": "DOUBLE",
      "unit": "{USD}",
      "labels": [
        {
          "key": "store_id",
          "valueType": "STRING",
          "description": "The ID of the store."
        },
      ],
    }
    

[PROJECT_ID] 대신 프로젝트 ID를 사용하여 위젯의 필드에 이 값을 입력합니다.

측정항목 설명자 만들기

메소드를 실행하려면 실행 버튼을 클릭합니다.

사용해 보기

새 커스텀 측정항목을 만들 때 MetricDescriptorname 필드가 무시되고 생략될 수 있습니다. create 메소드는 name 필드가 채워진 새 측정항목 설명자를 반환합니다. 이 예의 경우 다음과 같습니다.

"name": "projects/[PROJECT_ID]/metricDescriptors/custom.googleapis.com/stores/daily_sales"

이 이름을 사용하여 측정항목 설명자를 가져오는 등의 작업을 할 수 있습니다.

C#

        public static object CreateMetric(string projectId,
            string metricType = "custom.googleapis.com/stores/daily_sales")
        {
            // Create client.
            MetricServiceClient metricServiceClient = MetricServiceClient.Create();

            // Prepare custom metric descriptor.
            MetricDescriptor metricDescriptor = new MetricDescriptor();
            metricDescriptor.DisplayName = "Daily Sales";
            metricDescriptor.Description = "Daily sales records from all branch stores.";
            metricDescriptor.MetricKind = MetricKind.Gauge;
            metricDescriptor.ValueType = MetricDescriptor.Types.ValueType.Double;
            metricDescriptor.Type = metricType;
            metricDescriptor.Unit = "{USD}";
            LabelDescriptor labels = new LabelDescriptor();
            labels.Key = "store_id";
            labels.ValueType = LabelDescriptor.Types.ValueType.String;
            labels.Description = "The ID of the store.";
            metricDescriptor.Labels.Add(labels);
            CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
            {
                ProjectName = new ProjectName(projectId),
            };
            request.MetricDescriptor = metricDescriptor;
            // Make the request.
            MetricDescriptor response = metricServiceClient.CreateMetricDescriptor(request);
            Console.WriteLine("Done creating metric descriptor:");
            Console.WriteLine(JObject.Parse($"{response}").ToString());
            return 0;
        }

Go

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"google.golang.org/genproto/googleapis/api/label"
	"google.golang.org/genproto/googleapis/api/metric"
	metricpb "google.golang.org/genproto/googleapis/api/metric"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// createCustomMetric creates a custom metric specified by the metric type.
func createCustomMetric(w io.Writer, projectID, metricType string) (*metricpb.MetricDescriptor, error) {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return nil, err
	}
	md := &metric.MetricDescriptor{
		Name: "Custom Metric",
		Type: metricType,
		Labels: []*label.LabelDescriptor{{
			Key:         "environment",
			ValueType:   label.LabelDescriptor_STRING,
			Description: "An arbitrary measurement",
		}},
		MetricKind:  metric.MetricDescriptor_GAUGE,
		ValueType:   metric.MetricDescriptor_INT64,
		Unit:        "s",
		Description: "An arbitrary measurement",
		DisplayName: "Custom Metric",
	}
	req := &monitoringpb.CreateMetricDescriptorRequest{
		Name:             "projects/" + projectID,
		MetricDescriptor: md,
	}
	m, err := c.CreateMetricDescriptor(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("could not create custom metric: %v", err)
	}

	fmt.Fprintf(w, "Created %s\n", m.GetName())
	return m, nil
}

자바

// Your Google Cloud Platform project ID
String projectId = System.getProperty("projectId");
String metricType = CUSTOM_METRIC_DOMAIN + "/" + type;

final MetricServiceClient client = MetricServiceClient.create();
ProjectName name = ProjectName.of(projectId);

MetricDescriptor descriptor = MetricDescriptor.newBuilder()
    .setType(metricType)
    .setDescription("This is a simple example of a custom metric.")
    .setMetricKind(MetricDescriptor.MetricKind.GAUGE)
    .setValueType(MetricDescriptor.ValueType.DOUBLE)
    .build();

CreateMetricDescriptorRequest request = CreateMetricDescriptorRequest.newBuilder()
    .setName(name.toString())
    .setMetricDescriptor(descriptor)
    .build();

client.createMetricDescriptor(request);

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';

const request = {
  name: client.projectPath(projectId),
  metricDescriptor: {
    description: 'Daily sales records from all branch stores.',
    displayName: 'Daily Sales',
    type: 'custom.googleapis.com/stores/daily_sales',
    metricKind: 'GAUGE',
    valueType: 'DOUBLE',
    unit: '{USD}',
    labels: [
      {
        key: 'store_id',
        valueType: 'STRING',
        description: 'The ID of the store.',
      },
    ],
  },
};

// Creates a custom metric descriptor
const [descriptor] = await client.createMetricDescriptor(request);
console.log('Created custom Metric:\n');
console.log(`Name: ${descriptor.displayName}`);
console.log(`Description: ${descriptor.description}`);
console.log(`Type: ${descriptor.type}`);
console.log(`Kind: ${descriptor.metricKind}`);
console.log(`Value Type: ${descriptor.valueType}`);
console.log(`Unit: ${descriptor.unit}`);
console.log('Labels:');
descriptor.labels.forEach(label => {
  console.log(`  ${label.key} (${label.valueType}) - ${label.description}`);
});

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Api\LabelDescriptor;
use Google\Api\LabelDescriptor_ValueType;
use Google\Api\MetricDescriptor;
use Google\Api\MetricDescriptor_MetricKind;
use Google\Api\MetricDescriptor_ValueType;

/**
 * Create a new metric in Stackdriver Monitoring.
 * Example:
 * ```
 * create_metric($projectId);
 * ```
 *
 * @param string $projectId Your project ID
 */
function create_metric($projectId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $projectName = $metrics->projectName($projectId);

    $descriptor = new MetricDescriptor();
    $descriptor->setDescription('Daily sales records from all branch stores.');
    $descriptor->setDisplayName('Daily Sales');
    $descriptor->setType('custom.googleapis.com/stores/daily_sales');
    $descriptor->setMetricKind(MetricDescriptor_MetricKind::GAUGE);
    $descriptor->setValueType(MetricDescriptor_ValueType::DOUBLE);
    $descriptor->setUnit('{USD}');
    $label = new LabelDescriptor();
    $label->setKey('store_id');
    $label->setValueType(LabelDescriptor_ValueType::STRING);
    $label->setDescription('The ID of the store.');
    $labels = [$label];
    $descriptor->setLabels($labels);

    $descriptor = $metrics->createMetricDescriptor($projectName, $descriptor);
    printf('Created a metric: ' . $descriptor->getName() . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)
descriptor = monitoring_v3.types.MetricDescriptor()
descriptor.type = 'custom.googleapis.com/my_metric' + RANDOM_SUFFIX
descriptor.metric_kind = (
    monitoring_v3.enums.MetricDescriptor.MetricKind.GAUGE)
descriptor.value_type = (
    monitoring_v3.enums.MetricDescriptor.ValueType.DOUBLE)
descriptor.description = 'This is a simple example of a custom metric.'
descriptor = client.create_metric_descriptor(project_name, descriptor)
print('Created {}.'.format(descriptor.name))

Ruby

client = Google::Cloud::Monitoring::Metric.new
project_name = Google::Cloud::Monitoring::V3::MetricServiceClient.project_path project_id

descriptor = Google::Api::MetricDescriptor.new(
  type:        "custom.googleapis.com/my_metric#{random_suffix}",
  metric_kind: Google::Api::MetricDescriptor::MetricKind::GAUGE,
  value_type:  Google::Api::MetricDescriptor::ValueType::DOUBLE,
  description: "This is a simple example of a custom metric."
)

result = client.create_metric_descriptor project_name, descriptor
p "Created #{result.name}"
p result

문제가 발생할 경우 API 호출 문제해결을 참조하세요.

다음 단계: 측정항목 데이터 작성을 참조하세요.

측정항목 삭제

커스텀 측정항목을 삭제하려면 metricDescriptors.delete 메소드를 호출합니다.

프로토콜

측정항목 설명자를 삭제하려면 metricDescriptors.delete 메소드를 사용합니다. 메소드의 참조 페이지에서 API 탐색기 위젯을 사용하여 이 메소드를 실행할 수 있습니다. 자세한 내용은 API 탐색기를 참조하세요.

커스텀 측정항목 유형만 삭제할 수 있습니다.

stores/daily_sales에서 만든 stores/daily_sales 커스텀 측정항목을 삭제하려면 다음 안내를 따르세요.

  1. metricDescriptors.delete에 대한 참조 페이지로 이동합니다.
  2. API 탐색기 위젯에 측정항목 설명자 이름을 제공합니다.

    이름: projects/[PROJECT_ID]/metricDescriptors/custom.googleapis.com/stores/daily_sales

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

사용해 보기

C#

public static object DeleteMetric(string projectId, string metricType)
{
    // Create client.
    MetricServiceClient metricServiceClient = MetricServiceClient.Create();
    // Initialize request argument(s).
    MetricDescriptorName name = new MetricDescriptorName(projectId, metricType);
    // Make the request.
    metricServiceClient.DeleteMetricDescriptor(name);
    Console.WriteLine($"Done deleting metric descriptor: {name}");
    return 0;
}

Go

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// deleteMetric deletes the given metric. name should be of the form
// "projects/PROJECT_ID/metricDescriptors/METRIC_TYPE".
func deleteMetric(w io.Writer, name string) error {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return err
	}
	req := &monitoringpb.DeleteMetricDescriptorRequest{
		Name: name,
	}

	if err := c.DeleteMetricDescriptor(ctx, req); err != nil {
		return fmt.Errorf("could not delete metric: %v", err)
	}
	fmt.Fprintf(w, "Deleted metric: %q\n", name)
	return nil
}

자바

String projectId = System.getProperty("projectId");
final MetricServiceClient client = MetricServiceClient.create();
MetricDescriptorName metricName = MetricDescriptorName.of(projectId, name);
client.deleteMetricDescriptor(metricName);
System.out.println("Deleted descriptor " + name);

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const metricId = 'custom.googleapis.com/stores/daily_sales';

const request = {
  name: client.metricDescriptorPath(projectId, metricId),
};

// Deletes a metric descriptor
const [result] = await client.deleteMetricDescriptor(request);
console.log(`Deleted ${metricId}`, result);

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;

/**
 * Example:
 * ```
 * delete_metric($projectId, $databaseId);
 * ```
 *
 * @param string $projectId Your project ID
 * @param string $metricId  The ID of the Metric Descriptor to delete
 */
function delete_metric($projectId, $metricId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $metricPath = $metrics->metricDescriptorName($projectId, $metricId);
    $ret = $metrics->deleteMetricDescriptor($metricPath);

    printf('Deleted a metric: ' . $metricPath . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
client.delete_metric_descriptor(descriptor_name)
print('Deleted metric descriptor {}.'.format(descriptor_name))

Ruby

client = Google::Cloud::Monitoring::Metric.new
client.delete_metric_descriptor descriptor_name
p "Deleted metric descriptor #{descriptor_name}."

문제가 발생할 경우 API 호출 문제해결을 참조하세요.

커스텀 측정항목의 시계열 데이터는 삭제할 수 없지만 이 데이터는 데이터 보관 정책에 따라 만료 및 삭제됩니다.

측정항목 데이터 작성

커스텀 측정항목 유형에 한해 데이터 작성이 가능합니다. timeSeries.create 메소드를 사용하면 데이터 요소를 작성할 수 있습니다. 이 메소드는 기존 시계열에 새 데이터 요소를 추가해 필요한 경우 시계열을 만듭니다.

TimeSeries 객체 목록을 timeSeries.create에 전달하여 데이터 포인트를 작성합니다. 최대 목록 크기는 200이고 목록의 객체마다 다른 시계열을 지정해야 합니다.

  • 각 시계열은 TimeSeries 객체의 metricmetric과 resourceresource 필드로 식별됩니다.
  • metricKindvalueType 필드는 생략합니다. 이 두 필드는 데이터 포인트를 작성할 때 무시됩니다.
  • TimeSeries 객체에는 하나의 Point 객체만 포함되어야 합니다.

    • 포인트의 값 및 시간 간격이 측정항목 유형의 정의와 일치해야 합니다. 다양한 측정항목 종류의 시간 간격에 대한 자세한 내용은 측정항목 종류를 참조하세요.
    • 포인트의 시간 간격이 시계열에 이미 존재하는 포인트보다 늦은 시점에 존재해야 합니다.
    • 간격의 종료 시간이 24시간보다 이전이거나 5분보다 늦은 시점이어서는 안 됩니다.
  • 동일한 시계열에 두 개 이상의 포인트를 작성하려면 포인트마다 timeSeries.create 메소드를 따로 호출합니다. 분당 1회보다 빠르게 호출하지 마세요. 여러 데이터 포인트를 각기 다른 시계열에 추가할 경우에는 비율 한도가 적용되지 않습니다.

프로토콜

측정항목 데이터를 작성하려면 timeSeries.create 메소드를 사용합니다. 메소드의 참조 페이지에서 API 탐색기 위젯을 사용하여 이 메소드를 실행할 수 있습니다. 자세한 내용은 API 탐색기를 참조하세요.

측정항목 설명자 만들기에서 만든 stores/daily_sales 커스텀 측정항목에 포인트를 작성하려면 다음 안내를 따르세요.

  1. timeSeries.create에 대한 참조 페이지로 이동합니다.
  2. API 탐색기 위젯에 아래의 매개변수를 제공합니다.
  3. 실행 버튼을 클릭합니다.

다음 샘플 매개변수를 사용합니다.

  • name: projects/[PROJECT_ID]
  • 요청 본문: TimeSeries 객체 목록을 포함합니다. 다음 샘플에는 목록의 시계열이 하나만 있습니다.

    {
     "timeSeries": [
      {
       "metric": {
        "type": "custom.googleapis.com/my_metric",
        "labels": {
         "my_label": "my_value"
        }
       },
       "resource": {
        "type": "gce_instance",
        "labels": {
         "project_id": "[PROJECT_ID]",
         "instance_id": "1234567890123456789",
         "zone": "us-central1-f"
        }
       },
       "points": [
        {
         "interval": {
          "endTime": "2018-06-01T10:00:00-04:00"
         },
         "value": {
          "doubleValue": 123.45
         }
        }
       ]
      }
     ]
    }
    

사용해 보기

C#

        public static object WriteTimeSeriesData(string projectId)
        {
            // Create client.
            MetricServiceClient metricServiceClient = MetricServiceClient.Create();
            // Initialize request argument(s).
            ProjectName name = new ProjectName(projectId);
            // Prepare a data point.
            Point dataPoint = new Point();
            TypedValue salesTotal = new TypedValue();
            salesTotal.DoubleValue = 123.45;
            dataPoint.Value = salesTotal;
            Timestamp timeStamp = new Timestamp();
            timeStamp.Seconds = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;
            TimeInterval interval = new TimeInterval();
            interval.EndTime = timeStamp;
            dataPoint.Interval = interval;

            // Prepare custom metric.
            Metric metric = new Metric();
            metric.Type = "custom.googleapis.com/stores/daily_sales";
            metric.Labels.Add("store_id", "Pittsburgh");

            // Prepare monitored resource.
            MonitoredResource resource = new MonitoredResource();
            resource.Type = "global";
            resource.Labels.Add("project_id", projectId);

            // Create a new time series using inputs.
            TimeSeries timeSeriesData = new TimeSeries();
            timeSeriesData.Metric = metric;
            timeSeriesData.Resource = resource;
            timeSeriesData.Points.Add(dataPoint);

            // Add newly created time series to list of time series to be written.
            IEnumerable<TimeSeries> timeSeries = new List<TimeSeries> { timeSeriesData };
            // Write time series data.
            metricServiceClient.CreateTimeSeries(name, timeSeries);
            Console.WriteLine("Done writing time series data:");
            Console.WriteLine(JObject.Parse($"{timeSeriesData}").ToString());
            return 0;
        }

Go

// writeTimeSeriesValue writes a value for the custom metric created
func writeTimeSeriesValue(projectID, metricType string) error {
	ctx := context.Background()
	c, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		return err
	}
	now := &timestamp.Timestamp{
		Seconds: time.Now().Unix(),
	}
	req := &monitoringpb.CreateTimeSeriesRequest{
		Name: "projects/" + projectID,
		TimeSeries: []*monitoringpb.TimeSeries{{
			Metric: &metricpb.Metric{
				Type: metricType,
				Labels: map[string]string{
					"environment": "STAGING",
				},
			},
			Resource: &monitoredres.MonitoredResource{
				Type: "gce_instance",
				Labels: map[string]string{
					"instance_id": "test-instance",
					"zone":        "us-central1-f",
				},
			},
			Points: []*monitoringpb.Point{{
				Interval: &monitoringpb.TimeInterval{
					StartTime: now,
					EndTime:   now,
				},
				Value: &monitoringpb.TypedValue{
					Value: &monitoringpb.TypedValue_Int64Value{
						Int64Value: rand.Int63n(10),
					},
				},
			}},
		}},
	}
	log.Printf("writeTimeseriesRequest: %+v\n", req)

	err = c.CreateTimeSeries(ctx, req)
	if err != nil {
		return fmt.Errorf("could not write time series value, %v ", err)
	}
	return nil
}

자바

String projectId = System.getProperty("projectId");
// Instantiates a client
MetricServiceClient metricServiceClient = MetricServiceClient.create();

// Prepares an individual data point
TimeInterval interval = TimeInterval.newBuilder()
    .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))
    .build();
TypedValue value = TypedValue.newBuilder()
    .setDoubleValue(123.45)
    .build();
Point point = Point.newBuilder()
    .setInterval(interval)
    .setValue(value)
    .build();

List<Point> pointList = new ArrayList<>();
pointList.add(point);

ProjectName name = ProjectName.of(projectId);

// Prepares the metric descriptor
Map<String, String> metricLabels = new HashMap<>();
Metric metric = Metric.newBuilder()
    .setType("custom.googleapis.com/my_metric")
    .putAllLabels(metricLabels)
    .build();

// Prepares the monitored resource descriptor
Map<String, String> resourceLabels = new HashMap<>();
resourceLabels.put("instance_id", "1234567890123456789");
resourceLabels.put("zone", "us-central1-f");

MonitoredResource resource = MonitoredResource.newBuilder()
    .setType("gce_instance")
    .putAllLabels(resourceLabels)
    .build();

// Prepares the time series request
TimeSeries timeSeries = TimeSeries.newBuilder()
    .setMetric(metric)
    .setResource(resource)
    .addAllPoints(pointList)
    .build();

List<TimeSeries> timeSeriesList = new ArrayList<>();
timeSeriesList.add(timeSeries);

CreateTimeSeriesRequest request = CreateTimeSeriesRequest.newBuilder()
    .setName(name.toString())
    .addAllTimeSeries(timeSeriesList)
    .build();

// Writes time series data
metricServiceClient.createTimeSeries(request);
System.out.println("Done writing time series value.");

Node.js

// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Creates a client
const client = new monitoring.MetricServiceClient();

/**
 * TODO(developer): Uncomment and edit the following lines of code.
 */
// const projectId = 'YOUR_PROJECT_ID';

const dataPoint = {
  interval: {
    endTime: {
      seconds: Date.now() / 1000,
    },
  },
  value: {
    doubleValue: 123.45,
  },
};

const timeSeriesData = {
  metric: {
    type: 'custom.googleapis.com/stores/daily_sales',
    labels: {
      store_id: 'Pittsburgh',
    },
  },
  resource: {
    type: 'global',
    labels: {
      project_id: projectId,
    },
  },
  points: [dataPoint],
};

const request = {
  name: client.projectPath(projectId),
  timeSeries: [timeSeriesData],
};

// Writes time series data
const result = await client.createTimeSeries(request);
console.log(`Done writing time series data.`, result);

PHP

use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Cloud\Monitoring\V3\Point;
use Google\Cloud\Monitoring\V3\TimeInterval;
use Google\Cloud\Monitoring\V3\TimeSeries;
use Google\Cloud\Monitoring\V3\TypedValue;
use Google\Protobuf\Timestamp;

/**
 * Example:
 * ```
 * write_timeseries($projectId);
 * ```
 *
 * @param string $projectId Your project ID
 */
function write_timeseries($projectId)
{
    $metrics = new MetricServiceClient([
        'projectId' => $projectId,
    ]);

    $projectName = $metrics->projectName($projectId);
    $filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';

    $endTime = new Timestamp();
    $endTime->setSeconds(time());
    $interval = new TimeInterval();
    $interval->setEndTime($endTime);

    $value = new TypedValue();
    $value->setDoubleValue(123.45);

    $point = new Point();
    $point->setValue($value);
    $point->setInterval($interval);
    $points = [$point];

    $metric = new Metric();
    $metric->setType('custom.googleapis.com/stores/daily_sales');
    $labels = ['store_id' => 'Pittsburg'];
    $metric->setLabels($labels);

    $resource = new MonitoredResource();
    $resource->setType('global');
    $labels = ['project_id' => $projectId];
    $resource->setLabels($labels);

    $timeSeries = new TimeSeries();
    $timeSeries->setMetric($metric);
    $timeSeries->setResource($resource);
    $timeSeries->setPoints($points);

    $result = $metrics->createTimeSeries(
        $projectName,
        [$timeSeries]);

    printf('Done writing time series data.' . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)

series = monitoring_v3.types.TimeSeries()
series.metric.type = 'custom.googleapis.com/my_metric' + RANDOM_SUFFIX
series.resource.type = 'gce_instance'
series.resource.labels['instance_id'] = '1234567890123456789'
series.resource.labels['zone'] = 'us-central1-f'
point = series.points.add()
point.value.double_value = 3.14
now = time.time()
point.interval.end_time.seconds = int(now)
point.interval.end_time.nanos = int(
    (now - point.interval.end_time.seconds) * 10**9)
client.create_time_series(project_name, [series])

Ruby

client = Google::Cloud::Monitoring::Metric.new
project_name = Google::Cloud::Monitoring::V3::MetricServiceClient.project_path project_id

# Random suffix for metric type to avoid collisions with other runs
random_suffix = rand(36**10).to_s(36)

series = Google::Monitoring::V3::TimeSeries.new
metric = Google::Api::Metric.new type: "custom.googleapis.com/my_metric#{random_suffix}"
series.metric = metric

resource = Google::Api::MonitoredResource.new type: "gce_instance"
resource.labels["instance_id"] = "1234567890123456789"
resource.labels["zone"] = "us-central1-f"
series.resource = resource

point = Google::Monitoring::V3::Point.new
point.value = Google::Monitoring::V3::TypedValue.new double_value: 3.14
now = Time.now
end_time = Google::Protobuf::Timestamp.new seconds: now.to_i, nanos: now.usec
point.interval = Google::Monitoring::V3::TimeInterval.new end_time: end_time
series.points << point

client.create_time_series project_name, [series]
p "Time series created : #{metric.type}"

문제가 발생할 경우 API 호출 문제해결을 참조하세요.

측정항목 설명자 자동 생성

아직 존재하지 않는 커스텀 측정항목 유형에 측정항목 데이터를 작성하면 새로운 커스텀 측정항목 설명자가 자동으로 생성됩니다. 하지만 이 새 측정항목 설명자는 정확히 원하는 설명자가 아닐 수도 있습니다. 측정항목 설명자는 몇 가지 가정과 기본값에 따라 자동으로 생성됩니다.

구체적으로 말해 timeSeries.create를 호출하는 동안 TimeSeries 객체에 존재하지 않는 metric-type name을 지정하는 Metric 객체가 포함되어 있으면 Stackdriver Monitoring은 다음 필드가 포함된 새 MetricDescriptor를 만듭니다.

  • type: Metric 객체의 type 필드에서 복사되는 유형입니다.
  • name: 메소드 호출의 프로젝트 ID 및 Metric 객체의 type 값으로 만든 이름입니다.
  • labels: Metric 객체에 표시되는 라벨입니다. 새 측정항목 설명자의 각 라벨 설명자에는 다음과 같은 필드가 포함됩니다.
    • key: Metric 객체의 라벨 키
    • valueType: STRING
    • description: 설정되지 않음
  • metricKind: 기본 측정항목 종류는 GAUGE이지만 TimeSeries 객체의 metricKind 매개변수를 지정하면 해당 종류가 새 측정항목 종류에 적용됩니다. GAUGECUMULATIVE 종류만 지정할 수 있습니다.
  • valueType: 값 유형은 Point, BOOL, INT64 또는 DOUBLE 중 하나로 작성된 DISTRIBUTION의 유형 값에서 가져옵니다. TimeSeriesvalueType 필드에 값 유형을 지정하는 경우, 해당 유형이 Point 유형과 일치해야 합니다.
  • unit: 설정되지 않음
  • description: "Auto created custom metric."
  • displayName: 설정되지 않음

하나의 timeSeries.create 호출에 존재하지 않는 동일한 커스텀 측정항목 유형을 참조하는 여러 TimeSeries 객체를 포함시킬 수 있습니다. 이 경우 새 유형의 필드가 동일하게 설정됩니다. 단, 새 측정항목 설명자의 라벨은 create에 대한 이 호출에서 모든 시계열의 create 객체에 있는 모든 라벨이 통합되어 구성됩니다.

측정항목 설명자 수정

timeSeries.create 호출을 사용하여 새 라벨을 커스텀 측정항목에 추가할 수도 있습니다. 라벨을 시계열 데이터와 함께 포함하여 커스텀 측정항목 설명자에 라벨을 추가할 수 있습니다.

작성할 라벨이 유효하고 측정항목 설명자의 라벨 수가 라벨 한도인 10을 초과하지 않으면 라벨이 추가됩니다. 그러면 처음부터 측정항목에 라벨이 있었던 것처럼 시계열 데이터가 작성됩니다.

새 라벨을 추가하는 것보다 더 많은 작업을 하려면 측정항목 설명자를 삭제하고 다시 만들어야 합니다. 이 경우 오래된 측정항목 설명자에 대해 이전에 수집된 시계열 데이터가 모두 손실됩니다. 자세한 내용은 측정항목 삭제를 참조하세요.

측정항목 이름은 변경할 수 없습니다.

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

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

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