[스프링 핵심 원리와 활용] 섹션11. 모니터링 메트릭 활용(2)

[YONGHYNG]

메트릭 등록3 - Timer

Timer

• Timer는 좀 특별한 메트릭 측정 도구인데, 시간을 측정하는데 사용된다.
  • 카운터와 유사한데, Timer 를 사용하면 실행 시간도 함께 측정할 수 있다.
  • Timer 는 다음과 같은 내용을 한번에 측정해준다.
    • seconds_count : 누적 실행 수 - 카운터
    • seconds_sum : 실행 시간의 합 - sum
    • seconds_max : 최대 실행 시간(가장 오래걸린 실행 시간) - 게이지
      • 내부에 타임 윈도우라는 개념이 있어서 1~3분 마다 최대 실행 시간이 다시 계산된다.

OrderService

package hello.order;

import java.util.concurrent.atomic.AtomicInteger;

public interface OrderService {

    void order();
    void cancel();
    AtomicInteger getStock();
}

• 주문, 취소, 재고 수량을 확인할 수 있는 주문 서비스 인터페이스이다.

OrderServiceV0

package hello.order.v0;

import hello.order.OrderService;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicInteger;


@Slf4j
public class OrderServiceV0 implements OrderService {

    private AtomicInteger stock = new AtomicInteger(100);

    @Override
    public void order() {
        log.info("주문");
        stock.decrementAndGet();
    }

    @Override
    public void cancel() {
        log.info("취소");
        stock.incrementAndGet();
    }

    @Override
    public AtomicInteger getStock() {
        return stock;
    }
}

• new AtomicInteger(100) 초기값을 100으로 설정해둔다. 재고 수량이 100부터 시작한다고 가정한다.

OrderConfigV0

package hello.order.v0;

import hello.order.OrderService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OrderConfigV0 {

    @Bean
    OrderService orderService() {
        return new OrderServiceV0();
    }
}

• 앞서 만든 OrderService 빈을 직접 등록하는 설정이다.

OrderController

package hello.controller;

import hello.order.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class OrderController {

    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping("/order")
    public String order() {
        log.info("order");
        orderService.order();
        return "order";
    }

    @GetMapping("/cancel")
    public String cancel() {
        log.info("cancel");
        orderService.cancel();
        return "cancel";
    }

    @GetMapping("/stock")
    public int stock() {
        log.info("stock");
        return orderService.getStock().get();
    }
}

• 주문, 취소, 재고 수량을 확인하는 컨트롤러이다.
• 참고: 예제의 단순함을 위해서 GET 을 사용했습니다.

ActuatorApplication

package hello;
import hello.order.v0.OrderConfigV0;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;

@Import(OrderConfigV0.class)
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {
    public static void main(String[] args) {
        SpringApplication.run(ActuatorApplication.class, args);
    }
}

• @import(OrderConfigV0.class) : OrderServiceV0 를 사용하는 설정이다.
• @SpringBootApplication(scanBasePackages = "hello.controller") : 컴포넌트 스캔의 대상을 컨트롤러로 제한한다. 그렇지 않으면 이후에 추가할 OrderConfigVX 가 모두 스프링 빈으로 등록되는 문제가 발생한다.

메트릭 등록1 - 카운터

• 마이크로미터를 사용해서 메트릭을 직접 등록하는 방법을 알아보자. 먼저 주문수, 취소수를 대상으로 카운터 메트릭을 등록해보자.

MeterRegistry

• 마이크로미터 기능을 제공하는 핵심 컴포넌트 스프링을 통해서 주입 받아서 사용하고, 이곳을 통해서 카운터, 게이지 등을 등록한다.

Counter(카운터)

• 단조롭게 증가하는 단일 누적 측정항목
  • 단일 값
  • 보통 하나씩 증가
  • 누적이므로 전체 값을 포함(total)
  • 프로메테우스에서는 일반적으로 카운터의 이름 마지막에 _total 을 붙여서my_order_total 과 같이 표현함
• 값을 증가하거나 0으로 초기화 하는 것만 가능
• 마이크로미터에서 값을 감소하는 기능도 지원하지만, 목적에 맞지 않음
• 예) HTTP 요청수

주문수 취소수 서비스에 카운터 메트릭을 적용해보자.

