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

[YONGHYNG]

그라파나 - 메트릭을 통한 문제 확인

• 애플리케이션에 문제가 발생했을 때 그라파나를 통해서 어떻게 모니터링 하는지 확인해보자.
• 실제 우리가 작성한 애플리케이션에 직접 문제를 발생시킨 다음에 그라파나를 통해서 문제를 어떻게 모니터링 할 수 있는지 확인해보자.
• 실무에서 주로 많이 발생하는 다음 4가지 대표적인 예시를 확인해보자.
  • CPU 사용량 초과
  • JVM 메모리 사용량 초과
  • 커넥션 풀 고갈
  • 에러 로그 급증

CPU 사용량 초과

TrafficController - cpu() 추가

package hello.controller;

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

@Slf4j
@RestController
public class TrafficController {

    @GetMapping("/cpu")
    public String cpu() {
        log.info("cpu");
        long value = 0;
        for (long i = 0; i < 10000000000L; i++) {
            value++;
        }
        return "ok value=" + value;
    }
}

• 각자 컴퓨터 성능에 따라서 루프 횟수를 바꾸어야 할 수 있다.

실행

http://localhost:8080/cpu
(여러 번 요청하고 JVM 메모리 사용량을 확인하자)

결과

대시보드를 확인해보면 CPU 사용량이 증가하는 것을 확인할 수 있다. 아마 요청 하나당 코어 하나를 100% 사용할 것이다. 더 많이 요청하면 더 많은 CPU를 사용한다.

JVM 메모리 사용량 초과

TrafficController - jvm() 추가

    private List<String> list = new ArrayList<>();

    @GetMapping("/jvm")
    public String jvm() {
        log.info("jvm");
        for(int i = 0; i < 1000000; i++) {
            list.add("hello jvm!" + i);
        }
        return "ok";
    }

실행

http://localhost:8080/jvm
(여러 번 요청하고 JVM 메모리 사용량을 확인하자)

결과

계속 요청하면서 대시보드를 확인해보면 JVM 메모리 사용량이 계속 증가하다가 최대치를 넘는 순간 메트릭이 잡히지 않는다.
JVM 내부에서 OOM이 발생했기 때문이다.
기다려보면 애플리케이션 로그에서 다음과 같은 오류를 확인할 수 있다.
java.lang.OutOfMemoryError: Java heap space

커넥션 풀 고갈

TrafficController - jdbc() 추가

@Autowired
    DataSource dataSource;

    @GetMapping("/jdbc")
    public String jdbc() throws SQLException {
        log.info("jdbc");
        Connection conn = dataSource.getConnection();
        log.info("connection info={}", conn);
        //conn.close(); //커넥션을 닫지 않는다.
        return "ok";
    }

실행
http://localhost:8080/jdbc
(10번 이상 실행하자)

결과

Active 커넥션이 커넥션 풀의 최대 숫자인 10개를 넘어가게 되면, 커넥션을 획득하기 위해 대기(Pending)하게 된다.
그래서 커넥션 획득 부분에서 쓰레드가 대기하게 되고 결과적으로 HTTP 요청을 응답하지 못한다.

DB 커넥션을 획득하기 위해 대기하던 톰캣 쓰레드가 30초 이상 DB 커넥션을 획득하지 못하면 다음과 같은 예외가 발생하면서 커넥션 획득을 포기한다.
Connection is not available, request timed out after 30004ms.

에러 로그 급증

애플리케이션에서 ERROR 레벨의 로그가 급증한다면 심각한 문제가 발생한 것으로 이해할 수 있다.

TrafficController - errorLog() 추가

  @GetMapping("/error-log")
    public String errorLog() {
        log.error("error log");
        return "error";
    }

실행

http://localhost:8080/error-log
(여러번 실행하자)

결과

ERROR Logs , logback_events_total 메트릭에서 ERROR 로그가 급증하는 것을 확인할 수 있다.

메트릭 등록 - 예제 만들기

