Creare metriche definite dall'utente con l'API

La creazione di metriche definite dall'utente (chiamate anche metriche personalizzate) con l'API Cloud Monitoring consente di acquisire misurazioni specifiche dell'applicazione e di creare grafici o avvisi, proprio come le metriche integrate di Cloud Monitoring. Come le metriche integrate, ogni metrica definita dall'utente combina punti dati, un tipo di metrica che definisce ciò che rappresentano i punti e una risorsa monitorata che identifica l'origine dei dati.

Per instrumentare la tua applicazione, ti consigliamo di utilizzare un framework di strumentazione open source e indipendente dal fornitore, come OpenTelemetry, anziché API o librerie client specifiche del fornitore e del prodotto. Per informazioni su questi framework, consulta Osservabilità per gli sviluppatori di applicazioni e Scegli un approccio di strumentazione.

Non puoi utilizzare l'API Monitoring per creare metriche basate su log, che derivano i dati delle metriche dalle voci di log. Invece, Cloud Logging crea le strutture delle metriche e invia i dati a Cloud Monitoring per te; consulta Crea metriche contatore e Crea metriche di distribuzione.

Prima di iniziare

Per scoprire di più sulle strutture alla base di tutte le metriche, consulta Metriche, serie temporali e risorse.

Per utilizzare Cloud Monitoring, devi avere un progetto Google Cloud con la fatturazione abilitata. Se necessario, procedi nel seguente modo:

1. Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .

   Ruoli richiesti per selezionare o creare un progetto

   • Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
   • Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

   Vai al selettore di progetti

2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

3. Assicurati che l'API Monitoring sia abilitata. Per maggiori dettagli, consulta Abilitazione dell'API Monitoring.
4. Per le applicazioni in esecuzione al di fuori di Google Cloud, il tuo progetto Google Cloud deve autenticare l'applicazione utilizzando le Credenziali predefinite dell'applicazione (ADC) locali. Per saperne di più, consulta Configura ADC per on-premise o un altro provider cloud.

Crea un tipo di metrica definita dall'utente

Per creare una metrica definita dall'utente, definisci un oggetto MetricDescriptor che specifica varie informazioni sulla metrica oppure scrivi i dati della metrica. Quando scrivi i dati delle metriche, Monitoring crea il descrittore della metrica in base alla struttura dei dati che fornisci. Per informazioni sulla progettazione di un descrittore della metrica, consulta Descrittori delle metriche per le metriche definite dall'utente.

Creazione automatica dei descrittori delle metriche

Se scrivi dati delle metriche quando non esiste ancora un descrittore della metrica per la metrica definita dall'utente, viene creato automaticamente un descrittore della metrica. Tuttavia, questo nuovo descrittore della metrica potrebbe non essere esattamente quello che vuoi; la creazione automatica dei descrittori delle metriche prevede alcune ipotesi e impostazioni predefinite.

Cloud Monitoring crea un nuovo MetricDescriptor quando l'oggetto TimeSeries incluso in una chiamata a timeSeries.create fa riferimento a un oggetto Metric che specifica un nome del tipo di metrica inesistente. Cloud Monitoring utilizza le seguenti regole per compilare il campo MetricDescriptor:

• type: il tipo viene copiato dal campo type dell'oggetto Metric.
• name: il nome viene creato dall'ID progetto nella chiamata al metodo e dal valore di type nell'oggetto Metric.
• labels: le etichette visualizzate nell'oggetto Metric. Ogni descrittore di etichetta nel nuovo descrittore della metrica ha i seguenti campi:
  • key: la chiave dell'etichetta nell'oggetto Metric.
  • valueType: STRING
  • description: non impostato
• metricKind: il tipo di metrica è impostato su GAUGE, a meno che non specifichi il parametro metricKind dell'oggetto TimeSeries. Quando specifichi metricKind, la nuova metrica ha quel tipo. Puoi specificare solo i tipi GAUGE e CUMULATIVE.
• valueType: il tipo di valore viene preso dal valore digitato di Point in fase di scrittura. Il tipo di valore deve essere BOOL, INT64, DOUBLE o DISTRIBUTION. Quando specifichi un tipo di valore nel campo valueType di TimeSeries, questo tipo deve corrispondere al tipo di Point.
• unit: non impostato
• description: "Auto created custom metric.".
• displayName: non impostato

In una singola chiamata timeSeries.create, puoi includere più oggetti TimeSeries che fanno riferimento allo stesso tipo di metrica inesistente. In questo caso, le etichette nel nuovo descrittore della metrica sono costituite dall'unione di tutte le etichette negli oggetti Metric in tutte le serie temporali in questa chiamata a create.