OrderServiceV1

package hello.order.v1;

import hello.order.OrderService;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
public class OrderServiceV1 implements OrderService {

    private final MeterRegistry registry;
    private AtomicInteger stock = new AtomicInteger(100);

    public OrderServiceV1(MeterRegistry registry) {
        this.registry = registry;
    }

    @Override
    public void order() {
        log.info("주문");
        stock.decrementAndGet();

        Counter.builder("my.order")
                .tag("class", this.getClass().getName())
                .tag("method", "order")
                .description("order")
                .register(registry).increment();
    }

    @Override
    public void cancel() {
        log.info("취소");
        stock.incrementAndGet();

        Counter.builder("my.order")
                .tag("class", this.getClass().getName())
                .tag("method", "cancel")
                .description("order")
                .register(registry).increment();
    }

    @Override
    public AtomicInteger getStock(){
        return stock;
    }
}

• Counter.builder(name) 를 통해서 카운터를 생성한다. name 에는 메트릭 이름을 지정한다.
• tag 를 사용했는데, 프로메테우스에서 필터할 수 있는 레이블로 사용된다.
• 주문과 취소는 메트릭 이름은 같고 tag 를 통해서 구분하도록 했다.
• register(registry) : 만든 카운터를 MeterRegistry 에 등록한다. 이렇게 등록해야 실제 동작한다.
• increment() : 카운터의 값을 하나 증가한다.

정리하면 각각의 메서드를 하나 호출할 때 마다 카운터가 증가한다.

OrderConfigV1

package hello.order.v1;

import hello.order.OrderService;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OrderConfigV1 {

    @Bean
    OrderService orderService(MeterRegistry registry) {
        return new OrderServiceV1(registry);
    }
}

ActuatorApplication - 수정

package hello;
//@Import(OrderConfigV0.class)
@Import(OrderConfigV1.class)
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {} 

프로메테우스 포멧 메트릭 확인

# HELP my_order_total order
# TYPE my_order_total counter
my_order_total{class="hello.order.v1.OrderServiceV1",method="order",} 1.0
my_order_total{class="hello.order.v1.OrderServiceV1",method="cancel",} 1.0

• 메트릭 이름이 my.order => my_order_total 로 변경된 것을 확인할 수 있다.
  • 프로메테우스는 . => _ 로 변경한다.
  • 카운터는 마지막에 _total 을 붙인다. 프로메테우스는 관례상 카운터 이름의 끝에 _total 을 붙인다.
  • method 라는 tag , 레이블을 기준으로 데이터가 분류되어 있다.

그라파나 등록 - 주문수, 취소수

• 앞서 만들어둔 hello-dashboard 에 주문수, 취소수 그래프를 추가하자

Panel options

• Title : 주문수

PromQL

• increase(my_order_total{method="order"}[1m])
  • Legend : {{method}}
• increase(my_order_total{method="cancel"}[1m])
  • Legend : {{method}}
    참고: 카운터는 계속 증가하기 때문에 특정 시간에 얼마나 증가했는지 확인하려면 increase() , rate() 같은 함수와 함께 사용하는 것이 좋다.

메트릭 등록2 - @counted

• 앞서 만든 OrderServiceV1 의 가장 큰 단점은 메트릭을 관리하는 로직이 핵심 비즈니스 개발 로직에 침투했다는 점이다. 이런 부분을 분리하려면 어떻게 해야할까? 바로 스프링 AOP를 사용하면 된다.
• 직접 필요한 AOP를 만들어서 적용해도 되지만, 마이크로미터는 이런 상황에 맞추어 필요한 AOP 구성요소를 이미 다 만들어두었다.

OrderServiceV2

package hello.order.v2;

import hello.order.OrderService;
import io.micrometer.core.annotation.Counted;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
public class OrderServiceV2 implements OrderService {

    private AtomicInteger stock = new AtomicInteger(100);

    @Counted("my.order")
    @Override
    public void order() {
        log.info("주문");
        stock.decrementAndGet();
    }

    @Counted("my.order")
    @Override
    public void cancel() {
        log.info("취소");
        stock.incrementAndGet();
    }

    @Override
    public AtomicInteger getStock(){
        return stock;
    }
}