• 앞서 보았듯이 CPU 사용량, 메모리 사용량, 톰캣 쓰레드, DB 커넥션 풀과 같이 공통으로 사용되는 기술 메트릭은 이미 등록되어 있다. 우리는 이런 이미 등록된 메트릭을 사용해서 대시보드를 구성하고 모니터링 하면 된다.
• 여기서 더 나아가서 비즈니스에 특화된 부분을 모니터링 하고 싶으면 어떻게 해야할까? 예를 들어서 주문수, 취소수, 재고 수량 같은 메트릭 들이 있다. 이 부분은 공통으로 만들 수 있는 부분은 아니고, 각각의 비즈니스에 특화된 부분들이다.
• 이런 메트릭들도 시스템을 운영하는데 상당히 도움이 된다. 예를 들어서 취소수가 갑자기 급증하거나 재고 수량이 임계치 이상으로 쌓이는 부분들은 기술적인 메트릭으로 확인할 수 없는 우리 시스템의 비즈니스 문제를 빠르게 파악하는데 도움을 준다.
• 예를 들어서 택배회사에 문제가 생겨서 고객들이 많이 기다리다가 지쳐서 취소수가 증가해도 CPU, 메모리 사용량 같은 시스템 메트릭에는 아무런 문제가 발생하지 않는다. 이럴 때 비즈니스 메트릭이 있으면 이런 문제를 빠르게 인지할 수 있다.
• 비즈니스에 관한 부분은 각 비즈니스 마다 구현이 다르다. 따라서 비즈니스 메트릭은 직접 등록하고 확인해야 한다.
  여기서는 우리 비즈니스의 실시간 주문수, 취소수 또 실시간 재고 수량을 메트릭으로 등록하고 확인해보자. 각각의 메트릭은 다음과 같이 정의했다.

주문수, 취소수

• 상품을 주문하면 주문수가 증가한다.
• 상품을 취소해도 주문수는 유지한다. 대신에 취소수를 증가한다.

재고 수량

• 상품을 주문하면 재고 수량이 감소한다.
• 상품을 취소하면 재고 수량이 증가한다.
• 재고 물량이 들어오면 재고 수량이 증가한다.
• 주문수, 취소수는 계속 증가하므로 카운터를 사용하자.
• 재고 수량은 증가하거나 감소하므로 게이지를 사용하자.

OrderService

package hello.order;

import java.util.concurrent.atomic.AtomicInteger;

//주문, 취소, 재고 수량을 확인할 수 있는 주문 서비스 인터페이스이다.
public interface OrderService {
    void order();
    void cancel();

    AtomicInteger getStock();
}

OrderService

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 {
    //new AtomicInteger(100) 초기값을 100으로 설정해둔다. 재고 수량이 100부터 시작한다고 가정한다.
    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;
    }
}

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 {
    //앞서 만든 OrderService 빈을 직접 등록하는 설정이다.
    @Bean
    OrderService orderService() {
        return new OrderServiceV0();
    }

}

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
//주문, 취소, 재고 수량을 확인하는 컨트롤러이다.
//참고: 예제의 단순함을 위해서 GET 을 사용했습니다.
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();
    }
}

메트릭 등록1 - 카운터

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

MeterRegistry

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

Counter(카운터)

• https://prometheus.io/docs/concepts/metric_types/#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 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 hello.order.v0.OrderConfigV0;
import hello.order.v1.OrderConfigV1;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;

//@Import(OrderConfigV0.class)
@Import(OrderConfigV1.class)
@SpringBootApplication
public class AutoConfigApplication {

    public static void main(String[] args) {
        SpringApplication.run(AutoConfigApplication.class, args);
    }

}

- 메트릭을 확인해보면 method로 구분할 수 있다.

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

• 메트릭 이름이 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
    private 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 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(MeterRegistyry registry) {
        return new CountedAspect(registry);
    }
}

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

ActuatorApplication - 변경

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

• OrderConfigV1 OrderConfigV2 이 실행되도록 변경한다.

{
 "name": "my.order",
 "measurements": [
 {
 "statistic": "COUNT",
 "value": 5
 }
 ],
 "availableTags": [
 {
 "tag": "result",
 "values": [
 "success"
 ]
 },
 {
 "tag": "exception",
 "values": [
 "none"
 ]
 },
 {
 "tag": "method",
 "values": [ "cancel",
 "order"
 ]
 },
 {
 "tag": "class",
 "values": [
 "hello.order.v2.OrderServiceV2"
 ]
 }
 ]
}