Passaggio successivo: consulta Scrivi metriche definite dall'utente.

Creazione manuale dei descrittori delle metriche

Per creare un descrittore della metrica, segui questi passaggi:

1. Determina la struttura del descrittore della metrica. Per aiutarti a fare queste scelte, puoi sfogliare le metriche integrate e esaminare i relativi dati delle serie temporali:

   1. Scegli un nome della metrica per la metrica definita dall'utente.

   2. Scegli un nome visualizzato e una descrizione per la metrica. Il nome visualizzato viene utilizzato nella console Google Cloud .

   3. Scegli uno o più progetti in cui definire la metrica definita dall'utente e scrivere i dati delle serie temporali. Quando hai bisogno della stessa metrica in più progetti, crea definizioni identiche della metrica in ogni progetto.

   4. Determina il tipo di metrica, il tipo di valore e (facoltativamente) le unità. Non tutti i tipi di valori e di metriche sono supportati per le metriche definite dall'utente. Per saperne di più su questi campi, consulta Tipi di valori e tipi di metriche.

   5. Scegli le etichette della metrica: i nomi, i tipi di valore e le descrizioni.

2. Determina le risorse monitorate in base alle quali vengono scritti i dati delle metriche. Scegli una delle seguenti opzioni:

   • aws_ec2_instance: istanza Amazon EC2.
   • dataflow_job: job Dataflow.
   • gae_instance: istanza App Engine.
   • gce_instance: istanza di Compute Engine.
   • generic_node: nodo di computing specificato dall'utente.
   • generic_task: attività definita dall'utente.
   • gke_container: l'istanza del container GKE.
   • global: utilizza questa risorsa quando non è adatto nessun altro tipo di risorsa. Per la maggior parte dei casi d'uso, generic_node o generic_task sono scelte migliori rispetto a global.
   • k8s_cluster: cluster Kubernetes.
   • k8s_container: container Kubernetes.
   • k8s_node: nodo Kubernetes.
   • k8s_pod: pod Kubernetes.

3. Crea un oggetto MetricDescriptor, quindi passalo come argomento a una chiamata al metodo metricDescriptors.create.

In genere, si verifica un errore quando si chiama metricDescriptors.create utilizzando lo stesso nome di tipo di un descrittore della metrica esistente. Tuttavia, se tutti i campi del nuovo oggetto MetricDescriptor corrispondono esattamente ai campi del descrittore esistente, non si tratta di un errore, ma non ha alcun effetto.

Nell'esempio seguente, crei una metrica di tipo Gauge.

Protocollo

Per creare un descrittore della metrica, utilizza il metodo metricDescriptors.create. Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Per saperne di più, consulta Explorer API.

Di seguito sono riportati i parametri di esempio per metricDescriptors.create:

• name (URL): projects/[PROJECT_ID]

• Corpo della richiesta: fornisci un oggetto MetricDescriptor come il seguente:

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

Inserisci questi valori nei campi del widget, utilizzando l'ID del progetto al posto di [PROJECT_ID]:

Fai clic sul pulsante Esegui per eseguire il metodo.

Fai una prova

Quando crei una nuova metrica, il campo name in MetricDescriptor viene ignorato e può essere omesso. Il metodo create restituisce il nuovo descrittore della metrica con il campo name compilato, che in questo esempio sarebbe il seguente:

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

Ad esempio, se vuoi recuperare il descrittore di una metrica, utilizza questo nome.

C#

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

In caso di difficoltà, consulta Risolvi i problemi relativi alle chiamate API.

Passaggio successivo: consulta Scrivi metriche definite dall'utente.

Scrivi metriche definite dall'utente

Puoi scrivere dati solo nei tipi di metriche definite dall'utente. Per scrivere i dati, utilizza il metodo timeSeries.create. Se la serie temporale esiste, questo metodo aggiunge un nuovo punto dati alla serie temporale esistente. Se la serie temporale non esiste, questo metodo la crea e aggiunge i dati.

Per scrivere i punti dati, passa un elenco di oggetti TimeSeries a timeSeries.create. La dimensione massima dell'elenco è 200 e ogni oggetto nell'elenco deve specificare una serie temporale diversa:

• I valori dei campi metric e resource identificano un oggetto TimeSeries specifico. Questi campi rappresentano il tipo di metrica dei dati e la risorsa monitorata da cui sono stati raccolti i dati.
• Ometti i campi metricKind e valueType, che vengono ignorati durante la scrittura dei punti dati.

