Membuat metrik yang ditentukan pengguna dengan API

Dokumen ini menjelaskan cara membuat metrik yang ditentukan pengguna dan cara menulis data metrik ini menggunakan Cloud Monitoring API. Metrik yang ditentukan pengguna menggunakan elemen yang sama dengan metrik Cloud Monitoring bawaan:

• Sekumpulan titik data.
• Informasi jenis metrik, yang memberi tahu Anda apa yang diwakili oleh titik data.
• Informasi resource yang dipantau, yang memberi tahu Anda asal titik data.

Metrik buatan pengguna, terkadang disebut metrik kustom, dapat digunakan dengan cara yang sama seperti metrik bawaan. Artinya, Anda dapat membuat diagram dan pemberitahuan untuk data metrik ini.

Metrik berbasis log adalah class metrik yang ditentukan pengguna, tetapi Anda tidak dapat membuatnya menggunakan Cloud Monitoring API. Metrik berbasis log mendapatkan data metrik dari entri log, tetapi Monitoring API tidak menyediakan cara untuk menentukan cara mengekstrak data metrik dari entri log. Sebagai gantinya, gunakan Cloud Logging untuk membuat metrik berbasis log. Saat Anda membuat metrik berbasis log, Logging akan membuat struktur yang dijelaskan dalam dokumen ini dan mengirimkan data metrik ke Cloud Monitoring untuk Anda. Untuk mengetahui informasi tentang cara membuat metrik berbasis log, lihat dokumen berikut:

• Membuat metrik penghitung
• Membuat metrik distribusi

Untuk menginstrumentasi aplikasi, sebaiknya gunakan framework instrumentasi netral vendor yang bersifat open source, seperti OpenTelemetry, bukan API atau library klien khusus produk dan vendor. Untuk mengetahui informasi tentang menginstrumentasikan aplikasi Anda, lihat Instrumentasi dan kemampuan observasi.

Catatan: Metrik yang ditentukan pengguna adalah fitur Cloud Monitoring yang dikenai biaya dan ada kemungkinan biaya untuk metrik ini. Untuk mengetahui informasi harga, lihat bagian Cloud Monitoring di halaman harga Google Cloud Observability.

Sebelum memulai

Untuk mempelajari struktur yang mendasari semua metrik, lihat Metrik, deret waktu, dan resource.

Untuk menggunakan Cloud Monitoring, Anda harus memiliki project Google Cloud dengan penagihan diaktifkan. Jika perlu, lakukan hal berikut:

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Pastikan Monitoring API diaktifkan. Untuk mengetahui detailnya, lihat Mengaktifkan Monitoring API.
4. Untuk aplikasi yang berjalan di luar Google Cloud, project Google Cloud Anda harus mengautentikasi aplikasi menggunakan Kredensial Default Aplikasi (ADC) lokal. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan ADC untuk penyedia lokal atau penyedia cloud lainnya.

Membuat jenis metrik yang ditentukan pengguna

Untuk membuat metrik buatan pengguna, Anda dapat menentukan objek MetricDescriptor yang menentukan berbagai informasi tentang metrik, atau Anda dapat menulis data metrik. Saat Anda menulis data metrik, Monitoring akan membuat deskriptor metrik untuk Anda berdasarkan struktur data yang Anda berikan. Untuk mengetahui informasi tentang mendesain deskriptor metrik, lihat Deskriptor metrik untuk metrik yang ditentukan pengguna.

Pembuatan deskriptor metrik otomatis

Jika Anda menulis data metrik saat deskriptor metrik untuk metrik yang ditentukan pengguna tersebut belum ada, maka deskriptor metrik akan dibuat secara otomatis. Namun, deskriptor metrik baru ini mungkin tidak persis seperti yang Anda inginkan; pembuatan deskriptor metrik secara otomatis melibatkan beberapa asumsi dan default.

Cloud Monitoring membuat MetricDescriptor baru saat objek TimeSeries yang disertakan dalam panggilan ke timeSeries.create mereferensikan objek Metric yang menentukan nama jenis metrik yang tidak ada. Cloud Monitoring menggunakan aturan berikut untuk mengisi MetricDescriptor:

• type: Jenis disalin dari objek Metric type.
• name: Nama dibuat dari project ID dalam panggilan metode dan nilai type dalam objek Metric.
• labels: Label yang muncul di objek Metric. Setiap deskriptor label dalam deskriptor metrik baru memiliki kolom berikut:
  • key: kunci label dalam objek Metric.
  • valueType: STRING
  • description: tidak ditetapkan
