Cómo medir los métodos de servicio usando spring boot 2 y micrómetro

Recuerda que en las ciencias informáticas un problema casi siempre tiene más de una resoluciones, de igual modo te compartimos lo más óptimo y eficiente.

Solución:

@io.micrometer.core.annotation.Timed la anotación parece estar fuera de servicio para las llamadas personalizadas debido a la reducción del alcance, ya que se menciona en el enlace de su pregunta.

Debe configurar manualmente un aspecto:

@Configuration
@EnableAspectJAutoProxy
public class AutoTimingConfiguration 
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) 
        return new TimedAspect(registry);
        

De esta manera método como este:

@Timed("GET_CARS")
public List getCars()
        return Lists.newArrayList();

resultará en GET_CARS métrica en /actuator/metrics punto final (predeterminado).

Aquí hay una pequeña muestra que debería ayudarlo. Hay más variantes para Timer.record() que no se muestran aquí. (Además: la inyección de campo solo se usa por brevedad). No tiene que poner el nombre de los métodos llamados en una etiqueta. También puede hacer que forme parte del propio nombre de la métrica. Solo quería mostrar lo que podías hacer.

Actualización 2018-03-12: A partir de Micrometer 1.0.0 un TimedAspect se ha introducido para que también pueda utilizar el @Timed anotación. Por ahora necesita registrar el Bean tú mismo. (Sin embargo, debe tener cuidado cuando tiene @Timed anotaciones en sus recursos Spring-MVC o Jersey). Esto ya lo mencionó Michal Stepan en una respuesta de seguimiento.

package io.github.mweirauch.micrometered.eval;

import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import io.micrometer.core.annotation.Timed;
import io.micrometer.core.aop.TimedAspect;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micrometer.core.instrument.Timer.Sample;

@Configuration
@EnableAspectJAutoProxy
public class TimingStuff 

    @Service
    static class MyService 

        @Autowired
        private MeterRegistry registry;

        public void helloManual() 
            // you can keep a ref to this; ok to call multiple times, though
            Timer timer = Timer.builder("myservice").tag("method", "manual").register(registry);

            // manually do the timing calculation
            long start = System.nanoTime();
            doSomething();
            timer.record(System.nanoTime() - start, TimeUnit.NANOSECONDS);
        

        public void helloSupplier() 
            Timer timer = Timer.builder("myservice").tag("method", "supplier").register(registry);

            // execution of the method is timed internally
            timer.record(() -> doSomething());
        

        public void helloSample() 
            Timer timer = Timer.builder("myservice").tag("method", "sample").register(registry);

            // records time taken between Sample creation and registering the
            // stop() with the given Timer
            Sample sample = Timer.start(registry);
            doSomething();
            sample.stop(timer);
        

        // TimedAspect adds "class" and "method" tags
        @Timed(value = "myservice.aspect")
        public void helloAspect() 
            doSomething();
        

        private void doSomething() 
            try 
                Thread.sleep(50);
             catch (InterruptedException e) 
                //
            
        

    

    @Autowired
    private MyService myService;

    @Bean
    TimedAspect timedAspect(MeterRegistry registry) 
        return new TimedAspect(registry);
    

    @Scheduled(fixedRate = 1000)
    public void postConstruct() 
        myService.helloManual();
        myService.helloSupplier();
        myService.helloSample();
        myService.helloAspect();
    

En caso de que optes por Prometheus, terminarías con algo así:

# HELP myservice_seconds  
# TYPE myservice_seconds summary
myservice_seconds_countapplication="micrometered",method="manual", 4.0
myservice_seconds_sumapplication="micrometered",method="manual", 0.200378014
myservice_seconds_maxapplication="micrometered",method="manual", 0.050115291
myservice_seconds_countapplication="micrometered",method="supplier", 4.0
myservice_seconds_sumapplication="micrometered",method="supplier", 0.200393455
myservice_seconds_maxapplication="micrometered",method="supplier", 0.05011635
myservice_seconds_countapplication="micrometered",method="sample", 4.0
myservice_seconds_sumapplication="micrometered",method="sample", 0.200527005
myservice_seconds_maxapplication="micrometered",method="sample", 0.050250191
# HELP myservice_aspect_seconds  
# TYPE myservice_aspect_seconds summary
myservice_aspect_seconds_countapplication="micrometered",class="io.github.mweirauch.micrometered.eval.TimingStuff$MyService",method="helloAspect", 4.0
myservice_aspect_seconds_sumapplication="micrometered",class="io.github.mweirauch.micrometered.eval.TimingStuff$MyService",method="helloAspect", 0.201824272
myservice_aspect_seconds_maxapplication="micrometered",class="io.github.mweirauch.micrometered.eval.TimingStuff$MyService",method="helloAspect", 0.051014296

valoraciones y reseñas

---

---

Utiliza Nuestro Buscador