Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Membuat metrik yang ditentukan pengguna dengan API

Membuat metrik yang ditentukan pengguna (juga disebut metrik kustom) dengan Cloud Monitoring API memungkinkan Anda mengambil pengukuran khusus aplikasi dan membuat diagram atau pemberitahuan untuk pengukuran tersebut, sama seperti metrik Cloud Monitoring bawaan. Seperti metrik bawaan, setiap metrik yang ditentukan pengguna menggabungkan titik data, jenis metrik yang menentukan apa yang diwakili oleh titik tersebut, dan resource yang dipantau yang mengidentifikasi asal data.

Untuk melengkapi aplikasi Anda, sebaiknya gunakan framework instrumentasi open source yang netral terhadap vendor, seperti OpenTelemetry, bukan API atau library klien khusus vendor dan produk. Untuk mengetahui informasi tentang framework ini, lihat Kemampuan observasi untuk developer aplikasi dan Memilih pendekatan instrumentasi.

Anda tidak dapat menggunakan Monitoring API untuk membuat metrik berbasis log, yang memperoleh data metrik dari entri log. Sebagai gantinya, Cloud Logging membuat struktur metrik dan mengirimkan data ke Cloud Monitoring untuk Anda; lihat Membuat metrik penghitung dan Membuat metrik distribusi.

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:

Di konsol Google Cloud , pada halaman pemilih project, pilih atau buat project Google Cloud .
Peran yang diperlukan untuk memilih atau membuat project
- Memilih project: Memilih project tidak memerlukan peran IAM tertentu—Anda dapat memilih project apa pun yang perannya telah diberikan kepada Anda.
- Membuat project: Untuk membuat project, Anda memerlukan peran Project Creator (roles/resourcemanager.projectCreator), yang berisi izin resourcemanager.projects.create. Pelajari cara memberikan peran.
Buka pemilih project
Pastikan penagihan diaktifkan untuk project Google Cloud Anda.
Pastikan Monitoring API diaktifkan. Untuk mengetahui detailnya, lihat Mengaktifkan Monitoring API.
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 lingkungan lokal atau penyedia cloud lainnya.

Membuat jenis metrik yang ditentukan pengguna

Untuk membuat metrik yang ditentukan pengguna, Anda dapat menentukan objek MetricDescriptor yang menentukan berbagai informasi tentang metrik, atau 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 cara mendesain deskriptor metrik, lihat Deskriptor metrik untuk metrik yang ditentukan pengguna.

Pembuatan otomatis deskriptor metrik

Jika Anda menulis data metrik saat deskriptor metrik untuk metrik yang ditentukan pengguna tersebut belum ada, deskriptor metrik akan dibuat secara otomatis. Namun, deskriptor metrik baru ini mungkin tidak sesuai dengan keinginan Anda; pembuatan otomatis deskriptor 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 deskriptor label dalam deskriptor 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 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: belum ditetapkan
description: "Auto created custom metric.".
displayName: belum 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:

Tentukan struktur deskriptor metrik Anda. Untuk membantu 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 memerlukan metrik yang sama di beberapa project, buat definisi metrik yang identik di setiap project.
4. Tentukan jenis metrik, jenis nilai, dan (opsional) unit. 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.
Tentukan resource yang dimonitor yang menjadi tujuan penulisan 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.
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 akan menyebabkan error. Namun, jika semua kolom objek MetricDescriptor baru sama persis dengan kolom deskripsi yang ada, hal ini tidak akan menyebabkan error, tetapi tidak akan berpengaruh.

Dalam contoh berikut, Anda akan membuat metrik gauge.

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 mengetahui 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]:

Dialog Try this API yang diisi dengan isi permintaan untuk membuat deskriptor metrik.

Klik tombol Execute untuk menjalankan metode.

Cobalah!

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

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

Misalnya, jika Anda ingin mendapatkan deskriptor metrik, gunakan 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 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.
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 akhir interval tidak boleh lebih dari 25 jam di masa lalu atau lebih dari lima menit di masa mendatang.
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 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 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:

Buka halaman referensi untuk timeSeries.create.
Berikan parameter di bawah ke widget APIs Explorer.
Klik tombol Execute.

Gunakan contoh parameter berikut:

name: projects/[PROJECT_ID]

Isi permintaan: Sertakan daftar objek TimeSeries. Contoh berikut hanya memiliki satu deret waktu dalam daftar.

{
 "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!

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

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:

Buka halaman referensi untuk metricDescriptors.delete.
Berikan nama deskriptor metrik ke widget APIs Explorer:

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

Cobalah!

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 yang ditentukan pengguna, Anda harus memperbarui objek MetricDescriptor yang menentukan metrik tersebut. 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 deskriptor metrik saat label yang Anda coba tulis valid dan jumlah total label kurang dari 30.

Data deret waktu kemudian ditulis seolah-olah label telah 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.

Membuat metrik yang ditentukan pengguna dengan API Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Sebelum memulai

Membuat jenis metrik yang ditentukan pengguna

Pembuatan otomatis deskriptor metrik

Pembuatan deskriptor metrik secara manual

Protokol

C#

Go

Java

Node.js

PHP

Python

Ruby

Menulis metrik yang ditentukan pengguna

Protokol

C#

Go

Java

Node.js

PHP

Python

Ruby

Menghapus metrik yang ditentukan pengguna

Protokol

C#

Go

Java

Node.js

PHP

Python

Ruby

Mengubah metrik yang ditentukan pengguna

Langkah berikutnya

Membuat metrik yang ditentukan pengguna dengan API