Crear 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 estos datos de métricas mediante la API Cloud Monitoring. Las métricas definidas por el usuario usan los mismos elementos que las métricas integradas de Cloud Monitoring:

• Un conjunto de puntos de datos.
• Información de tipo métrica, que indica qué representan los puntos de datos.
• Información de recursos monitorizados, que indica de dónde proceden los puntos de datos.

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

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

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

Para instrumentar tu aplicación, te recomendamos que uses un framework de instrumentación de código abierto independiente del proveedor, como OpenTelemetry, en lugar de APIs o bibliotecas de cliente específicas de un proveedor o un producto. Para obtener información sobre cómo instrumentar tu aplicación, consulta Instrumentación y observabilidad.

Nota: Las métricas definidas por el usuario son una función de pago de Cloud Monitoring y pueden generar costes. Para obtener información sobre los precios, consulta las secciones de Cloud Monitoring de la página Precios de Observabilidad de Google Cloud.

Antes de empezar

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

Para usar Cloud Monitoring, debes tener un Google Cloud proyecto 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.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Comprueba que la API Monitoring esté habilitada. Para obtener más información, consulta el artículo sobre cómo habilitar la API Monitoring.
4. En el caso de las aplicaciones que se ejecutan fuera de Google Cloud, tu proyecto Google Cloud debe autenticar tu aplicación mediante credenciales de aplicación predeterminadas (ADC) locales. Para obtener más información, consulta el artículo Configurar ADC para un entorno local u otro proveedor de servicios en la nube.

Crear un tipo de métrica definida por el usuario

Para crear una métrica definida por el usuario, puede definir un objeto MetricDescriptor que especifique diversa información sobre la métrica o escribir datos de métricas. Cuando escribes datos de métricas, Monitoring crea el descriptor de métricas en función de la estructura de los datos que proporciones. Para obtener información sobre cómo diseñar un descriptor de métrica, consulta Descriptores de métricas definidas por el usuario.

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

Si escribe datos de métricas cuando aún no existe un descriptor de métricas para esa métrica definida por el usuario, se creará automáticamente un descriptor de métricas. Sin embargo, es posible que este nuevo descriptor de métrica no sea exactamente lo que quiere, ya que la creación automática de descriptores de métricas implica algunas suposiciones y valores predeterminados.

Cloud Monitoring crea un nuevo MetricDescriptor 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 que no existe. Cloud Monitoring usa las siguientes reglas para rellenar el MetricDescriptor:

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

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

Paso siguiente: Consulta Escribir métricas definidas por el usuario.

Creación manual de descriptores de métricas

Para crear un descriptor de métrica, siga estos pasos:

1. Determina la estructura del descriptor de métricas. Para tomar estas decisiones, puede consultar las métricas integradas y ver sus datos de serie temporal:

   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 la métrica. El nombre visible se usa en la consola. Google Cloud

   3. Elige el proyecto o los proyectos en los que quieras definir la métrica definida por el usuario y escribe sus datos de serie temporal. Si necesitas la misma métrica en varios proyectos, crea definiciones idénticas de la métrica en cada proyecto.

   4. Determina el tipo, el tipo de valor y (opcionalmente) las unidades de la métrica. No se admiten todos los tipos de valor y de métrica para las métricas definidas por el usuario. Para obtener más información sobre estos campos, consulta el artículo sobre los tipos de valores y los tipos de métricas.

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

2. Determina los recursos monitorizados en los que se escriben los datos de métricas. Elige una de las siguientes opciones:

   • aws_ec2_instance: Instancia de Amazon EC2.
   • dataflow_job: Tarea de Dataflow.
   • gae_instance: instancia de App Engine.
   • gce_instance: Instancia de Compute Engine.
   • generic_node: nodo de computación 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 adecuado. En la mayoría de los casos, generic_node o generic_task son mejores opciones que global.
   • k8s_cluster: Clúster de Kubernetes.
   • k8s_container: Contenedor de Kubernetes.
   • k8s_node: Nodo de Kubernetes.
   • k8s_pod: Pod de Kubernetes.

3. Crea un objeto MetricDescriptor y, a continuación, pásalo como argumento a una llamada al método metricDescriptors.create.

Normalmente, es un error llamar a metricDescriptors.create con el mismo nombre de tipo que un descriptor de métrica. Sin embargo, si todos los campos del nuevo objeto MetricDescriptor coinciden exactamente con los campos del descriptor, no se producirá ningún error, pero tampoco tendrá ningún efecto.

En el siguiente ejemplo, se crea una métrica de tipo Gauge.

Protocolo

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

Estos son los parámetros de ejemplo de metricDescriptors.create:

• name (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 en los campos del widget. Usa el ID de tu proyecto en lugar de [PROJECT_ID]:

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

Pruébalo

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

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

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

Por ejemplo, si 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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

Si tienes problemas, consulta el artículo Solucionar problemas con las llamadas a la API.

Paso siguiente: Consulta Escribir métricas definidas por el usuario.

Escribir métricas definidas por el usuario

Solo puede escribir datos en tipos de métricas de métricas definidas por el usuario. Para escribir tus datos, usa el método timeSeries.create. Si la serie temporal ya existe, este método añade un nuevo punto de datos a la serie temporal. Si la serie temporal no existe, este método la crea y añade los datos.

Para escribir puntos de datos, debes enviar una lista de objetos TimeSeries a timeSeries.create. El tamaño máximo de la lista es de 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 monitorizado del que se han recogido los datos.
• Omite los campos metricKind y valueType, ya que se ignoran al escribir puntos de datos.

• Cada objeto TimeSeries debe contener solo un objeto Point:

  • El valor y el intervalo de tiempo del punto deben ser coherentes con la definición del tipo de métrica. Para obtener información sobre los intervalos de tiempo de los distintos tipos de métricas, consulta TimeInterval.
  • El intervalo de tiempo del punto debe ser posterior a cualquier punto que ya esté en la serie temporal.
  • La hora de finalización del intervalo no debe ser de hace más de 25 horas ni de más de cinco minutos.

• Para escribir más de un punto en la misma serie temporal, usa una llamada independiente al método timeSeries.create para cada punto. No escribas datos en una sola serie temporal a una velocidad superior a un punto cada 5 segundos. Cuando añades puntos de datos a diferentes series temporales, no hay limitación de frecuencia.

Protocolo

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

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

1. Ve a la página de referencia de timeSeries.create.
2. Proporciona los parámetros que se indican a continuación al widget Explorador de APIs.
3. Haz clic en el botón Ejecutar.

Usa los siguientes parámetros de ejemplo:

• name: projects/[PROJECT_ID]

• Cuerpo de la solicitud: incluye una lista de objetos TimeSeries. El siguiente ejemplo solo tiene una serie temporal en la lista.

  Nota: Debe cambiar los valores de project_id y endTime en el siguiente cuerpo de la solicitud. Usa el ID de tu proyecto. El endTime debe ser cercano a la hora actual; date -Iseconds devuelve la hora actual en un formato utilizable.

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

Pruébalo

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

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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

Si tienes problemas, consulta el artículo Solucionar problemas con las llamadas a la API.

Eliminar métricas definidas por el usuario

Para eliminar una métrica definida por el usuario, elimina su descriptor de métrica. No puedes eliminar los datos de serie temporal almacenados en tu proyecto Google Cloud . Sin embargo, si eliminas el descriptor de métricas, no se podrá acceder a los datos. Los datos caducan y se eliminan de acuerdo con la política de conservación de datos.

No puedes eliminar el descriptor de métricas de una métrica integrada.

Nota: Si elimina un descriptor de métrica, no podrá acceder a los datos de serie temporal que tenga. Si vuelves a crear un descriptor de métrica eliminado exactamente igual que antes de eliminarlo, es posible que recuperes el acceso a los datos. No dependas de este comportamiento.

Para eliminar el descriptor de métrica, llama al método metricDescriptors.delete.

Protocolo

Para eliminar un descriptor de métrica, utiliza el método metricDescriptors.delete. Puedes ejecutar este método mediante el widget Explorador de APIs de la página de referencia del método. Consulta más información en el explorador de APIs.

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

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

2. Proporciona el nombre del descriptor de métricas al widget Explorador de APIs:

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

3. Haz clic en el botón Ejecutar.

Pruébalo

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

C#

Para autenticarte en Monitoring, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en 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. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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

Si tienes problemas, consulta el artículo Solucionar problemas con las llamadas a la API.

Modificar una métrica definida por el usuario

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

Para añadir etiquetas a una métrica definida por el usuario, utilice el método timeSeries.create e incluya las nuevas etiquetas con los datos de la serie temporal. Las etiquetas se añaden al descriptor de métrica cuando las etiquetas que intentas escribir son válidas y el número total de etiquetas es inferior a 30.

A continuación, los datos de la serie temporal se escriben como si la etiqueta hubiera estado ahí desde el principio.

Si quieres hacer algo más que añadir etiquetas, debes eliminar y volver a crear el descriptor de métrica. En este caso, perderá todos los datos de series temporales que se hayan recogido anteriormente del descriptor de métrica antiguo. Consulta más información en el artículo Eliminar métricas definidas por el usuario.

No puedes cambiar el nombre de una métrica.

Siguientes pasos

• Ver y gestionar el uso de métricas
• Lista de métricas integradas
• Lista de recursos monitorizados