Anotação @Timed usando métricas e aspectosJ

1. Introdução

Monitoring is very helpful for finding bugs and optimizing performance. Poderíamos instrumentar manualmente nosso código para adicionar temporizadores e registro, mas isso levaria a muitos clichês perturbadores.

Por outro lado, podemos usar uma estrutura de monitoramento, orientada por anotações, comoDropwizard Metrics.

Neste tutorial, iremos instrumentar uma classe simples usandoMetrics AspectJ, e a anotação Dropwizard Metrics @Timed.

2. Configuração do Maven

Em primeiro lugar, vamos adicionar as dependências do Metrics AspectJ Maven ao nosso projeto:


    io.astefanutti.metrics.aspectj
    metrics-aspectj
    1.2.0
    
        
            org.slf4j
            slf4j-api
        
    


    io.astefanutti.metrics.aspectj
    metrics-aspectj-deps
    1.2.0

Estamos usandometrics-aspectj para fornecermetrics por meio de programação orientada a aspectos emetrics-aspectj-deps para fornecer suas dependências.

Também precisamos doaspectj-maven-plugin para configurar o processamento do tempo de compilação das anotações de métricas:


    org.codehaus.mojo
    aspectj-maven-plugin
    1.8
    
        1.8
        1.8
        1.8
        
            
                io.astefanutti.metrics.aspectj
                metrics-aspectj
            
        
    
    
        
            
                compile

Agora, nosso projeto está pronto para ter algum código Java instrumentado.

3. Instrumentação de anotação

Em primeiro lugar, vamos criar um método e anotá-lo com a anotação@Timed. Também preencheremos a propriedadename com um nome para nosso cronômetro:

import com.codahale.metrics.annotation.Timed;
import io.astefanutti.metrics.aspectj.Metrics;

@Metrics(registry = "objectRunnerRegistryName")
public class ObjectRunner {

    @Timed(name = "timerName")
    public void run() throws InterruptedException {
        Thread.sleep(1000L);
    }
}

Estamos usando@Metrics annotation at the class level para permitir que o framework Metrics AspectJ saiba que esta classe tem métodos a serem monitorados. We’re putting @Timed on the method para criar o cronômetro.

Além disso,@Metrics cria um registro usando o nome de registro fornecido -objectRunnerRegistryName neste caso - para armazenar as métricas.

Nosso código de exemplo dorme por um segundo para emular uma operação.

Agora, vamos definir uma classe para iniciar o aplicativo e configurar nossoMetricsRegistry:

public class ApplicationMain {
    static final MetricRegistry registry = new MetricRegistry();

    public static void main(String args[]) throws InterruptedException {
        startReport();

        ObjectRunner runner = new ObjectRunner();

        for (int i = 0; i < 5; i++) {
            runner.run();
        }

        Thread.sleep(3000L);
    }

    static void startReport() {
        SharedMetricRegistries.add("objectRunnerRegistryName", registry);

        ConsoleReporter reporter = ConsoleReporter.forRegistry(registry)
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .outputTo(new PrintStream(System.out))
                .build();
        reporter.start(3, TimeUnit.SECONDS);
    }
}

No métodostartReport deApplicationMain, configuramos a instância de registro paraSharedMetricRegistries usando o mesmo nome de registro usado em@Metrics.

Depois disso, criamos umConsoleReporter simples para relatar nossas métricas do método anotado@Timed. Devemos observar que existemother types of reporters available.

Nosso aplicativo chamará o método cronometrado cinco vezes. Vamos compilá-lo com o Maven e depois executá-lo:

-- Timers ----------------------------------------------------------------------
ObjectRunner.timerName
             count = 5
         mean rate = 0.86 calls/second
     1-minute rate = 0.80 calls/second
     5-minute rate = 0.80 calls/second
    15-minute rate = 0.80 calls/second
               min = 1000.49 milliseconds
               max = 1003.00 milliseconds
              mean = 1001.03 milliseconds
            stddev = 1.10 milliseconds
            median = 1000.54 milliseconds
              75% <= 1001.81 milliseconds
              95% <= 1003.00 milliseconds
              98% <= 1003.00 milliseconds
              99% <= 1003.00 milliseconds
            99.9% <= 1003.00 milliseconds

Como podemos ver, a estrutura Metrics fornece estatísticas detalhadas para pouquíssimas alterações de código em um método que queremos instrumentar.

Devemos observar que a execução do aplicativo sem a compilação do Maven - por exemplo, por meio de um IDE - pode não obter a saída acima. We need to ensure the AspectJ compilation plugin is included in the build for this to work.

4. Conclusão

Neste tutorial, investigamoshow to instrument a simple Java application with Metrics AspectJ.

Achamos as anotações do Metrics AspectJ uma boa maneira de instrumentar o código sem precisar de uma grande estrutura de aplicativos como Spring, JEE ou Dropwizard. Em vez disso, usando aspectos, conseguimos adicionar interceptadores em tempo de compilação.

Como sempre, o código-fonte completo do exemplo está disponívelover on GitHub.

TOC

Anotação @Timed usando métricas e aspectosJ