Métricas personalizadas com o Application Signals

Para monitorar a performance e a disponibilidade de aplicações, o Application Signals coleta métricas padrão (falhas, erros e latência) e métricas de runtime das aplicações descobertas depois de ativá-lo.

As métricas personalizadas adicionam um contexto muito útil ao monitoramento de aplicações e ajudam a agilizar a solução de problemas. Você pode usá-las para:

• Personalizar a análise dos dados de telemetria

• Identificar as causas raiz dos problemas

• Tomar decisões comerciais e operacionais precisas com rapidez

O Application Signals permite que você visualize e correlacione métricas personalizadas geradas de um serviço com métricas padrão e de runtime. Por exemplo, uma aplicação pode emitir métricas para o tamanho da solicitação e a contagem de falhas de cache. Essas métricas personalizadas fornecem um insight mais granular dos problemas de performance, ajudando você a diagnosticar e resolver quedas de disponibilidade e picos de latência com mais rapidez.

Configuração de métricas personalizadas para o Application Signals

Você pode gerar métricas personalizadas da sua aplicação usando dois métodos: métricas do OpenTelemetry e métricas de extensões.

Tópicos

• Métricas do OpenTelemetry

• Métricas de extensão

Métricas do OpenTelemetry

Para usar métricas personalizadas do OpenTelemetry com o Application Signals, você deve usar o agente do CloudWatch ou o coletor do OpenTelemetry. As métricas personalizadas do OpenTelemetry permitem que você crie e exporte métricas diretamente do código da sua aplicação usando o SDK do OpenTelemetry Metrics.

1. Serviço de integração do Application Signals.

2. Configure o agente ou o coletor.

   • Ao usar o agente do CloudWatch, você deve configurar metrics_collected com um otlp. Por exemplo, cloudwatch-config.json.

     {
       "traces": {
         "traces_collected": {
           "application_signals": {}
         }
       },
       "logs": {
         "metrics_collected": {
           "application_signals": {},
           "otlp": {
             "grpc_endpoint": "0.0.0.0:4317",
             "http_endpoint": "0.0.0.0:4318"
           }
         }
       }
     }

   • Ao usar o coletor do OpenTelemetry, configure um pipeline de métricas. Você deve usar o CloudWatch EMF Exporter para o coletor do OpenTelemetry e habilitar os atributos de recursos para rótulos de métricas. É recomendável configurar dimension_rollup_option: NoDimensionRollup para evitar a emissão de muitas agregações métricas. Por exemplo, config.yaml:

     receivers:
       otlp:
         protocols:
           grpc:
             endpoint: 0.0.0.0:4317
           http:
             endpoint: 0.0.0.0:4318
     
     exporters:
       awsemf:
         region: $REGION
         namespace: $NAMESPACE
         log_group_name:$LOG_GROUP_NAME
         resource_to_telemetry_conversion:
           enabled: true
         dimension_rollup_option: "NoDimensionRollup"
         
       otlphttp/traces:
         compression: gzip
         traces_endpoint: https://xray.$REGION.amazonaws.com/v1/traces
         auth:
           authenticator: sigv4auth/traces
     
     extensions:
       sigv4auth/logs:
         region: "$REGION"
         service: "logs"
       sigv4auth/traces:
         region: "$REGION"
         service: "xray"
     
     processors:
       batch:
     
     service:
       telemetry:
       extensions: [sigv4auth/logs, sigv4auth/traces]
       pipelines:
         metrics:
           receivers: [otlp]
           processors: [batch]
           exporters: [awsemf]
         traces:
           receivers: [otlp]
           processors: [batch]
           exporters: [otlphttp/traces]

3. Configure o ambiente. Quando há vários serviços com o mesmo nome de serviço, e para correlacionar com precisão as métricas do Application Signals com o nome correto do serviço, é recomendável configurar o atributo de recurso deployment.environment.name. A configuração desse atributo de recurso geralmente é feita por meio das variáveis de ambiente.

   OTEL_RESOURCE_ATTRIBUTES="service.name=$YOUR_SVC_NAME,deployment.environment.name=$YOUR_ENV_NAME"

