Crea métricas definidas por el usuario con la API

En este documento, se describe cómo crear métricas definidas por el usuario y cómo escribir esta datos de métricas con la API de Cloud Monitoring. Las métricas definidas por el usuario usan los mismos elementos que usan las métricas integradas de Cloud Monitoring:

• Un conjunto de datos
• Información sobre tipos de métricas, que te indica qué representan los datos
• Información sobre recursos supervisados, que te indica dónde se originaron los datos

Las métricas definidas por el usuario, a veces llamadas métricas personalizadas, se pueden usar de la misma manera que las métricas integradas. Es decir, puedes crear gráficos y alertas para estos datos de métricas.

Las métricas basadas en registros son una clase de métricas definidas por el usuario, pero no puedes y crearlos con la API de Cloud Monitoring. Las métricas basadas en registros derivan datos métricos de las entradas de registro, pero la API de Monitoring no proporciona ninguna forma de especificar cómo extraer datos métricos de las entradas de registro. En su lugar, usa Cloud Logging para crear métricas basadas en registros. Cuando creas una campaña una métrica basada en registros, Logging crea las estructuras descritas en este documento y envía los datos de las métricas a Cloud Monitoring por ti. Para obtener información sobre cómo crear métricas basadas en registros, consulta los siguientes documentos:

• Crea métricas de contador
• Crea métricas de distribución

Para instrumentar tu aplicación, te recomendamos que uses un framework de instrumentación con proveedor neutro y que sea de código abierto, como OpenTelemetry, en lugar de las API específicas de proveedor y producto. o bibliotecas cliente. Para obtener más información sobre la instrumentación de tu aplicación, consulta Instrumentación y observabilidad.

Nota: Las métricas definidas por el usuario son una función con cargo de Cloud Monitoring y podrían tener costos. Para obtener información sobre los precios, consulta el Resumen de precios de Cloud Monitoring.

Antes de comenzar

Para obtener información sobre las estructuras subyacentes de todas las métricas, consulta Métricas, series temporales y recursos.

Para usar Cloud Monitoring, debes tener un proyecto de Google Cloud con la facturación habilitada. Cuando sea necesario, haz lo siguiente:

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

   Go to project selector

2. Make sure that billing is enabled for your Google Cloud project.

3. Asegúrate de que la API de Monitoring esté habilitada. Para obtener más información, consulta Habilita la API de Monitoring.

4. Para las aplicaciones que se ejecutan fuera de Google Cloud, tu proyecto de Google Cloud debe autenticar tu aplicación. Por lo general, la autenticación se configura con la creación cuenta de servicio para tu proyecto y configurando un entorno de salida.

   Para obtener información sobre cómo crear una cuenta de servicio, consulta Cómo comenzar a usar la autenticación

Crear un tipo de métrica definido por el usuario

Para crear una métrica definida por el usuario, puede definir Objeto MetricDescriptor que especifica información diversa sobre la métrica, o escribir datos de métricas. Cuando escribes datos de métricas, Monitoring crea el descriptor de métricas según la estructura de los datos que proporcionas. Para obtener más información sobre el diseño de un descriptor de métrica, consulta Descriptores de métricas para métricas definidas por el usuario.

Creación automática de descriptores de métricas

Si escribes datos de métricas cuando un descriptor de métrica para esa métrica definida por el usuario aún no existe, se crea automáticamente un descriptor de métrica. Sin embargo, este nuevo descriptor de métrica podría no ser exactamente lo que quieres. La creación automática de descriptores de métricas implica algunas suposiciones y predeterminaciones.

Cloud Monitoring crea un MetricDescriptor nuevo cuando el objeto TimeSeries incluido en una llamada a timeSeries.create hace referencia a un objeto Metric que especifica un nombre de tipo de métrica inexistente. Cloud Monitoring usa las siguientes reglas para propagar MetricDescriptor:

• type: El tipo se copia desde el campo type del objeto Metric.
• name: El nombre se crea a partir del ID del proyecto en la llamada de método y el valor de type en el objeto Metric
• labels: Son las etiquetas que aparecen en el objeto Metric. Cada descriptor de etiqueta en el nuevo descriptor de métrica posee los siguientes campos:
  • key: Es la clave de etiqueta en el objeto Metric.
  • valueType: STRING.
  • description: No se establece.
• metricKind: El tipo de métrica se establece en GAUGE, a menos que lo especifiques el parámetro metricKind del objeto TimeSeries Cuando especificas el metricKind, la métrica nueva tiene ese tipo. Solo puedes especificar Clases GAUGE y CUMULATIVE.
• valueType: El tipo de valor se toma del valor escrito de la Se está escribiendo Point. El tipo de valor debe ser BOOL INT64, DOUBLE o DISTRIBUTION. Cuando especificas un tipo de valor en el valueType del TimeSeries. el tipo debe coincidir con el tipo de Point.
• unit: No se establece.
• description: "Auto created custom metric.".
• displayName: No se establece.

