Crea métricas personalizadas

Las métricas personalizadas son métricas que definen los usuarios. Las métricas personalizadas 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 personalizadas se pueden usar de la misma manera que las métricas integradas. Es decir, puedes crear gráficos y alertas para los datos de tus métricas personalizadas.

Para obtener una introducción a las estructuras subyacentes de las métricas integradas y personalizadas, consulta Métricas, series temporales y recursos. Para explorar las métricas integradas, consulta la Lista de métricas. Para explorar los recursos supervisados disponibles, consulta la Lista de recursos.

Usa una métrica personalizada

Si deseas usar una métrica personalizada, debes tener un descriptor de métrica para tu nuevo tipo de métrica. El descriptor de métricas define cómo se organizan tus datos. Antes de comenzar a escribir datos de métricas personalizadas, determina cómo deseas usar los datos que recopilas y asegúrate de que la organización de los datos admita esos objetivos.

Crea un descriptor de métrica

Cloud Monitoring puede crear el descriptor de métricas de forma automática, o puedes usar el método de la API metricDescriptors.create para crearlo tú.

Para que Cloud Monitoring cree el descriptor de métricas, solo tienes que escribir datos de series temporales para tu métrica y Cloud Monitoring crea un descriptor basado en los datos que escribes. Para obtener más información, consulta Creación automática de descriptores de métricas. La creación automática tiene límites, por lo que es útil saber qué información se incluye en una definición de métrica. Una vez que tengas un nuevo descriptor de métricas personalizadas, creado por ti o por Monitoring, puedes usarlo con los métodos de la API de los descriptores de métricas y los métodos de las API de las series temporales.

Ya sea que crees de forma explícita el descriptor de métricas o permitas que Monitoring lo cree en función de tus datos, debes asegurarte de que la organización de los datos coincida con cómo deseas consultarlos.

Organiza tus datos

Supongamos que tienes un programa que se ejecuta en una sola máquina y este llama a los programas auxiliares A y B. Deseas contar la frecuencia con la que se llama a los programas A y B. También quieres saber cuándo se llama al programa A más de 10 veces por minuto y cuándo se llama al programa B más de 5 veces por minuto.

Para simplificar el debate, supongamos que tienes un solo proyecto de Google Cloud y planeas usar el recurso supervisado global. Para obtener más información sobre esta opción, consulta Recursos supervisados para las métricas personalizadas.

Considera los siguientes enfoques:

  • Debes usar dos tipos de métricas personalizadas: Metric-type-A cuenta las llamadas al programa A y Metric-type-B al programa B. En este caso, Metric-type-A contiene 1 serie temporal y Metric-type-B contiene 1 serie temporal.

    Mediante este modelo de datos, puedes crear una sola política de alertas con dos condiciones o puedes crear dos políticas de alertas con una condición. Una política de alertas puede admitir varias condiciones, pero tiene una sola configuración para los canales de notificaciones.

    Este modelo podría ser adecuado cuando no te interesan las similitudes de los datos entre las actividades que se supervisan. En este ejemplo, las actividades son la tasa de llamadas a los programas A y B.

  • Usa un único tipo de métrica personalizada y una etiqueta que almacene el valor A o B. Dado que Monitoring crea una serie temporal para cada combinación única de etiquetas, hay dos series temporales para este único tipo de métrica.

    Al igual que con el modelo anterior, puedes crear una sola política de alertas o dos políticas de alertas. Sin embargo, las condiciones de la política de alertas son más complicadas. Para crear una condición que genere un incidente si la tasa de llamadas al programa A excede un límite, la condición debe incluir un filtro que incluya datos cuyo valor de etiqueta sea A y excluya todos los demás datos.

    Una de las ventajas de este modelo es que es sencillo para calcular proporciones. Por ejemplo, puedes determinar qué cantidad del total se debe a las llamadas a A.

  • Usa un solo tipo de métrica personalizada para contar la cantidad de llamadas, pero no uses una etiqueta a fin de registrar a qué programa se llamó. En este modelo, hay una sola serie temporal que combina los datos de los dos programas. Sin embargo, no puedes crear una política de alertas que cumpla con tus objetivos, ya que los datos de dos programas no se pueden separar.

Nombres de métricas personalizadas

Cuando crees una métrica personalizada, debes crear un identificador de string que represente el tipo de métrica. Esta string debe ser única entre las métricas personalizadas de tu proyecto de Google Cloud. La string debe comenzar con un prefijo que la marque como una métrica definida por el usuario. En Monitoring, los únicos prefijos compatibles son custom.googleapis.com/ y external.googleapis.com/. El uso de prefijos arbitrarios no es compatible. Al prefijo le sigue un nombre que describe lo que recopilas. Consulta Convenciones de nombres para obtener más detalles. A continuación, se muestran ejemplos de los dos tipos de identificadores para los tipos de métricas:

