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:

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

Metrik yang ditentukan 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.

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

Catatan: Metrik yang ditentukan pengguna adalah fitur Cloud Monitoring yang dapat ditagih dan mungkin akan 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 diperlukan, lakukan tindakan berikut:

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

   Buka pemilih project

2. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

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 mengonfigurasi variabel lingkungan.

   Untuk aplikasi yang Anda jalankan pada instance Amazon Elastic Compute Cloud (Amazon EC2), buat akun layanan untuk project AWS Connector instance.

   Untuk informasi tentang cara membuat akun layanan, lihat Mulai menggunakan autentikasi.

Membuat jenis metrik yang ditentukan pengguna

Untuk membuat metrik yang ditentukan pengguna, tentukan objek MetricDescriptor yang menentukan berbagai informasi tentang metrik, atau tulis data metrik. Saat Anda menulis data metrik, Monitoring akan membuat deskripsi metrik berdasarkan struktur data yang Anda berikan. Untuk informasi tentang mendesain deskriptor 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, deskriptor metrik akan dibuat secara otomatis. Namun, deskripsi metrik baru ini mungkin tidak sama persis dengan yang Anda inginkan; pembuatan deskripsi 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 ini disalin dari kolom type objek Metric.
• name: Nama dibuat dari project ID dalam panggilan metode dan nilai type di objek Metric.
• labels: Label yang muncul di objek Metric. Setiap deskripsi label dalam deskripsi metrik baru memiliki kolom berikut:
  • key: kunci label di objek Metric.
  • valueType: STRING
  • description: belum 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 pada TimeSeries, jenis tersebut harus cocok dengan jenis Point.
• unit: belum ditetapkan
• description: "Auto created custom metric.".
• displayName: belum ditetapkan

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

Langkah berikutnya: Baca Menulis metrik yang ditentukan pengguna.

Pembuatan deskripsi metrik secara manual

Untuk membuat deskripsi metrik, lakukan tindakan berikut:

1. Tentukan struktur deskriptor metrik Anda. Untuk mendapatkan bantuan dalam membuat pilihan ini, Anda dapat menjelajahi 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 untuk menentukan metrik yang ditentukan pengguna dan menulis data deret waktunya. Jika Anda membutuhkan metrik yang sama di beberapa project, buat definisi metrik yang identik di setiap project.

      Untuk menulis metrik yang ditentukan pengguna dari resource yang dikelola oleh akun AWS, buat deskripsi metrik di project konektor AWS untuk akun tersebut.

   4. Tentukan jenis, jenis nilai, dan satuan (opsional) 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 dimonitor 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 saat tidak ada jenis resource lain yang cocok. 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, akan terjadi error saat memanggil metricDescriptors.create menggunakan nama jenis yang sama dengan deskriptor metrik yang ada. Namun, jika semua kolom objek MetricDescriptor baru sama persis dengan kolom deskripsi yang ada, maka itu bukan error, tetapi tidak berpengaruh.

Pada contoh berikut, Anda membuat metrik meteran.

Protokol

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

Berikut adalah contoh parameter untuk metricDescriptors.create:

• name (URL): projects/[PROJECT_ID]

• Request body: sediakan 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 akan diabaikan dan dapat dihilangkan. Metode create menampilkan deskripsi metrik baru dengan kolom name yang terisi, 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, gunakan nama ini.

C#

Untuk mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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: Baca 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 dimonitor tempat data dikumpulkan.
• Hapus kolom metricKind dan valueType; kolom tersebut akan 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 bagi jenis metrik yang berbeda, lihat TimeInterval.
  • Interval waktu titik harus lebih lambat dari 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 yang lalu.

• 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 satu deret waktu lebih cepat dari satu poin setiap 5 detik. Saat Anda menambahkan titik data ke deret waktu yang berbeda, tidak ada pembatasan kapasitas.

Protokol

Untuk menulis data metrik, gunakan metode timeSeries.create. Anda dapat menjalankan metode ini menggunakan widget APIs Explorer di halaman referensi metode. Lihat Penjelajah API untuk mengetahui 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. Sediakan parameter di bawah ini ke widget APIs Explorer.
3. Klik tombol Execute.

Gunakan contoh parameter berikut:

• nama: projects/[PROJECT_ID]

• request body: menyertakan 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 yang ditentukan pengguna

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

Anda tidak dapat menghapus deskripsi metrik untuk metrik bawaan.

Catatan: Menghapus deskriptor metrik membuat data deret waktu yang ada tidak dapat diakses. Jika Anda membuat ulang deskriptor metrik yang telah dihapus, persis seperti sebelum dihapus, Anda bisa mendapatkan kembali akses ke data tersebut. Jangan bergantung pada 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 Penjelajah API untuk mengetahui 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:

   nama: 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 mengautentikasi 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 yang ditentukan pengguna, Anda harus memperbarui objek MetricDescriptor yang menentukan metrik tersebut. Satu-satunya perubahan 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 deskriptif metrik jika label yang Anda coba tulis valid dan jumlah total label kurang dari 30.

Kemudian, data deret waktu ditulis seolah-olah label sudah ada sejak awal.

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

Anda tidak dapat mengganti nama metrik.

Langkah selanjutnya

• Melihat penggunaan dan diagnostik metrik
• Daftar metrik bawaan
• Daftar resource yang dimonitor