API を使用してカスタム指標を作成する

このドキュメントでは、Cloud Monitoring API を使用してカスタム指標を作成する方法と、カスタム指標データを書き込む方法について説明します。

カスタム指標では、組み込みの Cloud Monitoring 指標と同じ要素を使用します。

  • データポイントのセット。
  • データポイントが何を表しているかを示す指標タイプ情報。
  • モニタリング対象リソース情報。データポイントの発生場所がわかります。

カスタム指標は組み込み指標と同じように使用できます。つまり、カスタム指標のデータについて、グラフやアラートを作成できます。

始める前に

すべての指標の基礎となる構造については、指標、時系列、リソースをご覧ください。

Cloud Monitoring を使用するには、課金を有効にした Cloud プロジェクトが必要です。 必要に応じて、次のことを行います。

  1. Google Cloud Console の [プロジェクト セレクタ] ページで、Google Cloud プロジェクトを選択または作成します。

    プロジェクト セレクタに移動

  2. Cloud プロジェクトに対して課金が有効になっていることを確認します。詳しくは、プロジェクトで課金が有効になっているかどうかを確認する方法をご覧ください。

  3. Monitoring API が有効であることを確認します。詳細については、Monitoring API の有効化をご覧ください。
  4. Google Cloud の外部で実行されているアプリケーションの場合、Cloud プロジェクトでアプリケーションを認証する必要があります。通常は、プロジェクト用のサービス アカウントを作成し、環境変数を構成することによって、認証を構成します。

    Amazon Elastic Compute Cloud(Amazon EC2)インスタンスで実行するアプリケーションの場合は、インスタンスの AWS コネクタ プロジェクトのサービス アカウントを作成します。

    サービス アカウントの作成については、認証の開始をご覧ください。

カスタム指標の作成

カスタム指標を作成するには、指標に関するさまざまな情報を指定する MetricDescriptor オブジェクトを定義するか、指標データを書き込みます。指標データを書き込むと、Monitoring は提供されたデータの構造に基づいて指標記述子を作成します。指標記述子の設計については、カスタム指標の指標記述子をご覧ください。

指標記述子の自動作成

該当のカスタム指標の指標記述子が存在しない場合に指標データを書き込むと、指標記述子が自動的に作成されます。ただし、この新しい指標記述子は、必要なものとは正確に一致しない可能性があります。指標記述子の自動作成には、いくつかの仮定とデフォルトが伴います。

timeSeries.create の呼び出しに含まれる TimeSeries オブジェクトが、存在しない 指標タイプ名 を指定する Metric オブジェクトを参照する場合、Cloud Monitoring は新しいMetricDescriptorを作成します。Cloud Monitoring は、次のルールを使用して MetricDescriptor に値を入力します。

  • type: Metric オブジェクトの type フィールドからコピーされます。
  • name: 名前は、メソッド呼び出しで指定されたプロジェクト ID と Metric オブジェクトの type の値から作成されます。
  • labels: Metric オブジェクトで使用されるラベル。新しい指標記述子の各ラベル記述子には次のフィールドがあります。
    • key: Metric オブジェクト内のラベルキー
    • valueType: STRING
    • description: 未設定
  • metricKind: TimeSeries オブジェクトの metricKind パラメータを指定しない限り、指標の種類は GAUGE に設定されます。metricKind を指定すると、新しい指標がその種類になります。種類として指定できるのは GAUGECUMULATIVE だけです。
  • valueType: 値の型は、書き込まれる Point の型指定された値から取得されます。値の型は、BOOLINT64DOUBLE、または DISTRIBUTION にする必要があります。TimeSeriesvalueType フィールドで、値のタイプを指定する場合は、そのタイプが Point のタイプと一致する必要があります。
  • unit: 未設定
  • description: "Auto created custom metric."
  • displayName: 未設定

1 回の timeSeries.create の呼び出しに、存在しない同じ指標タイプを参照する複数の TimeSeries オブジェクトを含めることができます。その場合、新しい指標記述子のラベルは、この create の呼び出しにおけるすべての時系列の Metric オブジェクトのラベルすべてのユニオンになります。

次のステップ: カスタム指標データの書き込みをご覧ください。

指標記述子の手動作成