custom.googleapis.com/cpu_utilization
custom.googleapis.com/instance/cpu/utilization

Los tipos de métricas personalizadas tienen nombres de recursos que son únicos en todos los recursos de Google Cloud de todos los proyectos. El formato de un nombre de recurso para un tipo de métrica es el siguiente:

projects/[PROJECT_ID]/metricDescriptors/[METRIC_TYPE]

En el ejemplo anterior, METRIC_TYPE es el identificador de string del tipo de métrica. Si los ejemplos de métricas personalizadas anteriores se crearan en el proyecto my-project-id, los nombres de recursos serían los siguientes:

projects/my-project-id/metricDescriptors/custom.googleapis.com/cpu_utilization
projects/my-project-id/metricDescriptors/custom.googleapis.com/instance/cpu/utilization

¿Nombre o tipo? En el descriptor de métrica, el campo name almacena el nombre del recurso del tipo de métrica y el campo type almacena la string METRIC_TYPE.

Define tu descriptor de métrica personalizado

Para recopilar datos de métricas personalizadas, debes proporcionar un objeto MetricDescriptor que especifique información diversa sobre la métrica. Cloud Monitoring puede crear el descriptor de forma automática. Consulta Creación automática de descriptores de métricas para obtener más información.

Si deseas crear el descriptor de métrica de forma explícita, necesitarás la siguiente información:

  • Elige un identificador para el tipo de métrica personalizada, como se describió en la sección anterior.

  • Elige un proyecto para definir tu métrica personalizada y escribe sus datos de series temporales.

    El proyecto que elijas también debe ser miembro del lugar de trabajo donde se supervisa la métrica. Si necesitas la misma métrica en varios proyectos, realiza definiciones idénticas de la métrica en cada proyecto.

    Las métricas personalizadas de AWS deben crearse en el proyecto de conector de AWS para tu cuenta de AWS.

  • Elige un nombre visible y una descripción de la métrica. El nombre comercial se usa en Google Cloud Console.

  • Elige la clase, 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 personalizadas. Consulta Tipos de valores y clases de métricas.

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

Si necesitas más ayuda para tomar estas decisiones, puedes examinar las métricas integradas y ver sus datos de series temporales.

En Crea descriptores de métricas de forma manual, se incluyen muestras de código para crear un descriptor de métrica de manualmente.

Elige un tipo de recurso supervisado

Cuando escribes tus datos en una serie temporal, debes indicar de dónde provienen. Para hacerlo, debes elegir un tipo de recurso supervisado que represente la procedencia de tus datos y, luego, usarlo para describir el origen específico. El recurso supervisado no forma parte del tipo de métrica; en su lugar, la serie temporal en la que le escribes datos incluye una referencia al tipo de métrica, que describe los datos, y una referencia al recurso supervisado, que indica dónde se originaron los datos.

Ten en cuenta el recurso supervisado antes de crear tu descriptor de métrica. El tipo de recurso supervisado que uses afecta las etiquetas que debes incluir en el descriptor de métrica. Por ejemplo, si usas un recurso supervisado de instancia de VM con tus datos, no necesitarás una etiqueta de métrica para especificar la instancia. Para obtener más información, consulta Recursos supervisados para las métricas personalizadas.

Cada uno de los datos de tu métrica debe estar asociado con un objeto de recurso supervisado. Los datos de diferentes objetos de recursos supervisados se mantienen en distintas series temporales.

Recursos supervisados para métricas personalizadas

Solo puedes usar los siguientes tipos de recursos supervisados en tus métricas personalizadas.

Se suelen usar los objetos de recursos supervisados que representan los recursos físicos donde se ejecuta el código de tu aplicación. Este enfoque tiene varias ventajas:

  • Obtienes un mejor rendimiento en comparación con el uso de un solo tipo de recurso.
  • Evitas los datos fuera de orden causados por múltiples procesos que escriben en la misma serie temporal.
  • Los datos de métricas personalizadas se pueden agrupar con otros datos de métricas de los mismos recursos.

Comparación entre recursos genéricos y global

