Criar métricas definidas pelo usuário com a API

A criação de métricas definidas pelo usuário (também chamadas de métricas personalizadas) com a API Cloud Monitoring permite capturar medições específicas do aplicativo e criar gráficos ou alertas sobre elas, assim como as métricas integradas do Cloud Monitoring. Como as métricas integradas, cada métrica definida pelo usuário combina pontos de dados, um tipo de métrica que define o que os pontos representam e um recurso monitorado que identifica a origem dos dados.

Para instrumentar seu aplicativo, recomendamos o uso de um framework de instrumentação de código aberto e neutro em relação a fornecedores, como o OpenTelemetry, em vez de APIs ou bibliotecas de cliente específicas de fornecedores e produtos. Para mais informações sobre esses frameworks, consulte Observabilidade para desenvolvedores de aplicativos e Escolher uma abordagem de instrumentação.

Não é possível usar a API Monitoring para criar métricas com base em registros, que derivam dados de métricas de entradas de registro. Em vez disso, o Cloud Logging cria as estruturas de métricas e envia os dados para o Cloud Monitoring. Consulte Criar métricas de contador e Criar métricas de distribuição. As métricas definidas pelo usuário são um recurso cobrável do Cloud Monitoring. Para detalhes sobre preços, consulte as seções do Cloud Monitoring na página de preços do Google Cloud Observability.

Antes de começar

Para saber mais sobre as estruturas que estão por trás de todas as métricas, consulte Métricas, série temporal e recursos.

Para usar o Cloud Monitoring, é preciso ter um projeto do Google Cloud com o faturamento ativado. Quando necessário, faça o seguinte:

1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .

   Papéis necessários para selecionar ou criar um projeto

   • Selecionar um projeto: para selecionar um projeto, não é necessário ter um papel do IAM específico. É possível selecionar qualquer projeto em que você tenha um papel.
   • Criar um projeto: para criar um projeto, é preciso ter o papel de Criador de projetos (roles/resourcemanager.projectCreator), que contém a permissão resourcemanager.projects.create. Saiba como conceder papéis.

   Acessar o seletor de projetos

2. Verifique se o faturamento está ativado para o projeto do Google Cloud .

3. Verifique se a API Monitoring está ativada. Para ver detalhes, leia Como ativar a API Monitoring.
4. Para aplicativos em execução fora do Google Cloud, o projeto do Google Cloud precisa autenticar o aplicativo usando o Application Default Credentials (ADC) local. Para mais informações, consulte Configurar o ADC para um ambiente local ou outro provedor de nuvem.

Criar um tipo de métrica definido pelo usuário

Para criar uma métrica definida pelo usuário, defina um objeto MetricDescriptor que especifique várias informações sobre a métrica ou grave dados de métricas. Quando você grava dados de métricas, o Monitoring cria o descritor de métrica para você com base na estrutura dos dados fornecidos. Para saber como projetar um descritor de métrica, consulte Descritores de métricas para métricas definidas pelo usuário.

Criação automática de descritores de métrica

Se você gravar dados de métricas quando um descritor de métrica para essa métrica definida pelo usuário ainda não existir, um descritor de métrica será criado automaticamente. No entanto, talvez ele não seja exatamente o que você quer. A criação automática de descritores de métrica inclui algumas suposições e padrões.

O Cloud Monitoring cria um novo MetricDescriptor quando o objeto TimeSeries incluído em uma chamada para timeSeries.create faz referência a um objeto Metric que especifica um nome de tipo de métrica inexistente. O Cloud Monitoring usa as seguintes regras para preencher o MetricDescriptor:

• type: o tipo é copiado do campo type do objeto Metric.
• name: o nome é criado com base no ID do projeto na chamada de método e no valor de type no objeto Metric.
• labels: os rótulos que aparecem no objeto Metric. Cada descritor de rótulo no novo descritor de métrica tem os campos abaixo:
  • key: a chave do rótulo no objeto Metric.
  • valueType: STRING
  • description: não definido
• metricKind: o tipo de métrica é definido como GAUGE, a menos que você especifique o parâmetro metricKind do objeto TimeSeries. Quando você especifica metricKind, a nova métrica tem esse tipo. Só é possível especificar os tipos GAUGE e CUMULATIVE.
• valueType: o tipo de valor é extraído do valor digitado do Point que está sendo gravado. O tipo de valor precisa ser BOOL, INT64, DOUBLE ou DISTRIBUTION. Quando você especifica um tipo de valor no campo valueType do TimeSeries, esse tipo precisa corresponder ao tipo do Point.
• unit: não definido
• description: "Auto created custom metric.".
• displayName: não definido

