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 yang digunakan metrik Cloud Monitoring bawaan:

• Kumpulan titik data.
• Informasi jenis metrik, yang memberi tahu Anda apa yang diwakili oleh titik data.
• Informasi resource yang dipantau, yang memberi tahu Anda tempat titik data berasal.

Metrik buatan pengguna, yang 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 dalam metrik yang ditentukan pengguna, tetapi Anda tidak dapat membuatnya menggunakan Cloud Monitoring API. Metrik berbasis log memperoleh 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 mengirim data metrik ke Cloud Monitoring untuk Anda. Untuk informasi tentang cara membuat metrik berbasis log, lihat dokumen berikut:

• Membuat metrik penghitung
• Membuat metrik distribusi

Untuk melengkapi aplikasi Anda, sebaiknya gunakan framework instrumentasi netral vendor yang bersifat open source, seperti OpenTelemetry, bukan API atau library klien khusus vendor dan produk. Untuk informasi tentang cara melengkapi aplikasi Anda, lihat Instrumentasi dan observabilitas.

Catatan: Metrik yang ditentukan pengguna adalah fitur Cloud Monitoring yang dapat ditagih dan mungkin ada biaya untuk metrik ini. Untuk mengetahui informasi harga, lihat ringkasan harga Cloud Monitoring.

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 yang diaktifkan. Jika perlu, lakukan hal berikut:

1. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Buka pemilih project

2. Make sure 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 Anda. Biasanya, Anda mengonfigurasi autentikasi dengan membuat akun layanan untuk project dan dengan mengonfigurasi variabel lingkungan.

   Untuk informasi tentang cara membuat akun layanan, lihat Memulai autentikasi.

Membuat jenis metrik yang ditentukan pengguna

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

Pembuatan deskripsi metrik secara otomatis

Jika Anda menulis data metrik saat deskripsi metrik untuk metrik yang ditentukan pengguna tersebut belum ada, deskripsi metrik akan dibuat secara otomatis. Namun, deskripsi metrik baru ini mungkin tidak persis seperti yang Anda inginkan; pembuatan otomatis deskripsi metrik 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 kolom type objek Metric.
• name: Nama dibuat dari project ID dalam panggilan metode dan nilai type dalam objek Metric.
• labels: Label yang muncul di objek Metric. Setiap deskripsi label dalam deskripsi 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 akan memiliki jenis tersebut. Anda hanya dapat menentukan jenis GAUGE dan CUMULATIVE.
• valueType: Jenis nilai diambil dari nilai yang diketik dari Point yang 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 yang tidak ada. Dalam hal ini, label dalam deskripsi 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 deskripsi metrik secara manual

Untuk membuat deskripsi metrik, lakukan hal berikut:

1. Tentukan struktur deskripsi metrik Anda. Untuk mendapatkan bantuan dalam membuat pilihan ini, Anda dapat menelusuri metrik bawaan dan melihat data deret waktunya:

   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. Jika Anda memerlukan metrik yang sama di beberapa project, buat definisi metrik yang identik di setiap project.

   4. Tentukan jenis metrik, jenis nilai, dan (opsional) satuan. Tidak semua jenis nilai dan jenis metrik didukung untuk metrik yang ditentukan pengguna. Untuk 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 tempat data metrik ditulis. 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 penampung 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 deskripsi metrik yang ada merupakan error. Namun, jika semua kolom objek MetricDescriptor baru cocok persis dengan kolom deskripsi yang ada, hal ini bukan merupakan error, tetapi tidak berpengaruh.

Dalam contoh berikut, Anda akan membuat metrik pengukur.

Protokol

Untuk membuat deskripsi metrik, gunakan metode metricDescriptors.create. Anda dapat menjalankan metode ini menggunakan widget API 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 project ID Anda sebagai pengganti [PROJECT_ID]:

Klik tombol Execute untuk menjalankan metode.

Coba!

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

Saat membuat metrik baru, kolom name di MetricDescriptor akan diabaikan dan dapat dihilangkan. Metode create menampilkan deskripsi 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 ingin mendapatkan deskripsi metrik, Anda dapat menggunakan nama ini.

C#

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca 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, baca 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, baca 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, baca 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, baca 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, baca 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, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# 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 yang ditentukan pengguna

Anda hanya dapat menulis data ke jenis metrik untuk metrik yang ditentukan pengguna. Untuk menulis data, 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 mewakili jenis metrik data dan resource yang dipantau tempat data dikumpulkan.
• Hapus kolom metricKind dan valueType; kolom tersebut diabaikan saat menulis titik data.

• Setiap objek TimeSeries hanya boleh berisi satu objek Point:

  • Nilai titik dan interval waktu harus konsisten dengan definisi jenis metrik. Untuk mengetahui informasi tentang interval waktu untuk berbagai jenis metrik, lihat TimeInterval.
  • Interval waktu titik harus lebih lambat dari titik yang sudah ada dalam deret waktu.
  • Waktu akhir 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 kapasitas.

Protokol

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

Untuk menulis titik ke metrik stores/daily_sales yang dibuat di Pembuatan deskripsi 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
       }
      }
     ]
    }
   ]
  }
  

Coba!

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

C#

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca 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, baca 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, baca 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, baca 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, baca 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, baca 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, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# 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 deskripsi metrik akan membuat data tidak dapat diakses. Masa berlaku data akan berakhir dan dihapus sesuai dengan kebijakan retensi data.

Anda tidak dapat menghapus deskripsi metrik untuk metrik bawaan.

Catatan: Menghapus deskripsi metrik akan membuat data deret waktunya yang ada tidak dapat diakses. Jika Anda membuat ulang deskripsi metrik yang dihapus, persis seperti sebelum penghapusan, Anda mungkin dapat mengakses kembali data tersebut. Jangan mengandalkan perilaku ini.

Untuk menghapus deskripsi metrik, panggil metode metricDescriptors.delete.

Protokol

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

Untuk menghapus metrik stores/daily_sales yang dibuat di Pembuatan deskripsi 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.

Coba!

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

C#

Untuk melakukan autentikasi ke Monitoring, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca 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, baca 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, baca 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, baca 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, baca 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, baca 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, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# 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 ada, gunakan metode timeSeries.create dan sertakan label baru dengan data deret waktu. Label ditambahkan ke deskripsi metrik jika 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 ingin melakukan lebih dari sekadar menambahkan label baru, Anda harus menghapus dan membuat ulang deskripsi metrik. Dalam hal ini, Anda akan kehilangan semua data deret waktu yang sebelumnya dikumpulkan untuk deskripsi metrik lama. Lihat Menghapus metrik yang ditentukan pengguna untuk mengetahui informasi selengkapnya.

Anda tidak dapat mengganti nama metrik.

Langkah selanjutnya

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