Creare metriche definite dall'utente con l'API

Questo documento descrive come creare metriche definite dall'utente e come scriverle dei dati delle metriche usando l'API Cloud Monitoring. Le metriche definite dall'utente utilizzano gli stessi elementi utilizzati dalla soluzione integrata Cloud Monitoring metriche usano:

• Un insieme di punti dati.
• Informazioni sul tipo di metrica, che indicano cosa rappresentano i punti dati.
• Informazioni sulle risorse monitorate, che indicano dove puntano i dati ha avuto origine.

Le metriche definite dall'utente, a volte denominate metriche personalizzate, possono essere usate allo stesso modo delle metriche integrate. Vale a dire che puoi creare grafici e avvisi per i dati delle metriche.

Le metriche basate su log sono una classe di metriche definite dall'utente, ma e crearle usando l'API Cloud Monitoring. Derivazione delle metriche basate su log i dati delle metriche provenienti dalle voci di log, ma l'API Monitoring non consente di specificare come estrarre i dati delle metriche dalle voci di log. Utilizza invece Cloud Logging per creare metriche basate su log. Quando crei basata su log, Logging crea le strutture descritte in questo documento e invia i dati delle metriche a Cloud Monitoring per te. Per informazioni sulla creazione di metriche basate su log, consulta i seguenti documenti:

• Creare metriche dei contatori
• Creare metriche di distribuzione

Per instrumentare la tua applicazione, ti consigliamo di utilizzare una un framework di strumentazione neutrale dal fornitore e open source, come OpenTelemetry, anziché librerie client o API specifiche del fornitore e del prodotto. Per informazioni sulla strumentazione della tua applicazione, vedi Strumentazione e osservabilità.

Nota: le metriche definite dall'utente sono una funzionalità addebitabile di Cloud Monitoring e potrebbero essere addebitati costi per queste metriche. Per informazioni sui prezzi, vedi Riepilogo dei prezzi di Cloud Monitoring.

Prima di iniziare

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

Per utilizzare Cloud Monitoring, devi avere un progetto Google Cloud con e la fatturazione mensile abilitata. Se necessario:

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

   Go to project selector

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

3. Assicurati che l'API Monitoring sia abilitata. Per maggiori dettagli, vedi Attivazione dell'API Monitoring.

4. Per le applicazioni in esecuzione al di fuori di Google Cloud, Il progetto Google Cloud deve autenticare la tua applicazione. In genere, si configura l'autenticazione creando un per il tuo progetto e configurando un ambiente .

   Per le applicazioni eseguite su un Amazon Elastic Compute Cloud (Amazon EC2), creare l'account di servizio per l'istanza Progetto connettore AWS.

   Per informazioni sulla creazione di un account di servizio, consulta Guida introduttiva all'autenticazione.

Creare un tipo di metrica definita dall'utente

Per creare una metrica definita dall'utente, puoi definire una Oggetto MetricDescriptor che specifica varie informazioni sulla metrica, o scrivi dati di metriche. Quando scrivi dati di metriche, Monitoring crea il descrittore della metrica in base sulla 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 di descrittori delle metriche

Se scrivi dati di metrica quando un descrittore della metrica per quella metrica definita dall'utente non esiste ancora, viene creato automaticamente un descrittore della metrica. Tuttavia, questo nuovo descrittore della metrica potrebbe non corrispondere esattamente a ciò che volevi. la creazione automatica dei descrittori delle metriche comporta alcune ipotesi e valori predefiniti.

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

• type: il tipo viene copiato dall'oggetto Metric campo type.
• name: il nome viene creato a partire dall'ID progetto nella chiamata al metodo e nella valore di type nell'oggetto Metric.
• labels: le etichette visualizzate nell'oggetto Metric. Ciascuna nel nuovo descrittore della metrica ha i seguenti campi:
  • key: chiave di 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. Se specifichi l'attributo metricKind, la nuova metrica ha questo tipo. Puoi specificare solo GAUGE e CUMULATIVE tipi.
• valueType: il tipo di valore viene recuperato dal valore digitato dell'attributo Point in fase di scrittura. Il tipo di valore deve essere BOOL, INT64, DOUBLE o DISTRIBUTION. Quando specifichi un tipo di valore nel campo campo valueType di TimeSeries, deve corrispondere al tipo di Point.
• unit: non impostato
• description: "Auto created custom metric.".
• displayName: non impostato

In una singola chiamata a timeSeries.create puoi: includi più 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 di questa chiamata a create.

Passaggio successivo: consulta Scrivere metriche definite dall'utente.

Creazione manuale dei descrittori delle metriche

Per creare un descrittore della metrica:

1. Determina la struttura del descrittore della metrica. Per assistenza nella realizzazione di questi puoi sfogliare le metriche integrate e esaminare i dati delle serie temporali:

   1. Scegli un nome metrica per 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, rendi uguali le definizioni della metrica in ogni progetto.

      Per scrivere metriche definite dall'utente dalle risorse gestite da un account AWS, crea il descrittore della metrica Progetto connettore AWS per l'account in questione.

   4. Determina il tipo, il tipo di valore e, facoltativamente, le unità di misura della metrica. Non tutti i tipi di valori e metriche sono supportati per metriche definite dall'utente. Per ulteriori informazioni su questi campi, vedi Tipi di valori e metriche.

   5. Scegli le etichette della metrica (nomi, tipi di valori e descrizioni.

2. Determinare le risorse monitorate rispetto alle quali i dati delle metriche vengono scritto. Scegli dall'elenco seguente:

   • aws_ec2_instance: Amazon EC2.
   • dataflow_job: del job Dataflow.
   • gae_instance: dell'istanza di App Engine.
   • gce_instance: di Compute Engine.
   • generic_node: Nodo di computing specificato dall'utente.
   • generic_task: Attività definita dall'utente.
   • gke_container: un'istanza di container GKE.
   • global: Usa questa risorsa quando non sono presenti altri tipi di risorsa adatto. Nella maggior parte dei casi d'uso, generic_node o generic_task sono scelte migliori di global.
   • k8s_cluster: in un cluster Kubernetes.
   • k8s_container: container Kubernetes.
   • k8s_node: nodo Kubernetes.
   • k8s_pod: nel pod Kubernetes.

3. Crea un oggetto MetricDescriptor e poi passalo come un argomento a una chiamata metricDescriptors.create.

Di solito è un errore chiamare metricDescriptors.create utilizza lo stesso tipo come descrittore della metrica esistente. Tuttavia, se tutti i campi il nuovo oggetto MetricDescriptor corrisponda ai campi del descrittore esistente, non si tratta di un errore ma non ha alcun effetto.

Nell'esempio seguente, viene creata una metrica di misurazione.

Protocollo

Per creare un descrittore della metrica, utilizza la metricDescriptors.create. Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Consulta Explorer API per ulteriori informazioni.

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

Fornisci questi valori ai campi del widget, utilizzando l'ID del tuo progetto al posto di [PROJECT_ID]:

Fai clic sul pulsante Esegui per eseguire il metodo.

Prova!

Nota: per visualizzare la richiesta come comando cURL, come richiesta HTTP o in JavaScript, fai clic su Schermo intero in Explorer API.

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

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

Se, ad esempio, vuoi che ottieni un descrittore di una metrica, utilizza questo nome.

C#

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

# 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

Consulta Risolvere i problemi relativi alle chiamate API se hai con maggiore difficoltà.

Passaggio successivo: consulta Scrivere metriche definite dall'utente.

Scrivi metriche definite dall'utente

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

Scrivi punti dati passando 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 una specifica TimeSeries. 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; vengono ignorati durante la scrittura e i punti dati.

• Ogni oggetto TimeSeries deve contenere un solo oggetto Oggetto Point:

  • Il valore del punto e l'intervallo di tempo devono essere coerenti con la metrica la definizione del tipo. Per informazioni sugli intervalli di tempo per tipi di metriche, consulta TimeInterval.
  • L'intervallo di tempo del punto deve essere successivo a qualsiasi punto già presente nel serie temporali.
  • L'ora di fine dell'intervallo non deve essere superiore a 25 ore nel passato. o più di cinque minuti nel futuro.

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

Protocollo

Per scrivere dati delle metriche, utilizza la timeSeries.create . Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Consulta Explorer API per ulteriori informazioni.

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

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

Utilizza i seguenti parametri di esempio:

• nome: projects/[PROJECT_ID]

• request body (corpo della richiesta): includi un elenco di TimeSeries di oggetti strutturati. Nell'esempio seguente è presente una sola serie temporale nell'elenco.

  Nota: devi modificare i valori project_id e endTime nella seguire il corpo della richiesta. Utilizza l'ID del progetto. endTime deve essere vicino all'ora corrente; date -Iseconds restituisce il valore l'ora attuale 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
       }
      }
     ]
    }
   ]
  }
  

Prova!

Nota: per visualizzare la richiesta come comando cURL, come richiesta HTTP o in JavaScript, fai clic su Schermo intero in Explorer API.

C#

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Consulta la sezione Risolvere i problemi relativi alle chiamate API se hai con maggiore difficoltà.

Elimina metriche definite dall'utente

Per eliminare una metrica definita dall'utente, elimina il 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 scade e viene eliminata in base norme sulla conservazione dei dati.

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

Nota: l'eliminazione di un descrittore della metrica rende le sue serie temporali esistenti dati inaccessibili. Se ricrei un descrittore della metrica eliminato, esattamente come prima dell'eliminazione, potresti riottenere l'accesso ai dati. Non dipendere da questo comportamento.

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

Protocollo

Per eliminare un descrittore della metrica, utilizza la metricDescriptors.delete. Puoi eseguire questo metodo utilizzando il widget Explorer API nella pagina di riferimento del metodo. Consulta Explorer API per ulteriori informazioni.

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

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

2. Fornisci il nome del descrittore della metrica al widget Explorer API:

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

3. Fai clic sul pulsante Esegui.

Prova!

Nota: per visualizzare la richiesta come comando cURL, come richiesta HTTP o in JavaScript, fai clic su Schermo intero in Explorer API.

C#

Per autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 autenticarti a Monitoring, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Consulta la sezione Risolvere i problemi relativi alle chiamate API se hai con maggiore difficoltà.

Modificare una metrica definita dall'utente

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

Per aggiungere etichette a una metrica esistente definita dall'utente, utilizza la timeSeries.create e includi il nuovo metodo con i dati delle serie temporali. Le etichette vengono aggiunte alla metrica descrittore quando le etichette che provi a 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 stata partendo dall'inizio.

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

Non puoi rinominare una metrica.

Passaggi successivi

• Visualizzare e gestire l'utilizzo delle metriche
• Elenco di metriche integrate
• Elenco delle risorse monitorate