En una sola llamada a timeSeries.create, puedes incluir varios objetos TimeSeries que hagan referencia al mismo tipo de métrica. En ese caso, las etiquetas del nuevo descriptor de métricas consisten en la unión de todas las etiquetas de los objetos Metric de todas las series temporales de esta llamada a create.

Siguiente paso: Consulta Escribe métricas definidas por el usuario.

Creación manual de descriptores de métricas

Para crear un descriptor de métrica, haz lo siguiente:

1. Determina la estructura de tu descriptor de métrica. Para hacer estas opciones, puedes navegar por las métricas integradas y ver sus datos de series temporales:

   1. Elige un nombre de métrica para tu métrica definida por el usuario.

   2. Elige un nombre visible y una descripción para tu métrica. El nombre visible se usa en la consola de Google Cloud.

   3. Elige uno o varios proyectos en los que definirás tu métrica definida por el usuario y escribe sus datos de series temporales. Cuando necesites la misma métrica en varios proyectos, realiza definiciones idénticas de la métrica en cada uno de esos proyectos.

   4. Determina el tipo, el tipo de valor y, de manera opcional, las unidades de la métrica. No todos los tipos de valores y las clases de métricas son compatibles con las métricas definidas por el usuario. Para obtener más información sobre estos campos, consulta Tipos de valores y clases de métricas.

   5. Elige las etiquetas de la métrica: sus nombres, tipos de valor y descripciones.

2. Determinar los recursos supervisados con los que se comparan los datos de métricas escrita. Elige una opción de la siguiente lista:

   • aws_ec2_instance: Instancia de Amazon EC2.
   • dataflow_job: Trabajo de Dataflow.
   • gae_instance: instancia de App Engine.
   • gce_instance: instancia de Compute Engine.
   • generic_node: Nodo de procesamiento especificado por el usuario.
   • generic_task: Tarea definida por el usuario.
   • gke_container: instancia de contenedor de GKE.
   • global: Usa este recurso cuando no haya otro tipo de recurso y que sean adecuados. En la mayoría de los casos de uso, se usan generic_node o generic_task mejores opciones que global.
   • k8s_cluster: Clúster de Kubernetes
   • k8s_container: Contenedor de Kubernetes
   • k8s_node: tu nodo de Kubernetes.
   • k8s_pod: Pod de Kubernetes.

3. Crea un objeto MetricDescriptor y, luego, pásalo como un argumento a una llamada a metricDescriptors.create.

Por lo general, es un error llamar metricDescriptors.create con el mismo tipo como descriptor de métrica existente. Sin embargo, si todos los campos del objeto nuevo MetricDescriptor coinciden de manera exacta con los campos del descriptor existente, no se trata de un error y no tiene efecto alguno.

En el siguiente ejemplo, crearás una métrica de indicador.

Protocolo

Para crear un descriptor de métricas, usa el método metricDescriptors.create. Puedes ejecutar este método usando el widget del Explorador de APIs en la página de referencia del método. Consulta Explorador de APIs para obtener más información.

Los siguientes son los parámetros de muestra de metricDescriptors.create:

• Nombre (URL): projects/[PROJECT_ID]

• Cuerpo de la solicitud: Proporciona un objeto MetricDescriptor como el siguiente:

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

Proporciona estos valores para los campos del widget mediante el uso del ID del proyecto en lugar de [PROJECT_ID]:

Haz clic en el botón Ejecutar (Execute) para ejecutar el método.

Probar

Nota: Para ver la solicitud como un comando curl, como una solicitud HTTP o en JavaScript, haz clic en Pantalla completa en el Explorador de APIs.

Cuando creas una métrica nueva, el campo name del MetricDescriptor se ignora y se puede omitir. El método create muestra el nuevo descriptor de métrica con el campo name completo, que en este ejemplo sería el siguiente:

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

Si, por ejemplo, quieres obtener el descriptor de una métrica, debes usar este nombre.

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

        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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

# 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 Cómo solucionar problemas de llamadas a la API si tienes lo siguiente: dificultad.

Siguiente paso: Consulta Escribe métricas definidas por el usuario.

Escribe métricas definidas por el usuario

Solo puedes escribir datos en tipos de métricas para las métricas definidas por el usuario. Para escribir tus datos, usa el método timeSeries.create. Cuando la serie temporal existe, este método agrega un dato nuevo a la serie temporal existente. Cuando la serie temporal no existe, este método la crea y agrega los datos.

Para escribir datos, pasa una lista de objetos TimeSeries a timeSeries.create. El tamaño máximo de la lista es 200, y cada objeto de la lista debe especificar una serie temporal diferente:

• Los valores de los campos metric y resource identifican un objeto TimeSeries específico. Estos campos representan el tipo de métrica de los datos y el recurso supervisado desde el que se recopilaron los datos.
• Omite los campos metricKind y valueType. Se ignoran cuando se escriben datos.

• Cada objeto TimeSeries debe contener solo un único objeto Point:

  • El valor y el intervalo temporal del dato deben ser coherentes con la definición del tipo de métrica. Para obtener información sobre los intervalos de tiempo para diferentes similares, consulta TimeInterval.
  • El intervalo temporal del dato debe ser posterior a cualquier dato que ya pertenezca a la serie temporal.
  • La hora de finalización del intervalo no debe superar las 25 horas en el pasado o 5 minutos en el futuro.

• Para escribir más de un punto en la misma serie temporal, usa una llamada al método timeSeries.create separada para cada punto. No escribas datos en una única serie temporal más rápido que un punto cada 5 segundos. Cuando agregas datos a diferentes series temporales, no hay límite de frecuencia.

Protocolo

Para escribir datos de métricas, usa el método timeSeries.create. Puedes ejecutar este método usando el widget del Explorador de APIs en la página de referencia del método. Consulta Explorador de APIs para obtener más información.

Para escribir un dato en la métrica stores/daily_sales creada en Creación manual de descriptores de métricas, haz lo siguiente:

1. Ve a la página de referencia de timeSeries.create:
2. Proporciona los parámetros a continuación para el widget Explorador de API.
3. Haz clic en el botón Ejecutar.

Usa los siguientes parámetros de muestra:

• name: projects/[PROJECT_ID]

• cuerpo de la solicitud: incluye una lista de objetos TimeSeries. La siguiente muestra solo tiene una serie temporal en la lista.

  Nota: Debes cambiar los valores project_id y endTime en el siguiente cuerpo de solicitud. Usa el ID de tu proyecto. El valor de endTime debe ser próximo a la hora actual. date -Iseconds muestra la hora actual en un formato usable.

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

Probar

Nota: Para ver la solicitud como un comando curl, como una solicitud HTTP o en JavaScript, haz clic en Pantalla completa en el Explorador de APIs.

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

        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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

# 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 Soluciona problemas de llamadas a la API si tienes dificultades.

Borra las métricas definidas por el usuario

Para borrar una métrica definida por el usuario, borra su descriptor de métrica. No puedes borrar los datos de series temporales almacenados en tu proyecto de Google Cloud. Sin embargo, borrar el descriptor de métrica hace que los datos sean inaccesibles. Los datos caducan y se borran de acuerdo con la política de retención de datos.

No puedes borrar el descriptor de métrica de una métrica integrada.

Nota: Si borras un descriptor de métricas, ya no se podrá acceder a sus datos de series temporales existentes. Si vuelves a crear un descriptor de métrica borrado, tal como estaba antes de la eliminación, entonces es posible que recuperes el acceso a los datos. No dependas de este comportamiento.

Para borrar tu descriptor de métrica, llama al metricDescriptors.delete.

Protocolo

Para borrar un descriptor de métricas, usa el método metricDescriptors.delete. Puedes ejecutar este método usando el widget del Explorador de APIs en la página de referencia del método. Consulta el Explorador de APIs para obtener más información.

Para borrar la métrica stores/daily_sales creada en Creación manual de descriptores de métricas, sigue estos pasos:

1. Ve a la página de referencia de metricDescriptors.delete:

2. Proporciona el nombre del descriptor de métrica al widget del Explorador de API:

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

3. Haz clic en el botón Ejecutar.

Probar

Nota: Para ver la solicitud como un comando curl, como una solicitud HTTP, o JavaScript, haz clic en Pantalla completa en el Explorador de APIs.

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

# 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 Soluciona problemas de llamadas a la API si tienes dificultades.

Modifica una métrica definida por el usuario

Para modificar una métrica definida por el usuario, debes actualizar el MetricDescriptor que define la métrica. La única modificación admitida es agregar etiquetas.

Para agregar etiquetas a una métrica definida por el usuario existente, usa el método timeSeries.create y, luego, incluye las etiquetas nuevas con los datos de las series temporales. Las etiquetas se agregan al descriptor de métrica cuando las etiquetas que intentas escribir son válidas y la cantidad total de etiquetas es inferior a 30.

Los datos de la serie temporal se escriben como si la etiqueta hubiera estado allí desde el principio.

Si quieres hacer algo más que agregar etiquetas nuevas, deberás borrar y volver a crear el descriptor de métrica. En este caso, perderás todos los datos de series temporales recopilados previamente para el descriptor de métrica anterior. Consulta Borra métricas definidas por el usuario para obtener más información.

No puedes cambiar el nombre de una métrica.

¿Qué sigue?

• Visualiza y administra el uso de métricas
• Lista de métricas integradas
• Lista de recursos supervisados