• metricKind: Jenis metrik ditetapkan ke GAUGE kecuali jika Anda menentukan parameter metricKind dari objek TimeSeries. Saat Anda menentukan metricKind, metrik baru memiliki jenis tersebut. Anda hanya dapat menentukan jenis GAUGE dan CUMULATIVE.
• valueType: Jenis nilai diambil dari nilai yang diketik dari Point yang sedang ditulis. Jenis nilai harus berupa BOOL, INT64, DOUBLE, atau DISTRIBUTION. Saat Anda menentukan jenis nilai di kolom valueType dari TimeSeries, jenis tersebut harus cocok dengan jenis Point.
• unit: tidak ditetapkan
• description: "Auto created custom metric.".
• displayName: tidak ditetapkan

Dalam satu panggilan timeSeries.create, Anda dapat menyertakan beberapa objek TimeSeries yang merujuk ke jenis metrik yang sama dan tidak ada. Dalam hal ini, label dalam deskriptor metrik baru terdiri dari gabungan semua label dalam objek Metric di semua deret waktu dalam panggilan ini ke create.

Langkah berikutnya: Lihat Menulis metrik yang ditentukan pengguna.

Pembuatan deskriptor metrik secara manual

Untuk membuat deskriptor metrik, lakukan hal berikut:

1. Tentukan struktur deskriptor metrik Anda. Untuk mendapatkan bantuan dalam membuat pilihan ini, Anda dapat menjelajahi metrik bawaan dan melihat data deret waktu:

   1. Pilih nama metrik untuk metrik yang ditentukan pengguna.

   2. Pilih nama tampilan dan deskripsi untuk metrik Anda. Nama tampilan digunakan di konsol Google Cloud .

   3. Pilih satu atau beberapa project tempat Anda akan menentukan metrik yang ditentukan pengguna dan menulis data deret waktunya. Saat Anda memerlukan metrik yang sama di beberapa project, buat definisi metrik yang identik di setiap project.

   4. Tentukan jenis, jenis nilai, dan (opsional) satuan metrik. Tidak semua jenis nilai dan jenis metrik didukung untuk metrik yang ditentukan pengguna. Untuk mengetahui informasi selengkapnya tentang kolom ini, lihat Jenis nilai dan jenis metrik.

   5. Pilih label metrik—nama, jenis nilai, dan deskripsinya.

2. Menentukan resource yang dipantau yang digunakan untuk menulis data metrik. Pilih dari daftar berikut:

   • aws_ec2_instance: Instance Amazon EC2.
   • dataflow_job: Tugas Dataflow.
   • gae_instance: Instance App Engine.
   • gce_instance: Instance Compute Engine.
   • generic_node: Node komputasi yang ditentukan pengguna.
   • generic_task: Tugas yang ditentukan pengguna.
   • gke_container: Instance container GKE.
   • global: Gunakan resource ini jika tidak ada jenis resource lain yang sesuai. Untuk sebagian besar kasus penggunaan, generic_node atau generic_task adalah pilihan yang lebih baik daripada global.
   • k8s_cluster: Cluster Kubernetes.
   • k8s_container: Container Kubernetes.
   • k8s_node: Node Kubernetes.
   • k8s_pod: Pod Kubernetes.

3. Buat objek MetricDescriptor, lalu teruskan sebagai argumen ke panggilan ke metode metricDescriptors.create.

Biasanya, memanggil metricDescriptors.create menggunakan nama jenis yang sama dengan deskriptor metrik yang ada merupakan error. Namun, jika semua kolom objek MetricDescriptor baru cocok dengan kolom deskriptor yang ada, maka itu bukan error, tetapi tidak akan berpengaruh.

Dalam contoh berikut, Anda membuat metrik pengukur.

Protokol

Untuk membuat deskriptor metrik, gunakan metode metricDescriptors.create. Anda dapat menjalankan metode ini menggunakan widget APIs Explorer di halaman referensi metode. Lihat APIs Explorer untuk informasi selengkapnya.

Berikut adalah contoh parameter untuk metricDescriptors.create:

• name (URL): projects/[PROJECT_ID]

• Isi permintaan: berikan objek MetricDescriptor seperti berikut:

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

Berikan nilai ini ke kolom di widget, menggunakan ID project Anda sebagai pengganti [PROJECT_ID]:

Klik tombol Execute untuk menjalankan metode.

Cobalah!

Catatan: Untuk melihat permintaan sebagai perintah curl, sebagai permintaan HTTP, atau di JavaScript, klik Layar penuh di APIs Explorer.