Los tipos de recursos generic_task y generic_node son útiles en situaciones en las que ninguno de los tipos de recursos más específicos es apropiado. El tipo generic_task es útil para definir recursos similares a las tareas, como las aplicaciones. El tipo generic_node es útil para definir recursos similares a los nodos, como máquinas virtuales. Ambos tipos generic_* tienen varias etiquetas comunes que puedes usar a fin de definir objetos de recursos únicos, lo que facilita su uso en filtros de métricas para agregaciones y reducciones.

Por el contrario, el tipo de recurso global solo tiene etiquetas project_id y location. Si tienes muchas fuentes de métricas dentro de un proyecto, usar el mismo objeto de recurso global puede provocar colisiones y reemplazos de los datos de métricas.

Crea descriptores de métricas

Los datos que recopiles para una métrica personalizada deben estar asociados con un descriptor de un tipo de métrica personalizada. Puedes crear el descriptor de métricas de forma manual o Monitoring lo puede hacer por ti.

Hay formas limitadas de cambiar un descriptor existente. Para obtener más información, consulta Modifica los descriptores de métricas.

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

Si escribes datos de métricas en un tipo de métrica personalizada que aún no existe, se crea automáticamente un nuevo descriptor de métrica personalizada. 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 opciones de configuración predeterminadas.

De forma específica, durante una llamada a timeSeries.create, si un objeto TimeSeries incluye un objeto Metric que especifica un nombre de tipo de métrica inexistente, Cloud Monitoring crea un MetricDescriptor nuevo con los siguientes campos:

  • 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: Las etiquetas son aquellas 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: La clase de métrica predeterminada es GAUGE, pero si especificas el parámetro metricKind del objeto TimeSeries, la métrica nueva será de esa clase. Solo puedes especificar las clases GAUGE y CUMULATIVE.
  • valueType: El tipo de valor se toma del valor escrito del Point que se está escribiendo, que debe ser BOOL, INT64, DOUBLE o DISTRIBUTION. Si especificas un tipo de valor en el campo valueType de TimeSeries, ese 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 personalizada. En ese caso, los campos del tipo nuevo se configuran de la misma manera, excepto que las etiquetas del descriptor de métricas nuevo están formadas por la unión de todas las etiquetas de los objetos Metric de todas las series temporales de esta llamada a create.

Próximo paso: Consulta Escribe datos de métricas.

Crea descriptores de métricas de forma manual

Una vez que hayas recopilado la información que necesitas para crear el tipo de métrica personalizada, llama al método metricDescriptors.create y pasa un objeto MetricDescriptor. Consulta Modifica descriptores de métricas para obtener más información.

Por lo general, es un error llamar a metricDescriptors.create con el mismo nombre de tipo que un descriptor de métricas personalizadas 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, se crea una métrica personalizada de indicador, custom.googleapis.com/stores/daily_sales. La métrica tiene una sola etiqueta de dimensión, store_id.

Protocolo

Para crear un descriptor de métricas, usa el método metricDescriptors.create. Puedes ejecutar este método mediante el uso del Explorador de API en la página de referencia del método. Consulta Explorador de API 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": "CUMULATIVE",
  "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]:

Usa este cuadro de diálogo de la API propagado con el cuerpo de la solicitud para crear un descriptor de métricas.

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

Probar

Cuando crees una métrica personalizada nueva, el campo name de 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#

        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


import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	"google.golang.org/genproto/googleapis/api/label"
	"google.golang.org/genproto/googleapis/api/metric"
	metricpb "google.golang.org/genproto/googleapis/api/metric"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// 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
	}
	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: %v", err)
	}

	fmt.Fprintf(w, "Created %s\n", m.GetName())
	return m, nil
}

Java

// Your Google Cloud Platform project ID
String projectId = System.getProperty("projectId");
String metricType = CUSTOM_METRIC_DOMAIN + "/" + type;

final MetricServiceClient client = MetricServiceClient.create();
ProjectName name = ProjectName.of(projectId);

MetricDescriptor descriptor =
    MetricDescriptor.newBuilder()
        .setType(metricType)
        .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(name.toString())
        .setMetricDescriptor(descriptor)
        .build();

client.createMetricDescriptor(request);