• @counted 애노테이션을 측정을 원하는 메서드에 적용한다. 주문과 취소 메서드에 적용했다.
• 그리고 메트릭 이름을 지정하면 된다. 여기서는 이전과 같은 my.order 를 적용했다.
• 참고로 이렇게 사용하면 tag 에 method 를 기준으로 분류해서 적용한다.

OrderConfigV2

package hello.order.v2;

import hello.order.OrderService;
import io.micrometer.core.aop.CountedAspect;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OrderConfigV2 {

    @Bean
    public OrderService orderService() {
        return new OrderServiceV2();
    }
    
    @Bean
    public CountedAspect countedAspect(MeterRegistry registry) {
        return new CountedAspect(registry);
    }

}

• CountedAspect를 등록하면 @counted를 인지해서 Counter를 사용하는 AOP를 적용한다.
• 주의! CountedAspect를 빈으로 등록하지 않으면 @counted 관련 AOP가 동작하지 않는다.

ActuatorApplication

package hello;
import hello.order.v0.OrderConfigV0;
import hello.order.v1.OrderConfigV1;
import hello.order.v2.OrderConfigV2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;

//@Import(OrderConfigV0.class)
//@Import(OrderConfigV1.class)
@Import(OrderConfigV2.class)
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {
    public static void main(String[] args) {
        SpringApplication.run(ActuatorApplication.class, args);
    }
}

액츄에이터 메트릭 확인

- @counted 를 사용하면 result , exception , method , class 같은 다양한 tag 를 자동으로 적용한다.

프로메테우스 포멧 메트릭 확인