Saat membuat metrik baru, kolom name di MetricDescriptor diabaikan dan dapat dihilangkan. Metode create menampilkan deskriptor metrik baru dengan kolom name yang diisi, yang dalam contoh ini adalah sebagai berikut:

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

Misalnya, jika Anda ingin mendapatkan deskriptor metrik, Anda menggunakan nama ini.

C#

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

        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

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

import (
	"context"
	"fmt"
	"io"

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

// 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: %w", err)
	}

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

Java

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

// Your Google Cloud Platform project ID
final String projectId = System.getProperty("projectId");

try (final MetricServiceClient client = MetricServiceClient.create();) {
  ProjectName projectName = ProjectName.of(projectId);

  MetricDescriptor descriptor =
      MetricDescriptor.newBuilder()
          .setType(type)
          .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(projectName.toString())
          .setMetricDescriptor(descriptor)
          .build();

  descriptor = client.createMetricDescriptor(request);
  System.out.println("Created descriptor " + descriptor.getName());
}

Node.js

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

// 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

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

use Google\Api\LabelDescriptor;
use Google\Api\MetricDescriptor;
use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\CreateMetricDescriptorRequest;

/**
 * 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 = 'projects/' . $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);
    $createMetricDescriptorRequest = (new CreateMetricDescriptorRequest())
        ->setName($projectName)
        ->setMetricDescriptor($descriptor);

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

Python

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

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

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

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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

Lihat Memecahkan masalah panggilan API jika Anda mengalami kesulitan.

Langkah berikutnya: Lihat Menulis metrik yang ditentukan pengguna.

Menulis metrik buatan pengguna

Anda hanya dapat menulis data ke jenis metrik untuk metrik yang ditentukan pengguna. Untuk menulis data Anda, gunakan metode timeSeries.create. Jika deret waktu ada, metode ini akan menambahkan titik data baru ke deret waktu yang ada. Jika deret waktu tidak ada, metode ini akan membuatnya dan menambahkan data.

Anda menulis titik data dengan meneruskan daftar objek TimeSeries ke timeSeries.create. Ukuran daftar maksimum adalah 200 dan setiap objek dalam daftar harus menentukan deret waktu yang berbeda:

• Nilai kolom metric dan resource mengidentifikasi objek TimeSeries tertentu. Kolom ini merepresentasikan jenis metrik data dan resource yang dipantau dari mana data dikumpulkan.
• Hilangkan kolom metricKind dan valueType; kolom tersebut diabaikan saat menulis titik data.

• Setiap objek TimeSeries hanya boleh berisi satu objek Point:

  • Nilai dan interval waktu titik harus konsisten dengan definisi jenis metrik. Untuk mengetahui informasi tentang interval waktu untuk berbagai jenis metrik, lihat TimeInterval.
  • Interval waktu titik harus lebih lambat daripada titik mana pun yang sudah ada dalam deret waktu.
  • Waktu berakhir interval tidak boleh lebih dari 25 jam yang lalu atau lebih dari lima menit ke depan.

• Untuk menulis lebih dari satu titik ke deret waktu yang sama, gunakan panggilan terpisah ke metode timeSeries.create untuk setiap titik. Jangan menulis data ke deret waktu tunggal lebih cepat dari satu titik setiap 5 detik. Saat Anda menambahkan titik data ke deret waktu yang berbeda, tidak ada batasan kecepatan.

Protokol

Untuk menulis data metrik, gunakan metode timeSeries.create. Anda dapat menjalankan metode ini menggunakan widget APIs Explorer di halaman referensi metode. Lihat APIs Explorer untuk mengetahui informasi selengkapnya.

Untuk menulis titik ke metrik stores/daily_sales yang dibuat di Pembuatan deskriptor metrik secara manual:

1. Buka halaman referensi untuk timeSeries.create.
2. Berikan parameter di bawah ke widget API Explorer.
3. Klik tombol Execute.

Gunakan parameter contoh berikut:

• name: projects/[PROJECT_ID]

• isi permintaan: sertakan daftar objek TimeSeries. Contoh berikut hanya memiliki satu deret waktu dalam daftar.

  Catatan: Anda harus mengubah nilai project_id dan endTime dalam isi permintaan berikut. Gunakan ID project Anda. endTime harus mendekati waktu saat ini; date -Iseconds menampilkan waktu saat ini dalam format yang dapat digunakan.

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

Cobalah!

Catatan: Untuk melihat permintaan sebagai perintah curl, sebagai permintaan HTTP, atau di JavaScript, klik Layar penuh di APIs Explorer.

C#

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

        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

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

// 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, %w ", err)
	}
	return nil
}

Java

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

String projectId = System.getProperty("projectId");

// 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
try (final MetricServiceClient client = MetricServiceClient.create();) {
  client.createTimeSeries(request);
}
System.out.println("Done writing time series value.");

Node.js

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

// 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

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

use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\CreateTimeSeriesRequest;
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 = 'projects/' . $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);
    $createTimeSeriesRequest = (new CreateTimeSeriesRequest())
        ->setName($projectName)
        ->setTimeSeries([$timeSeries]);

    $metrics->createTimeSeries($createTimeSeriesRequest);

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

Python

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

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-c"
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

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

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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."

Lihat Memecahkan masalah panggilan API jika Anda mengalami kesulitan.

Menghapus metrik buatan pengguna

Untuk menghapus metrik yang ditentukan pengguna, hapus deskripsi metriknya. Anda tidak dapat menghapus data deret waktu yang disimpan di project Google Cloud ; namun, menghapus deskriptor metrik akan membuat data tidak dapat diakses. Data akan berakhir masa berlakunya dan dihapus sesuai dengan kebijakan retensi data.

Anda tidak dapat menghapus deskriptor metrik untuk metrik bawaan.

Catatan: Menghapus deskriptor metrik akan membuat data deret waktu yang ada menjadi tidak dapat diakses. Jika Anda membuat ulang deskriptor metrik yang dihapus, persis seperti sebelum dihapus, Anda mungkin mendapatkan kembali akses ke data. Jangan mengandalkan perilaku ini.

Untuk menghapus deskriptor metrik, panggil metode metricDescriptors.delete.

Protokol

Untuk menghapus deskriptor metrik, gunakan metode metricDescriptors.delete. Anda dapat menjalankan metode ini menggunakan widget APIs Explorer di halaman referensi metode. Lihat APIs Explorer untuk mengetahui informasi selengkapnya.

Untuk menghapus metrik stores/daily_sales yang dibuat di Pembuatan deskriptor metrik secara manual:

1. Buka halaman referensi untuk metricDescriptors.delete:

2. Berikan nama deskriptor metrik ke widget APIs Explorer:

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

3. Klik tombol Execute.

Cobalah!

Catatan: Untuk melihat permintaan sebagai perintah curl, sebagai permintaan HTTP, atau di JavaScript, klik Layar penuh di APIs Explorer.

C#

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

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

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

import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
)

// 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: %w", err)
	}
	fmt.Fprintf(w, "Deleted metric: %q\n", name)
	return nil
}

Java

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

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

Node.js

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

// 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

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

use Google\Cloud\Monitoring\V3\Client\MetricServiceClient;
use Google\Cloud\Monitoring\V3\DeleteMetricDescriptorRequest;

/**
 * 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);
    $deleteMetricDescriptorRequest = (new DeleteMetricDescriptorRequest())
        ->setName($metricPath);
    $metrics->deleteMetricDescriptor($deleteMetricDescriptorRequest);

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

Python

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

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

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

gem "google-cloud-monitoring"
require "google/cloud/monitoring"

# 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}."

Lihat Memecahkan masalah panggilan API jika Anda mengalami kesulitan.

Mengubah metrik yang ditentukan pengguna

Untuk mengubah metrik buatan pengguna, Anda harus memperbarui objek MetricDescriptor yang menentukan metrik. Satu-satunya modifikasi yang didukung adalah menambahkan label.

Untuk menambahkan label ke metrik yang ditentukan pengguna yang sudah ada, gunakan metode timeSeries.create dan sertakan label baru dengan data deret waktu. Label ditambahkan ke deskriptor metrik saat label yang Anda coba tulis valid dan jumlah total label kurang dari 30.

Data deret waktu kemudian ditulis seolah-olah label sudah ada sejak awal.

Jika Anda ingin melakukan lebih dari sekadar menambahkan label baru, Anda harus menghapus dan membuat ulang deskriptor metrik. Dalam hal ini, Anda akan kehilangan semua data deret waktu yang sebelumnya dikumpulkan untuk deskriptor metrik lama. Lihat Menghapus metrik yang ditentukan pengguna untuk mengetahui informasi selengkapnya.

Anda tidak dapat mengganti nama metrik.

Langkah berikutnya

• Melihat dan mengelola penggunaan metrik
• Daftar metrik bawaan
• Daftar resource yang dipantau