Em uma única chamada timeSeries.create, é possível incluir vários objetos TimeSeries que se referem ao mesmo tipo de métrica inexistente. Nesse caso, os rótulos no novo descritor de métrica consistem na união de todos os rótulos nos objetos Metric em todas as série temporal nessa chamada para create.

Próxima etapa: consulte Gravar métricas definidas pelo usuário.

Criação manual de descritores de métricas

Para criar um descritor de métrica, faça o seguinte:

1. Determine a estrutura do descritor de métrica. Para ajudar a fazer essas escolhas, navegue pelas métricas integradas e analise os dados de série temporal:

   1. Escolha um nome de métrica para sua métrica definida pelo usuário.

   2. Escolha um nome de exibição e uma descrição para sua métrica. O nome de exibição é usado no console do Google Cloud .

   3. Escolha um ou mais projetos para definir a métrica definida pelo usuário e gravar os dados de série temporal. Quando você precisar da mesma métrica em vários projetos, faça definições idênticas da métrica em cada projeto.

   4. Determine o tipo de métrica e de valor e, se quiser, as unidades. Nem todos os tipos de valor e de métrica são compatíveis com métricas definidas pelo usuário. Para mais informações sobre esses campos, consulte Tipos de valor e tipos de métricas.

   5. Escolha os rótulos da métrica: nomes, tipos de valor e descrições.

2. Determine os recursos monitorados em que os dados de métricas são gravados. Escolha uma das seguintes opções:

   • aws_ec2_instance: instância do Amazon EC2.
   • dataflow_job: job do Dataflow.
   • gae_instance: instância do App Engine.
   • gce_instance: instância do Compute Engine.
   • generic_node: nó de computação especificado pelo usuário.
   • generic_task: tarefa definida pelo usuário.
   • gke_container: instância de contêiner do GKE.
   • global: use esse recurso quando nenhum outro tipo de recurso for adequado. Na maioria dos casos de uso, generic_node ou generic_task são melhores opções do que global.
   • k8s_cluster: cluster do Kubernetes.
   • k8s_container: contêiner do Kubernetes.
   • k8s_node: nó do Kubernetes.
   • k8s_pod: pod do Kubernetes.

3. Crie um objeto MetricDescriptor e transmita-o como um argumento para uma chamada ao método metricDescriptors.create.

Normalmente, é um erro chamar metricDescriptors.create usando o mesmo nome de tipo de um descritor de métrica atual. No entanto, se todos os campos do novo objeto MetricDescriptor corresponderem exatamente aos campos do descritor existente, não será um erro, mas não terá efeito.

No exemplo a seguir, você cria uma métrica de medidor.

Protocolo

Para criar um descritor de métrica, use o método metricDescriptors.create. É possível executá-lo por meio do widget da APIs Explorer na página de referência do método. Consulte APIs Explorer para mais informações.

Veja a seguir os parâmetros de exemplo para metricDescriptors.create:

• nome (URL): projects/[PROJECT_ID]

• Corpo da solicitação: forneça um objeto MetricDescriptor como este:

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

Insira esses valores nos campos do widget, usando o ID do projeto no lugar de [PROJECT_ID]:

Clique em Executar para executar o método.

Faça o teste!

Observação :para ver a solicitação como um comando curl, uma solicitação HTTP ou em JavaScript, clique em Tela cheia no APIs Explorer.

Ao criar uma nova métrica, o campo name no MetricDescriptor é ignorado e pode ser omitido. O método create retorna o novo descritor de métrica com o campo name preenchido, que neste exemplo seria:

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

Por exemplo, se você quiser receber o descritor de uma métrica, use esse nome.

C#

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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

Consulte Resolver problemas de chamadas de API se tiver dificuldade.

Próxima etapa: consulte Gravar métricas definidas pelo usuário.

Gravar métricas definidas pelo usuário

Só é possível gravar dados em tipos de métricas definidas pelo usuário. Para gravar seus dados, use o método timeSeries.create. Quando a série temporal existe, esse método anexa um novo ponto de dados à série temporal atual. Quando a série temporal não existe, esse método a cria e anexa os dados.

Você escreve pontos de dados passando uma lista de objetos TimeSeries para timeSeries.create. O tamanho máximo da lista é de 200, e cada objeto nela precisa especificar uma série temporal diferente:

• Os valores dos campos metric e resource identificam um objeto TimeSeries específico. Esses campos representam o tipo de métrica dos dados e o recurso monitorado a partir do qual os dados foram coletados.
• Omita os campos metricKind e valueType. Eles são ignorados ao gravar pontos de dados.