Node.js

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

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}`);
});

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Api\LabelDescriptor;
use Google\Api\LabelDescriptor_ValueType;
use Google\Api\MetricDescriptor;
use Google\Api\MetricDescriptor_MetricKind;
use Google\Api\MetricDescriptor_ValueType;

/**
 * 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 = $metrics->projectName($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);

    $descriptor = $metrics->createMetricDescriptor($projectName, $descriptor);
    printf('Created a metric: ' . $descriptor->getName() . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)
descriptor = monitoring_v3.types.MetricDescriptor()
descriptor.type = 'custom.googleapis.com/my_metric' + str(uuid.uuid4())
descriptor.metric_kind = (
    monitoring_v3.enums.MetricDescriptor.MetricKind.GAUGE)
descriptor.value_type = (
    monitoring_v3.enums.MetricDescriptor.ValueType.DOUBLE)
descriptor.description = 'This is a simple example of a custom metric.'
descriptor = client.create_metric_descriptor(project_name, descriptor)
print('Created {}.'.format(descriptor.name))

Ruby

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

Próximo paso: Consulta Escribe datos de métricas.

Borra métricas

Para borrar una métrica personalizada, borra su descriptor de métrica. No puedes borrar los datos de la serie temporal de tu métrica personalizada, pero borrar el descriptor de métricas hace que los datos sean inaccesibles. Los datos caducan y se borran de acuerdo con la política de retención de datos.

Para borrar tu descriptor de métricas personalizadas, llama al método metricDescriptors.delete.

Protocolo

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

Solo puedes borrar tipos de métricas personalizadas.

Para borrar la métrica personalizada stores/daily_sales creada en Crea descriptores de métricas de forma manual, 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 Explorador de API:

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

  3. Haz clic en el botón Ejecutar.

Probar

C#

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


import (
	"context"
	"fmt"
	"io"

	monitoring "cloud.google.com/go/monitoring/apiv3"
	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
)

// 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
	}
	req := &monitoringpb.DeleteMetricDescriptorRequest{
		Name: name,
	}

	if err := c.DeleteMetricDescriptor(ctx, req); err != nil {
		return fmt.Errorf("could not delete metric: %v", err)
	}
	fmt.Fprintf(w, "Deleted metric: %q\n", name)
	return nil
}

Java

String projectId = System.getProperty("projectId");
final MetricServiceClient client = MetricServiceClient.create();
MetricDescriptorName metricName = MetricDescriptorName.of(projectId, name);
client.deleteMetricDescriptor(metricName);
System.out.println("Deleted descriptor " + name);

Node.js

// 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';
// 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);

PHP

use Google\Cloud\Monitoring\V3\MetricServiceClient;

/**
 * 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);
    $ret = $metrics->deleteMetricDescriptor($metricPath);

    printf('Deleted a metric: ' . $metricPath . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
client.delete_metric_descriptor(descriptor_name)
print('Deleted metric descriptor {}.'.format(descriptor_name))

Ruby

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

Escribe datos de métricas

Solo puedes escribir datos en tipos de métricas personalizadas. Para escribir tus datos, usa el método timeSeries.create. Si la serie temporal ya existe, este método agrega un dato nuevo a la serie temporal existente. Si 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:

  • Cada serie temporal se identifica mediante los campos metric y resource del objeto TimeSeries. 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 clases de métricas, 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.

  • Si deseas 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 sola serie temporal a una velocidad mayor a un punto cada 10 segundos. Si estás agregando datos a diferentes series temporales, entonces no hay límite de frecuencia.

Protocolo

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

Para escribir un dato en la métrica personalizada stores/daily_sales creada en Crea descriptores de métricas de forma manual, 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:

  • Nombre: projects/[PROJECT_ID]

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

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

C#

        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


// 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
	}
	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, %v ", err)
	}
	return nil
}

Java

String projectId = System.getProperty("projectId");
// Instantiates a client
MetricServiceClient metricServiceClient = MetricServiceClient.create();

// 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
metricServiceClient.createTimeSeries(request);
System.out.println("Done writing time series value.");

Node.js

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

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

PHP

use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\MetricServiceClient;
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 = $metrics->projectName($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);

    $result = $metrics->createTimeSeries(
        $projectName,
        [$timeSeries]);

    printf('Done writing time series data.' . PHP_EOL);
}

Python

client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)

series = monitoring_v3.types.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-f'
point = series.points.add()
point.value.double_value = 3.14
now = time.time()
point.interval.end_time.seconds = int(now)
point.interval.end_time.nanos = int(
    (now - point.interval.end_time.seconds) * 10**9)
client.create_time_series(project_name, [series])

Ruby

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

Modifica descriptores de métricas

También puedes usar la llamada timeSeries.create para agregar etiquetas nuevas a las métricas personalizadas. Para agregar etiquetas a tu descriptor de métrica personalizada, puedes incluirlas con los datos de series temporales.

Si la etiqueta que intentas escribir es válida y no hace que el número de etiquetas en el descriptor de métrica exceda el límite de 10 etiquetas, la etiqueta se agrega. 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, debes 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 para obtener más información.

No puedes cambiar el nombre de una métrica.