指標記述子を作成するには、次のようにします。

  1. 指標記述子の構造を決定します。指定する情報を選択するとき、組み込まれた指標を閲覧したり、その時系列データを見たりして、判断の参考にしてください。

    1. カスタム指標の指標名を選択します。

    2. 指標の表示名と説明を選択します。表示名は Google Cloud Console で使用されます。

    3. カスタム指標を定義してその時系列データを書き込む、対象のプロジェクトを選択します。複数のプロジェクトで同じ指標が必要な場合は、それぞれのプロジェクトに同じ指標の定義を作成します。

      AWS アカウントで管理されるリソースからカスタム指標を書き込むには、そのアカウントの AWS コネクタ プロジェクトに指標記述子を作成します。

    4. 指標の種類、値の型、単位(省略可)を決定します。値の型と指標の種類の中には、カスタム指標ではサポートされないものもあります。これらのフィールドの詳細については、値の型と指標の種類をご覧ください。

    5. 指標のラベル(名前、値の型、説明)を選択します。

  2. 指標データの書き込み先のモニタリング対象リソースを決定します。次のリストから選択してください。

    • aws_ec2_instance: Amazon EC2 インスタンス。
    • dataflow_job: Dataflow ジョブ。
    • gae_instance: App Engine インスタンス。
    • gce_instance: Compute Engine インスタンス。
    • generic_node: ユーザー指定のコンピューティング ノード。
    • generic_task: ユーザー定義のタスク。
    • gke_container: GKE コンテナ インスタンス。
    • global: 他に適切なリソースタイプがない場合はこのリソースを使用します。ほとんどのケースでは、generic_nodegeneric_task の方が global より適切です。
    • k8s_cluster: Kubernetes クラスタ。
    • k8s_container: Kubernetes コンテナ。
    • k8s_node: Kubernetes ノード。
    • k8s_pod: Kubernetes Pod。
  3. MetricDescriptor オブジェクトを作成し、それを metricDescriptors.create メソッド呼び出しの引数として渡します。

metricDescriptors.create を呼び出す際に既存の指標記述子と同じタイプ名を使用すると、通常はエラーになります。ただし、新しい MetricDescriptor オブジェクトのすべてのフィールドが既存の記述子のフィールドと完全に一致していればエラーになりませんが、効果はありません。

次の例では、ゲージカスタム指標を作成します。

プロトコル

指標記述子を作成するには、metricDescriptors.create メソッドを使用します。このメソッドは、メソッドのリファレンス ページにある API Explorer ウィジェットを使用して実行できます。詳細については、API Explorer をご覧ください。

metricDescriptors.create のサンプル パラメータを次に示します。

  • 名前 (URL): projects/[PROJECT_ID]
  • リクエスト本文: 次のような MetricDescriptor オブジェクトを渡します。

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

[PROJECT_ID] の部分を実際のプロジェクト ID に置き換えて、これらの値をウィジェットのフィールドに入力します。

リクエスト本文を入力したこの API ダイアログを試し、指標記述子を作成します。

[Execute] ボタンをクリックしてメソッドを実行します。

試してみる

新しいカスタム指標を作成する際、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
	}
	defer c.Close()
	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
}

Java

// 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)
        .addLabels(
            LabelDescriptor.newBuilder()
                .setKey("store_id")
                .setValueType(LabelDescriptor.ValueType.STRING))
        .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';