• Cada objeto TimeSeries pode conter apenas um único objeto Point:

  • O valor do ponto e o intervalo de tempo precisam ser consistentes com a definição do tipo de métrica. Para informações sobre intervalos de tempo de tipos diferentes de métricas, consulte TimeInterval.
  • O intervalo de tempo do ponto precisa ser posterior a qualquer ponto atual na série temporal.
  • O tempo de término do intervalo não pode ser maior que 25 horas no passado nem que cinco minutos no futuro.

• Para gravar mais de um ponto na mesma série temporal, use uma chamada separada para o método timeSeries.create para cada ponto. Não grave dados em uma única série temporal mais rapidamente do que um ponto a cada 5 segundos. Quando você adiciona pontos de dados a diferentes série temporal, não há limitação de taxa.

Protocolo

Para gravar dados de métricas, use o método timeSeries.create. É possível executá-lo por meio do widget da APIs Explorer na página de referência do método. Consulte o APIs Explorer para mais informações.

Para gravar um ponto na métrica stores/daily_sales criada em Criação manual de descritores de métricas:

1. Acesse a página de referência de timeSeries.create.
2. Forneça os parâmetros abaixo ao widget das APIs Explorer.
3. Clique no botão Executar.

Use os seguintes parâmetros de amostra:

• nome: projects/[PROJECT_ID]

• Corpo da solicitação: inclua uma lista de objetos TimeSeries. A amostra a seguir tem apenas uma série temporal na lista.

  Observação: você precisa mudar os valores project_id e endTime no corpo da solicitação a seguir. Use o código do projeto. O endTime precisa estar próximo do horário atual e date -Iseconds retorna a hora atual em um formato utilizável.

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

Faça o teste!

Observação :para ver a solicitação como um comando curl, uma solicitação HTTP ou em JavaScript, clique em Tela cheia no APIs Explorer.

C#

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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."

Consulte Resolver problemas de chamadas de API se tiver dificuldade.

Excluir métricas definidas pelo usuário

Para excluir uma métrica definida pelo usuário, exclua o descritor de métrica dela. Não é possível excluir os dados de série temporal armazenados no projeto do Google Cloud . No entanto, excluir o descritor de métrica torna os dados inacessíveis. Os dados expiram e são excluídos de acordo com a política de retenção de dados.

Não é possível excluir o descritor de métrica de uma métrica integrada.

Observação: ao excluir um descritor de métrica, os dados de série temporal dele ficam inacessíveis. Se você recriar um descritor de métrica excluído, exatamente como estava antes da exclusão, talvez seja possível recuperar o acesso aos dados. Não dependa desse comportamento.

Para excluir o descritor de métrica, chame o método metricDescriptors.delete.

Protocolo

Para excluir um descritor de métrica, use o método metricDescriptors.delete. É possível executá-lo por meio do widget da APIs Explorer na página de referência do método. Consulte o APIs Explorer para mais informações.

Para excluir a métrica stores/daily_sales criada em Criação manual de descritores de métricas:

1. Acesse a página de referência de metricDescriptors.delete.

2. Forneça o nome do descritor de métrica ao widget da APIs Explorer:

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

3. Clique no botão Executar.

Faça o teste!

Observação :para ver a solicitação como um comando curl, uma solicitação HTTP ou em JavaScript, clique em Tela cheia no APIs Explorer.

C#

Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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}."

Consulte Resolver problemas de chamadas de API se tiver dificuldade.

Modificar uma métrica definida pelo usuário

Para modificar uma métrica definida pelo usuário, atualize o objeto MetricDescriptor que define a métrica. A única modificação aceita é adicionar rótulos.

Para adicionar rótulos a uma métrica definida pelo usuário, use o método timeSeries.create e inclua os novos rótulos com os dados de série temporal. Os rótulos são adicionados ao descritor de métricas quando os rótulos que você tenta gravar são válidos e o número total de rótulos é menor que 30.

Os dados de série temporal são gravados como se o rótulo estivesse lá desde o início.

Se você quiser fazer mais do que adicionar novos rótulos, exclua e recrie o descritor de métrica. Nesse caso, você perde todos os dados de série temporal coletados anteriormente para o descritor de métrica antigo. Consulte Excluir métricas definidas pelo usuário para mais informações.

Não é possível renomear uma métrica.

A seguir

• Ver e gerenciar o uso de métricas
• Lista de métricas integradas
• Lista de recursos monitorados