• Ogni oggetto TimeSeries deve contenere un solo oggetto Point:

  • Il valore e l'intervallo di tempo del punto devono essere coerenti con la definizione del tipo di metrica. Per informazioni sugli intervalli di tempo per i diversi tipi di metriche, consulta TimeInterval.
  • L'intervallo di tempo del punto deve essere successivo a qualsiasi punto già presente nella serie temporale.
  • L'ora di fine dell'intervallo non deve essere precedente di oltre 25 ore o successiva di oltre cinque minuti.

• Per scrivere più di un punto nella stessa serie temporale, utilizza una chiamata separata al metodo timeSeries.create per ogni punto. Non scrivere dati in una singola serie temporale più velocemente di un punto ogni 5 secondi. Quando aggiungi punti dati a serie temporali diverse, non esiste una limitazione di frequenza.

Protocollo

Per scrivere i dati delle metriche, utilizza il metodo timeSeries.create. Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Per saperne di più, consulta Explorer API.

Per scrivere un punto nella metrica stores/daily_sales creata in Creazione manuale dei descrittori delle metriche:

1. Vai alla pagina di riferimento per timeSeries.create.
2. Fornisci i parametri riportati di seguito al widget Explorer API.
3. Fai clic sul pulsante Esegui.

Utilizza i seguenti parametri di esempio:

• name: projects/[PROJECT_ID]

• Corpo della richiesta: includi un elenco di oggetti TimeSeries. L'esempio seguente contiene una sola serie temporale nell'elenco.

  Nota: devi modificare i valori project_id e endTime nel corpo della richiesta seguente. Utilizza l'ID del tuo progetto. endTime deve essere vicino all'ora corrente; date -Iseconds restituisce l'ora corrente in un formato utilizzabile.

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

Fai una prova

C#

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

In caso di difficoltà, consulta Risolvi i problemi relativi alle chiamate API.

Elimina le metriche definite dall'utente

Per eliminare una metrica definita dall'utente, elimina il relativo descrittore della metrica. Non puoi eliminare i dati delle serie temporali archiviati nel tuo progetto Google Cloud , ma l'eliminazione del descrittore della metrica rende i dati inaccessibili. I dati scadono e vengono eliminati in base alle policy sulla conservazione dei dati.

Non puoi eliminare il descrittore della metrica per una metrica integrata.

Nota: l'eliminazione di un descrittore della metrica rende inaccessibili i dati delle serie temporali esistenti. Se ricrei un descrittore della metrica eliminato, esattamente come era prima dell'eliminazione, potresti riottenere l'accesso ai dati. Non fare affidamento su questo comportamento.

Per eliminare il descrittore della metrica, chiama il metodo metricDescriptors.delete.

Protocollo

Per eliminare un descrittore della metrica, utilizza il metodo metricDescriptors.delete. Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Per saperne di più, consulta Explorer API.

Per eliminare la metrica stores/daily_sales creata in Creazione manuale dei descrittori delle metriche:

1. Vai alla pagina di riferimento per metricDescriptors.delete.

2. Specifica il nome del descrittore della metrica nel widget Explorer API:

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

3. Fai clic sul pulsante Esegui.

Fai una prova

C#

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione in Monitoring, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

In caso di difficoltà, consulta Risolvi i problemi relativi alle chiamate API.

Modifica una metrica definita dall'utente

Per modificare una metrica definita dall'utente, devi aggiornare l'oggetto MetricDescriptor che la definisce. L'unica modifica supportata è l'aggiunta di etichette.

Per aggiungere etichette a una metrica definita dall'utente esistente, utilizza il metodo timeSeries.create e includi le nuove etichette con i dati delle serie temporali. Le etichette vengono aggiunte al descrittore della metrica quando le etichette che tenti di scrivere sono valide e il numero totale di etichette è inferiore a 30.

I dati delle serie temporali vengono quindi scritti come se l'etichetta fosse presente fin dall'inizio.

Se vuoi fare di più che aggiungere nuove etichette, devi eliminare e ricreare il descrittore della metrica. In questo caso, perdi tutti i dati delle serie temporali raccolti in precedenza per il descrittore della metrica precedente. Per saperne di più, consulta Elimina le metriche definite dall'utente.

Non puoi rinominare una metrica.

Passaggi successivi

• Visualizza e gestisci l'utilizzo delle metriche
• Elenco delle metriche integrate
• Elenco delle risorse monitorate