async function createMetricDescriptor() {
  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}`);
  });
}
createMetricDescriptor();

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

from google.api import label_pb2 as ga_label
from google.api import metric_pb2 as ga_metric
from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
descriptor = ga_metric.MetricDescriptor()
descriptor.type = "custom.googleapis.com/my_metric" + str(uuid.uuid4())
descriptor.metric_kind = ga_metric.MetricDescriptor.MetricKind.GAUGE
descriptor.value_type = ga_metric.MetricDescriptor.ValueType.DOUBLE
descriptor.description = "This is a simple example of a custom metric."

labels = ga_label.LabelDescriptor()
labels.key = "TestLabel"
labels.value_type = ga_label.LabelDescriptor.ValueType.STRING
labels.description = "This is a test label"
descriptor.labels.append(labels)

descriptor = client.create_metric_descriptor(
    name=project_name, metric_descriptor=descriptor
)
print("Created {}.".format(descriptor.name))

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

descriptor = Google::Api::MetricDescriptor.new(
  type:        metric_type,
  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 name:              project_name,
                                         metric_descriptor: descriptor
p "Created #{result.name}"
p result

問題がある場合は、API 呼び出しのトラブルシューティングをご覧ください。

次のステップ: カスタム指標データの書き込みをご覧ください。

カスタム指標を書き込む

データを書き込むことができるのは、カスタム指標の指標タイプのみです。データを書き込むには、timeSeries.createメソッドを使用します。時系列が存在する場合、このメソッドは既存の時系列に新しいデータポイントを追加します。時系列が存在しない場合、このメソッドは、時系列を作成してデータを追加します。

データポイントを書き込むには、TimeSeries オブジェクトのリストを timeSeries.create に渡します。リストの最大サイズは 200 で、リスト内の各オブジェクトに異なる時系列を指定する必要があります。

  • metric フィールドと resource フィールドの値は、特定の TimeSeries オブジェクトを同定します。このフィールドは、データの指標タイプと、データの収集元のモニタリング対象リソースを表します。
  • metricKind フィールドと valueType フィールドは省略します。データポイントを書き込むときには無視されます。
  • TimeSeries オブジェクトには Point オブジェクトを 1 つだけ含める必要があります。

    • ポイントの値と時間間隔は指標タイプの定義と一致していなければなりません。さまざまな種類の指標の時間間隔については、TimeInterval をご覧ください。
    • ポイントの時間間隔は、時系列にすでに存在するすべてのポイントより後である必要があります。
    • 時間間隔の終了時刻は、過去 25 時間以内または未来 5 分以内でなければなりません。
  • 同じ時系列に複数のポイントを書き込むには、それぞれのポイントごとに timeSeries.create メソッドを呼び出します。5 秒ごとに 1 つのポイントよりも速く、1 つの時系列にデータを書き込むことはできません。異なる時系列にデータポイントを追加する場合、レート制限はありません。

プロトコル

指標データを書き込むには、timeSeries.create メソッドを使用します。このメソッドは、メソッドのリファレンス ページにある API Explorer ウィジェットを使用して実行できます。詳細については、API Explorer をご覧ください。

指標記述子の手動作成で作成したカスタム指標 stores/daily_sales にポイントを書き込むには:

  1. timeSeries.create のリファレンス ページに移動します。
  2. 下記のパラメータを API Explorer ウィジェットに供給します。
  3. [Execute] ボタンをクリックします。

次のサンプル パラメータを使用します。

  • 名前: projects/[PROJECT_ID]
  • リクエスト本文: この中に TimeSeries オブジェクトのリストがあります。次のサンプルでは、リストに時系列が 1 つだけ含まれています。

    {
     "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
	}
	defer c.Close()
	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
}

Java

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();

async function writeTimeSeriesData() {
  /**
   * 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);
}
writeTimeSeriesData();

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);

    $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

from google.cloud import monitoring_v3

client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"

series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/my_metric" + str(uuid.uuid4())
series.resource.type = "gce_instance"
series.resource.labels["instance_id"] = "1234567890123456789"
series.resource.labels["zone"] = "us-central1-f"
series.metric.labels["TestLabel"] = "My Label Data"
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
    {"end_time": {"seconds": seconds, "nanos": nanos}}
)
point = monitoring_v3.Point({"interval": interval, "value": {"double_value": 3.14}})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
project_name = client.project_path project: project_id

series = Google::Cloud::Monitoring::V3::TimeSeries.new
series.metric = Google::Api::Metric.new type: metric_type

resource = Google::Api::MonitoredResource.new type: "global"
resource.labels["project_id"] = project_id
series.resource = resource

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

client.create_time_series name: project_name, time_series: [series]
p "Time series created."

問題がある場合は、API 呼び出しのトラブルシューティングをご覧ください。

カスタム指標を削除する

カスタム指標を削除するには、その指標記述子を削除します。Google Cloud プロジェクトに保存されている時系列データは削除できません。ただし、指標記述子を削除すると、データにアクセスできなくなります。データは期限切れになり、データ保持ポリシーに従って削除されます。

組み込み指標の指標記述子は削除できません。

指標記述子を削除するには、metricDescriptors.delete メソッドを呼び出します。

プロトコル

指標記述子を削除するには、metricDescriptors.delete メソッドを使用します。このメソッドは、メソッドのリファレンス ページにある API Explorer ウィジェットを使用して実行できます。詳細については、API Explorer をご覧ください。

指標記述子の手動作成で作成したカスタム指標 stores/daily_sales を削除するには、次のようにします。

  1. metricDescriptors.delete のリファレンス ページに移動します。
  2. 指標記述子の名前を API Explorer ウィジェットに供給します。

    名前: projects/[PROJECT_ID]/metricDescriptors/custom.googleapis.com/stores/daily_sales

  3. [Execute] ボタンをクリックします。

試してみる

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
	}
	defer c.Close()
	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
}

Java

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();

async function deleteMetricDescriptor() {
  /**
   * 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.projectMetricDescriptorPath(projectId, metricId),
  };

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

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

from google.cloud import monitoring_v3

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

Ruby

# Your Google Cloud Platform project ID
# project_id = "YOUR_PROJECT_ID"

# Example metric type
# metric_type = "custom.googleapis.com/my_metric"

client = Google::Cloud::Monitoring.metric_service
metric_name = client.metric_descriptor_path project:           project_id,
                                            metric_descriptor: metric_type

client.delete_metric_descriptor name: metric_name
p "Deleted metric descriptor #{metric_name}."

問題がある場合は、API 呼び出しのトラブルシューティングをご覧ください。

カスタム指標の変更

カスタム指標を変更するには、カスタム指標を定義する MetricDescriptor オブジェクトを更新する必要があります。サポートされている唯一の変更は、ラベルを追加することです。

既存のカスタム指標にラベルを追加するには、timeSeries.create メソッドを使用して、時系列データを含む新しいラベルを追加します。 書き込もうとしているラベルが有効で、ラベルの総数が 30 未満の場合、ラベルは指標記述子に追加されます。

その後は、あたかもそのラベルが最初から存在していたかのように時系列データが書き込まれます。

新しいラベルを追加する以上の変更を加える場合は、指標記述子を削除して再作成する必要があります。この場合、それまでに収集された古い指標記述子の時系列データはすべて失われます。詳細については、カスタム指標の削除をご覧ください。

指標の名前は変更できません。

次のステップ