# HELP my_order_total
# TYPE my_order_total counter
my_order_total{class="hello.order.v2.OrderServiceV2",exception="none",method="or
der",result="success",} 4.0
my_order_total{class="hello.order.v2.OrderServiceV2",exception="none",method="ca
ncel",result="success",} 1.0

그라파나 대시보드 확인

• 메트릭 이름과 tag가 기존과 같으므로 같은 대시보드에서 확인할 수 있다.

메트릭 등록3 - Timer

Timer

• Timer는 좀 특별한 메트릭 측정 도구인데, 시간을 측정하는데 사용된다.
  • 카운터와 유사한데, Timer 를 사용하면 실행 시간도 함께 측정할 수 있다.
  • Timer 는 다음과 같은 내용을 한번에 측정해준다.
    • seconds_count : 누적 실행 수 - 카운터
    • seconds_sum : 실행 시간의 합 - sum
    • seconds_max : 최대 실행 시간(가장 오래걸린 실행 시간) - 게이지
      • 내부에 타임 윈도우라는 개념이 있어서 1~3분 마다 최대 실행 시간이 다시 계산된다.

OrderServiceV3

package hello.order.v3;

import hello.order.OrderService;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import lombok.extern.slf4j.Slf4j;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

import static java.lang.Thread.sleep;

@Slf4j
public class OrderServiceV3 implements OrderService {

    private final MeterRegistry registry;
    private AtomicInteger stock = new AtomicInteger(100);

    public OrderServiceV3(MeterRegistry registry) {
        this.registry = registry;
    }

    @Override
    public void order() {
        Timer timer = Timer.builder("my.order")
                .tag("class", this.getClass().getName())
                .tag("method", "order")
                .description("order")
                .register(registry);

        timer.record(() -> {
            log.info("주문");
            stock.decrementAndGet();
            sleep(500);
        });

    }
    @Override
    public void cancel() {
        Timer timer = Timer.builder("my.order")
                .tag("class", this.getClass().getName())
                .tag("method", "cancel")
                .description("order")
                .register(registry);
        timer.record(() -> {
            log.info("취소");
            stock.incrementAndGet();
            sleep(200);
        });
    }

    private static void sleep(int l) {
        try {
            Thread.sleep(l + new Random().nextInt(200));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public AtomicInteger getStock() {
        return stock;
    }
}

• Timer.builder(name) 를 통해서 타이머를 생성한다. name 에는 메트릭 이름을 지정한다.
• tag 를 사용했는데, 프로메테우스에서 필터할 수 있는 레이블로 사용된다.
• 주문과 취소는 메트릭 이름은 같고 tag 를 통해서 구분하도록 했다.
• register(registry) : 만든 타이머를 MeterRegistry 에 등록한다. 이렇게 등록해야 실제 동작한다.
• 타이머를 사용할 때는 timer.record() 를 사용하면 된다. 그 안에 시간을 측정할 내용을 함수로 포함하면 된다.

걸리는 시간을 확인하기 위해 주문은 0.5초, 취소는 0.2초 대기하도록 했다. 추가로 가장 오래 걸린 시간을 확인하기 위해 sleep() 에서 최대 0.2초를 랜덤하게 더 추가했다. (모두 0.5초로 같으면 가장 오래 걸린 시간을 확인하기 어렵다.)

OrderConfigV3

package hello.order.v3;

import hello.order.OrderService;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OrderConfigV3 {

    @Bean
    OrderService orderService(MeterRegistry registry) {
        return new OrderServiceV3(registry);
    }
}

ActuatorApplication - 변경

package hello;
//@Import(OrderConfigV1.class)
//@Import(OrderConfigV2.class)
@Import(OrderConfigV3.class)
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {} 

• measurements 항목을 보면 COUNT , TOTAL_TIME , MAX 이렇게 총 3가지 측정 항목을 확인할 수 있다.

1. COUNT : 누적 실행 수(카운터와 같다)
2. TOTAL_TIME : 실행 시간의 합(각각의 실행 시간의 누적 합이다)
3. MAX : 최대 실행 시간(가장 오래 걸린 실행시간이다)
4. 타이머를 사용하면 총 3가지 측정 항목이 생기는 것을 확인할 수 있다.

• 프로메테우스로 다음 접두사가 붙으면서 3가지 메트릭을 제공한다.

1. seconds_count : 누적 실행 수
2. seconds_sum : 실행 시간의 합
3. seconds_max : 최대 실행 시간(가장 오래걸린 실행 시간), 프로메테우스 gague
4. 참고: 내부에 타임 윈도우라는 개념이 있어서 1~3분 마다 최대 실행 시간이 다시 계산된다.

여기서 평균 실행 시간도 계산할 수 있다.

• seconds_sum / seconds_count = 평균 실행시간

그라파나 등록 - 주문수 v3

• 앞서 만들어둔 hello-dashboard 에 주문수, 취소수 그래프를 추가하자

패널 옵션

• Title : 주문수 v3

PromQL

• increase(my_order_seconds_count{method="order"}[1m])
  • Legend : {{method}}
• increase(my_order_seconds_count{method="cancel"}[1m])
  • Legend : {{method}}
    참고: 카운터는 계속 증가하기 때문에 특정 시간에 얼마나 증가했는지 확인하려면 increase() , rate() 같은 함수와 함께 사용하는 것이 좋다.

그라파나 등록 - 최대 실행시간

패널 옵션

• Title : 최대 실행시간

PromQL

• my_order_seconds_max

그라파나 등록 - 평균 실행시간

패널 옵션

• Title : 평균 실행시간

PromQL

• increase(my_order_seconds_sum[1m]) / increase(my_order_seconds_count[1m])

메트릭 등록4 - @timed

• 타이머는 @timed 라는 애노테이션을 통해 AOP를 적용할 수 있다.

OrderServiceV4

package hello.order.v4;

import hello.order.OrderService;
import io.micrometer.core.annotation.Timed;
import lombok.extern.slf4j.Slf4j;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

import static java.lang.Thread.sleep;

@Timed("my.order")
@Slf4j
public class OrderServiceV4 implements OrderService {

    private AtomicInteger stock = new AtomicInteger(100);

    @Override
    public void order() {
        log.info("주문");
        stock.decrementAndGet();
        sleep(500);
    }

    @Override
    public void cancel() {
        log.info("취소");
        stock.incrementAndGet();
        sleep(200);
    }

    private static void sleep(int l) {
        try {
            Thread.sleep(l + new Random().nextInt(200));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public AtomicInteger getStock(){
        return stock;
    }
}

• @timed("my.order") 타입이나 메서드 중에 적용할 수 있다. 타입에 적용하면 해당 타입의 모든 public 메서드에 타이머가 적용된다. 참고로 이 경우 getStock() 에도 타이머가 적용된다.

OrderConfigV4

package hello.order.v4;

import hello.order.OrderService;
import io.micrometer.core.aop.TimedAspect;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.context.annotation.Bean;

public class OrderConfigV4 {

    @Bean
    OrderService orderService() {
        return new OrderServiceV4();
    }

    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

• TimedAspect를 적용해야 @timed에 AOP가 적용된다.

ActuatorApplication - 변경

package hello;
//@Import(OrderConfigV1.class)
//@Import(OrderConfigV2.class)
//@Import(OrderConfigV3.class)
@Import(OrderConfigV4.class)
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {}

{
  "name": "my.order",
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 2
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 0.969096792
    },
    {
      "statistic": "MAX",
      "value": 0.685785584
    }
  ],
  "availableTags": [
    {
      "tag": "exception",
      "values": [
        "none"
      ]
    },
    {
      "tag": "method",
      "values": [
        "cancel",
        "order"
      ]
    },
    {
      "tag": "class",
      "values": [
        "hello.order.v4.OrderServiceV4"
      ]
    }
  ]
}

프로메테우스 포멧 메트릭 확인

# HELP my_order_seconds
# TYPE my_order_seconds summary
my_order_seconds_count{class="hello.order.v4.OrderServiceV4",exception="none",me
thod="cancel",} 1.0
my_order_seconds_sum{class="hello.order.v4.OrderServiceV4",exception="none",meth
od="cancel",} 0.283311208
my_order_seconds_count{class="hello.order.v4.OrderServiceV4",exception="none",me
thod="order",} 1.0
my_order_seconds_sum{class="hello.order.v4.OrderServiceV4",exception="none",meth
od="order",} 0.685785584
# HELP my_order_seconds_max
# TYPE my_order_seconds_max gauge
my_order_seconds_max{class="hello.order.v4.OrderServiceV4",exception="none",meth
od="cancel",} 0.283311208
my_order_seconds_max{class="hello.order.v4.OrderServiceV4",exception="none",meth
od="order",} 0.685785584

그라파나 대시보드 확인

• 메트릭 이름과 tag가 기존과 같은 대시보드에서 확인할 수 있다.

메트릭 등록5 - 게이지

Guage(게이지)

• https://prometheus.io/docs/concepts/metric_types/#gauge
• 게이지는 임의로 오르내릴 수 있는 단일 숫자 값을 나타내는 메트릭
• 값의 현재 상태를 보는데 사용
• 값이 증가하거나 감소할 수 있음
• 예) 차량의 속도, CPU 사용량, 메모리 사용량

참고: 카운터와 게이지를 구분할 때는 값이 감소할 수 있는가를 고민해보면 도움이 된다.

이번에는 재고 수량을 통해 게이지를 등록하는 방법을 알아보자
가장 단순한 방법은 다음과 같이 등록하는 것이다.

StockConfigV1

package hello.order.gauge;

import hello.order.OrderService;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StockConfigV1 {

    @Bean
    public MyStockMetric myStockMetric(OrderService orderService, MeterRegistry registry) {
        return new MyStockMetric(orderService, registry);
    }

    @Slf4j
    static class MyStockMetric {
        private OrderService orderService;
        private MeterRegistry registry;

        public MyStockMetric(OrderService orderService, MeterRegistry registry) {
            this.orderService = orderService;
            this.registry = registry;
        }

        @PostConstruct
        public void init(){
            Gauge.builder("my.stock", orderService, service -> {
               log.info("stock gauge call");
               return service.getStock().get();
            }).register(registry);
        }
    }
}

• my.stock 이라는 이름으로 게이지를 등록했다.
• 게이지를 만들 때 함수를 전달했는데, 이 함수는 외부에서 메트릭을 확인할 때 마다 호출된다. 이 함수의 반환 값이 게이지의 값이다.

ActuatorApplication - 변경

package hello;
//@Import(OrderConfigV4.class)
@Import({OrderConfigV4.class, StockConfigV1.class})
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {} 

• OrderConfigV4 @import({OrderConfigV4.class, StockConfigV1.class}) 로 변경한다.
• 애플리케이션을 실행하면 stock gauge call 로그가 주기적으로 남는 것을 확인할 수 있다.
• 게이지를 확인하는 함수는 외부에서 메트릭을 확인할 때 호출 된다. 현재 프로메테우스가 다음 경로를 통해 주기적으로 메트릭을 확인하기 때문이다.
• http://localhost:8080/actuator/prometheus
• 프로메테우스를 종료해보면 해당 함수가 호출되지 않는 것을 확인할 수 있다. 물론 메트릭 확인 경로를 직접 호출하면 해당 함수가 호출된다.
• 카운터와 다르게 게이지는 무언가를 누적할 필요도 없고, 딱 현재 시점의 값을 보여주면 된다. 따라서 측정 시점에 현재 값을 반환한다.

프로메테우스 포멧 메트릭 확인

# HELP my_stock
# TYPE my_stock gauge
my_stock 101.0

그라파나 등록 - 재고

패널 옵션

• Title: 재고

PromQL

• my_stock

게이지 단순하게 등록하기

StockConfigV2

package hello.order.gauge;

import hello.order.OrderService;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.binder.MeterBinder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class StockConfigV2 {

    @Bean
    public MeterBinder stockSize(OrderService orderService) {
        return registry -> Gauge.builder("my.stock", orderService, service -> {
            log.info("stock gauge call");
            return service.getStock().get();
        }).register(registry);
    }
}

• MeterBinder 타입을 바로 반환해도 된다.

ActuatorApplication - 변경

package hello;
//@Import({OrderConfigV4.class, StockConfigV1.class})
@Import({OrderConfigV4.class, StockConfigV2.class})
@SpringBootApplication(scanBasePackages = "hello.controller")
public class ActuatorApplication {}

• StockConfigV1 @import({OrderConfigV4.class, StockConfigV2.class}) 로 변경한다.

정리

Micrometer 사용법 이해

메트릭은 100% 정확한 숫자를 보는데 사용하는 것이 아니다. 약간의 오차를 감안하고 실시간으로 대략의 데이터를 보
는 목적으로 사용한다.

마이크로미터 핵심 기능

Counter, Gauge, Timer, Tags

MeterRegistry

마이크로미터 기능을 제공하는 핵심 컴포넌트
스프링을 통해서 주입 받아서 사용하고, 이곳을 통해서 카운터, 게이지 등을 등록한다.

Counter(카운터)

• https://prometheus.io/docs/concepts/metric_types/#counter
• 단조롭게 증가하는 단일 누적 측정항목
  • 단일 값
  • 보통 하나씩 증가
  • 누적이므로 전체 값을 포함(total)
  • 프로메테우스에서는 일반적으로 카운터의 이름 마지막에 _total 을 붙여서 my_order_total 과 같이 표현함
• 값을 증가하거나 0으로 초기화 하는 것만 가능
• 마이크로미터에서 값을 감소하는 기능도 지원하지만, 목적에 맞지 않음
• 예) HTTP 요청수

Gauge(게이지)

• https://prometheus.io/docs/concepts/metric_types/#gauge
• 게이지는 임의로 오르내릴 수 있는 단일 숫자 값을 나타내는 메트릭
• 값의 현재 상태를 보는데 사용
• 값이 증가하거나 감소할 수 있음
• 예) 차량의 속도, CPU 사용량, 메모리 사용량
• 참고: 카운터와 게이지를 구분할 때는 값이 감소할 수 있는가를 고민해보면 도움이 된다.

Timer

• Timer는 좀 특별한 메트릭 측정 도구인데, 시간을 측정하는데 사용된다.
  • 카운터와 유사한데, Timer 를 사용하면 실행 시간도 함께 측정할 수 있다.
  • Timer 는 다음과 같은 내용을 한번에 측정해준다.
    • seconds_count : 누적 실행 수 - 카운터
    • seconds_sum : 실행 시간의 합 - sum
    • seconds_max : 최대 실행 시간(가장 오래걸린 실행 시간) - 게이지
      • 내부에 타임 윈도우라는 개념이 있어서 1~3분 마다 최대 실행 시간이 다시 계산된다.
    • seconds_sum / seconds_count = 평균 실행시간

Tag, 레이블

• Tag를 사용하면 데이터를 나누어서 확인할 수 있다.
• Tag는 카디널리티가 낮으면서 그룹화 할 수 있는 단위에 사용해야 한다.
  • 예) 성별, 주문 상태, 결제 수단[신용카드, 현금] 등등
• 카디널리티가 높으면 안된다. 예) 주문번호, PK 같은 것