Crea métricas personalizadas

Las métricas personalizadas son métricas que definen los usuarios. En esta página, se describe cómo crear descriptores de métricas para métricas personalizadas y cómo escribir datos de métricas personalizadas.

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.

Antes de comenzar

  • Para usar Cloud Monitoring, debes tener un proyecto de Cloud con la facturación habilitada.

    Si no tienes un proyecto de Cloud, haz lo siguiente:

    1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
    2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

      Ir al selector de proyectos

    3. Comprueba que la facturación esté habilitada en tu proyecto.

      Descubre cómo puedes habilitar la facturación

    4. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

      Ir al selector de proyectos

    5. Comprueba que la facturación esté habilitada en tu proyecto.

      Descubre cómo puedes habilitar la facturación

    6. Habilita la API de Monitoring. Para obtener más información, consulta Habilita la API de Monitoring.
    7. Si tu aplicación se ejecuta fuera de Google Cloud, tu proyecto de Google Cloud debe autenticar tu aplicación. Por lo general, debes configurar la autenticación mediante la creación de una cuenta de servicio para el proyecto y una variable de entorno.

      Si ejecutas tu aplicación en una instancia de Amazon Elastic Compute Cloud (Amazon EC2), crea la cuenta de servicio para el proyecto del conector de AWS de la instancia.

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

  • Si no estás familiarizado con las estructuras que respaldan todas las métricas, consulta Métricas, series temporales y recursos.

Comienza a usar las métricas personalizadas

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étrica de forma automática o puedes usar el método metricDescriptors.create en la API de Monitoring para crearlo tú mismo. No puedes manipular descriptores de métricas mediante Google Cloud Console para Monitoring.

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 el descriptor de métrica de forma explícita o permitas que Monitoring lo cree por ti en función de tus datos, debes asegurarte de que la organización de los datos coincida con la forma en que deseas consultarlo.

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:

  • Usa dos métricas personalizadas: Metric-type-A cuenta las llamadas al programa A y Metric-type-B cuenta las llamadas 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.

  • Puede usar una sola métrica personalizada y una etiqueta para almacenar un identificador de programa. Por ejemplo, la etiqueta puede almacenar 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 una sola 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.

Cómo asignar nombres a métricas personalizadas

Cuando creas una métrica personalizada, debes definir un identificador de string que represente el tipo de métrica. Esta string debe ser única entre las métricas personalizadas en tu proyecto de Google Cloud y debe usar un prefijo que marque la métrica como una métrica definida por el usuario. En Monitoring, los prefijos permitidos son custom.googleapis.com/ y external.googleapis.com/prometheus. El prefijo va seguido de un nombre que describe lo que está recopilando. Si deseas obtener detalles sobre la forma recomendada para asignar un nombre a una métrica personalizada, consulta Convenciones de nombres. 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

Todos los tipos de métricas tienen identificadores únicos a nivel global llamados nombres de recursos. La estructura de un nombre de recurso para un tipo de métrica es la 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 crearon en el proyecto my-project-id, los nombres de recursos de estas métricas 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.

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 recopilas para una métrica personalizada deben estar asociados con un objeto MetricDescriptor que especifique información diversa sobre la métrica.

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 cuando aún no existe un descriptor de métrica para esa métrica personalizada, entonces, se crea un descriptor de métrica de forma automática. 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.

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

En esta sección, se describe cómo puedes crear el descriptor de métrica para tu métrica personalizada.

Antes de comenzar

Completa los siguientes pasos:

  • Elige un nombre o identificador de métrica para tu métrica personalizada.

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

  • Elige uno o varios proyectos en los que definas tu métrica personalizada y escribas los datos de sus series temporales. Si necesitas la misma métrica en varios proyectos, realiza definiciones idénticas de la métrica en cada proyecto.

    Para escribir las métricas personalizadas de recursos administrados por una cuenta de AWS, crea el descriptor de métrica en el proyecto del conector de AWS para esa cuenta.

  • Determina el tipo y el tipo de valor de la métrica, y las unidades (opcional). No todos los tipos de valores y las clases de métricas son compatibles con las métricas personalizadas. Para obtener más información sobre estos campos, consulta Tipos de valores y categorías 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.

Crea un descriptor de métrica

A fin de crear el descriptor de la métrica personalizada, llama al método metricDescriptors.create y pasa un objeto MetricDescriptor.

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 MetricDescriptor nuevo coinciden de forma exacta con los campos del descriptor existente, no se generará un error, pero no tendrá efecto.

En el siguiente ejemplo, se crea una métrica personalizada de indicador, .

Protocolo

Para crear un descriptor de métricas, usa el método metricDescriptors.create. Puedes ejecutar este método mediante el widget 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
	}
	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: %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';
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

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

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

# 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 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 se puede borrar el descriptor de métrica de una métrica integrada.

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 widget del Explorador de API en la página de referencia del método. Consulta Explorador de API para obtener más información.

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 del Explorador de API:

    name: 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
	}
	defer c.Close()
	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();

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

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

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

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

Lee datos de métricas

Solo puedes escribir datos en tipos de métricas para 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. A fin de obtener información sobre los intervalos de tiempo para diferentes tipos 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 más rápido que un punto cada 5 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 widget 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:

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

    {
     "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
	}
	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, %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();

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

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

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

# 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étrica

Para agregar etiquetas a una métrica personalizada existente, usa el método timeSeries.create e incluye las nuevas etiquetas con los datos de series temporales. Si las etiquetas que intentas escribir son válidas y no hacen que el número de etiquetas en el descriptor de métrica supere el límite de 30 etiquetas, se agregan las etiquetas. 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 nuevas etiquetas, debes quitar 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.

¿Qué sigue?