Mini-challenge: trace 1 request từ main() và log mọi bean tạo

package com.olhub.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

package com.olhub.demo.model;

import java.math.BigDecimal;

public record Order(Long id, String customer, BigDecimal total) {}

package com.olhub.demo.model;

import java.math.BigDecimal;

public record OrderDto(Long id, String customer, BigDecimal total) {
    public static OrderDto from(Order o) {
        return new OrderDto(o.id(), o.customer(), o.total());
    }
}

package com.olhub.demo.repository;

import com.olhub.demo.model.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;

import java.math.BigDecimal;
import java.util.Map;
import java.util.Optional;

@Slf4j
@Repository
public class OrderRepository {

    private final Map<Long, Order> data = Map.of(
        42L, new Order(42L, "Alice", new BigDecimal("99.99")),
        43L, new Order(43L, "Bob", new BigDecimal("149.50"))
    );

    public Optional<Order> queryById(Long id) {
        long start = System.currentTimeMillis();
        log.debug("queryById({})", id);
        Optional<Order> result = Optional.ofNullable(data.get(id));
        long elapsed = System.currentTimeMillis() - start;
        result.ifPresent(o -> log.info("found Order#{} in {}ms", o.id(), elapsed));
        return result;
    }
}

package com.olhub.demo.service;

import com.olhub.demo.model.OrderDto;
import com.olhub.demo.repository.OrderRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Slf4j
@Service
public class OrderService {

    private final OrderRepository repo;

    public OrderService(OrderRepository repo) {
        this.repo = repo;
    }

    public Optional<OrderDto> findById(Long id) {
        long start = System.currentTimeMillis();
        log.info("findById({})", id);
        Optional<OrderDto> dto = repo.queryById(id).map(OrderDto::from);
        long elapsed = System.currentTimeMillis() - start;
        log.info("returned OrderDto in {}ms", elapsed);
        return dto;
    }
}

package com.olhub.demo.controller;

import com.olhub.demo.model.OrderDto;
import com.olhub.demo.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService service;

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

    @GetMapping("/{id}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable Long id) {
        long start = System.currentTimeMillis();
        log.info("getOrder({})", id);

        ResponseEntity<OrderDto> response = service.findById(id)
            .map(ResponseEntity::ok)
            .orElseGet(() -> ResponseEntity.notFound().build());

        long elapsed = System.currentTimeMillis() - start;
        log.info("{} in {}ms", response.getStatusCode().value(), elapsed);
        return response;
    }
}

package com.olhub.demo.config;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.UUID;

@Slf4j
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class LoggingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpReq = (HttpServletRequest) req;
        HttpServletResponse httpRes = (HttpServletResponse) res;

        String requestId = httpReq.getHeader("X-Request-Id");
        if (requestId == null) {
            requestId = UUID.randomUUID().toString().substring(0, 8);
        }

        long start = System.currentTimeMillis();

        try (MDC.MDCCloseable mdc = MDC.putCloseable("requestId", requestId)) {
            log.info(">>> {} {}", httpReq.getMethod(), httpReq.getRequestURI());
            httpRes.setHeader("X-Request-Id", requestId);

            chain.doFilter(req, res);

            long elapsed = System.currentTimeMillis() - start;
            log.info("<<< {} in {}ms", httpRes.getStatus(), elapsed);
        }
    }
}

package com.olhub.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class BeanCreationLogger implements BeanPostProcessor {

    private static final String APP_PACKAGE = "com.olhub.demo";

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        String className = bean.getClass().getName();
        if (className.startsWith(APP_PACKAGE)) {
            log.info("Created bean: {} ({})", beanName, className);
        }
        // Bo qua bean infrastructure cua Spring/Boot
        return bean;
    }
}

server:
  port: 8080

spring:
  application:
    name: trace-demo

logging:
  level:
    root: INFO
    com.olhub.demo: DEBUG
    com.olhub.demo.config.BeanCreationLogger: INFO
  pattern:
    console: "%d{HH:mm:ss.SSS} [%thread] %-5level [%X{requestId:-no-req}] %logger{30} : %msg%n"

management:
  endpoints:
    web:
      exposure:
        include: health, info, beans, conditions, mappings, loggers