4. Configure a exportação de métricas para o agente do CloudWatch ou o coletor do OpenTelemetry. Você pode usar uma das seguintes abordagens:

   • (Recomendado) Pipeline de exportação personalizado: no código da aplicação, crie um MeterProvider dedicado exportando para o endpoint configurado do agente ou do coletor. Por exemplo:

     Resource resource = Resource.getDefault().toBuilder()
             .put(AttributeKey.stringKey("service.name"), serviceName)
             .put(AttributeKey.stringKey("deployment.environment.name"), environment)
             .build();
     
     MetricExporter metricExporter = OtlpHttpMetricExporter.builder()
             .setEndpoint("http://localhost:4318/v1/metrics")
             .build();
     
     MetricReader metricReader = PeriodicMetricReader.builder(metricExporter)
             .setInterval(Duration.ofSeconds(10))
             .build()
     
     SdkMeterProvider meterProvider = SdkMeterProvider.builder()
         .setResource(resource)
         .registerMetricReader()
         .build();
         
     Meter meter = meterProvider.get("myMeter");

   • Exportação baseada em agente: configure as variáveis de ambiente do agente OTEL_METRICS_EXPORTER e OTEL_EXPORTER_OTLP_METRICS_ENDPOINT. Por exemplo:

     OTEL_METRICS_EXPORTER=otlp
     OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://localhost:4318/v1/metrics

     No código da aplicação, baseie-se no MeterProvider global criado pelo agente. Por exemplo:

     Meter meter = GlobalOpenTelemetry.getMeter("myMeter");

5. Usando o SDK de métricas do OTel no código da aplicação, adicione as métricas do OTel. Por exemplo, para adicionar as métricas do OTel em Python:

   counter = meter.counterBuilder("myCounter").build();
   counter.add(value);
   counter.add(value, Attributes.of(AttributeKey.stringKey("Operation"), "myOperation"));

   Adicionar o atributo Operation não é obrigatório, mas pode ser útil para correlacionar as operações do serviço do Application Signals às métricas personalizadas do OpenTelemetry.

Métricas de extensão

Atualmente, as métricas personalizadas de extensão funcionam apenas com a pesquisa de transações. Com as métricas personalizadas de extensão, você pode:

• Criar métricas usando filtros de métricas

• Processar atributos de extensão adicionados no código da aplicação

• Usar o SDK de rastreamentos do OpenTelemetry para implementação

1. Habilite o monitoramento do Application Signals com a pesquisa de transações. Para obter mais informações, consulte Transaction Search.

   Para garantir 100% de amostragem de métricas, é recomendável enviar 100% das extensões para o endpoint.

2. Adicione atributos de extensão usando o SDK de rastreamentos do OTel. Há duas formas:

   • [Recomendado] Adicione atributos às extensões geradas automaticamente. Por exemplo:

     Span.current().setAttribute("myattribute", value);

   • Adicione atributos às extensões geradas manualmente. Por exemplo:

     Span span = tracer.spanBuilder("myspan").startSpan();
     try (Scope scope = span.makeCurrent()) {
        span.setAttribute("myattribute",  value);
     }

3. Crie um filtro de métricas com os valores a seguir. Para obter informações sobre como criar um filtro de métricas, consulte Create a metric filter for a log group.

   • Grupo de logs: aws/spans

   • Padrão de filtro: { $.attributes.['myattribute'] = * }

   • Nome da métrica: myattribute (os valores devem ser uma correspondência exata ou a correlação de extensão não funcionará)

   • Valor da métrica: $.attributes.['myattribute']

   • Dimensões: Nome do campo: Service, Valor do campo: $.attributes.['aws.local.service'], Nome do campo: Environmente, Valor do campo: $.attributes.['aws.local.environment'] e Nome do campo: Operation, Valor do campo: $.attributes.['aws.local.operation']

     nota

     Ao adicionar atributos às extensões geradas manualmente, você não pode definir Operation porque aws.local.operation não estará presente nos dados da extensão.

Visualização de métricas personalizadas no Application Signals

Você agora pode visualizar métricas personalizadas para serviços e operações no console do Application Signals:

• Selecione um serviço na lista Serviços para ver a nova guia Métricas relacionadas

• Visualize métricas padrão, métricas de runtime e métricas relacionadas para o serviço selecionado

• Filtre e selecione várias métricas da lista

• Gere um gráfico de métricas selecionadas para identificar correlações e causas raiz dos problemas

Para obter mais informações sobre as métricas relacionadas, consulte Visualizar métricas relacionadas.

Perguntas frequentes (FAQs)

Qual é o impacto de não adicionar a configuração do ambiente para métricas personalizadas?

O Application Signals configura o atributo de recurso deployment.environment.name para remover a ambiguidade das aplicações. O Application Signals não pode correlacionar métricas personalizadas geradas de dois serviços diferentes com o mesmo nome ao serviço correto sem a remoção da ambiguidade.

Para adicionar a configuração do ambiente à aplicação, consulte Métricas do OpenTelemetry.

Há algum limite para filtros de métricas?

Você só pode criar até cem filtros de métricas por grupo de logs do CloudWatch Logs. Cada métrica definida pode ter até três dimensões. Você pode ver os limites dos filtros de métricas aqui Métricas do OpenTelemetry.

Por que os grafos de métricas não aparecem na tabela de métricas?

A solução depende do tipo de métrica:

• Métricas personalizadas: consulte Configuração de métricas personalizadas para o Application Signals para verificar a configuração de métricas

• Métricas padrão ou de runtime: consulte Solução de problemas relacionados à instalação do Application Signals