一、MDC日志定位

1、概述

1.1 简介

MDC是可以帮组我们 在多线程条件下记录追踪日志的功能，它支持 Log4J和LogBack 两种日志框架通常打印出的日志会有线程号等信息来标志当前日志属于哪个线程，然而由于线程是可以重复使用的，所以并不能很清晰的确认一个请求的日志范围。处理这种情况一般有两种处理方式：

• 手动生成一个唯一序列号打印在日志中；
• 使用日志控件提供的MDC功能，生成一个唯一序列标记一个线程的日志

在现网出现故障时，我们经常需要获取一次请求流程里的所有日志进行定位。如果请求只在一个线程里处理，则我们可以通过线程ID来过滤日志，但同时如果请求包含异步线程的处理，那么光靠线程ID就显得捉襟见肘了，这也是需要解决的一个问题

1.2 MDC原理

MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。对于一个 Web 应用来说，通常是在请求被处理的最开始保存这些数据。

如果是微服务之间的调用，则需要上层服务在 header 中添加标识同请求一起传输过来。下层服务直接使用上层服务的标识，就可以将日志串联起来

2、MDC入门

2.1 配置日志文件

在resources下配置logback.xml，设置输出格式，默认是不会输出的

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
        <!--<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{trace_id}] [%level] [%thread] [%class:%line] - %m%n</pattern>-->
            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [requestId=%X{requestId}] %-5level %logger{50} - %msg%n</Pattern>
        </layout>
    </appender>
    <root level="debug">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

2.2 基础入门

SLF4J日志框架提供了一个MDC(Mapped Diagnostic Contexts)工具类，谷歌翻译为映射的诊断上下文，从字面上很难理解，我们可以先实战一把。

public class Main {

    private static final String KEY = "requestId";
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    
    public static void main(String[] args) {

        // 入口传入请求ID
        MDC.put(KEY, UUID.randomUUID().toString());
        
        // 打印日志
        logger.debug("log in main thread 1");
        logger.debug("log in main thread 2");
        logger.debug("log in main thread 3");

        // 出口移除请求ID
        MDC.remove(KEY);

    }

}

我们在main函数的入口调用MDC.put()方法传入请求ID，在出口调用MDC.remove()方法移除请求ID。配置好log4j2.xml文件后，运行main函数，可以在控制台看到以下日志输出：

2023-03-04 20:37:05.572 [main] [requestId=dab8412a-f070-4406-9940-89fcdbd3473f] DEBUG com.example.mdc.mdc.Main - log in main thread 1
2023-03-04 20:37:05.572 [main] [requestId=dab8412a-f070-4406-9940-89fcdbd3473f] DEBUG com.example.mdc.mdc.Main - log in main thread 2
2023-03-04 20:37:05.572 [main] [requestId=dab8412a-f070-4406-9940-89fcdbd3473f] DEBUG com.example.mdc.mdc.Main - log in main thread 3

从日志中可以明显地看到花括号中包含了（映射的）请求ID(requestId)，这其实就是我们定位（诊断）问题的关键字（上下文）。有了MDC工具，只要在接口或切面植入put()和remove()代码，在现网定位问题时，我们就可以通过grep requestId=xxx *.log快速的过滤出某次请求的所有日志。

2.3 进阶提升

然而，MDC工具真的有我们所想的这么方便吗？回到我们开头，一次请求可能涉及多线程异步处理，那么在多线程异步的场景下，它是否还能正常运作呢？Talk is cheap, show me the code。

public class Main {

    private static final String KEY = "requestId";
    private static final Logger logger = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {

        // 入口传入请求ID
        MDC.put(KEY, UUID.randomUUID().toString());

        // 主线程打印日志
        logger.debug("log in main thread");

        // 异步线程打印日志
        new Thread(new Runnable() {
            @Override
            public void run() {
                logger.debug("log in other thread");
            }
        }).start();

        // 出口移除请求ID
        MDC.remove(KEY);
    }
}

代码里我们新起了一个异步线程，并在匿名对象Runnable的run()方法打印日志。运行main函数，可以在控制台看到以下日志输出

2023-03-04 20:38:06.594 [main] [requestId=bfbf71b4-2201-4558-b049-f613759eb88e] DEBUG com.example.mdc.mdc.Main - log in main thread
2023-03-04 20:38:06.595 [Thread-0] [requestId=] DEBUG com.example.mdc.mdc.Main - log in other thread

不幸的是，请求ID在异步线程里不打印了。这是怎么回事呢？要解决这个问题，我们就得知道MDC的实现原理。MDC之所以在异步线程中不生效是因为底层采用ThreadLocal作为数据结构，我们调用MDC.put()方法传入的请求ID只在当前线程有效。

知道了原理那么解决这个问题就轻而易举了，我们可以使用装饰器模式，新写一个MDCRunnable类对Runnable接口进行一层装饰。在创建MDCRunnable类时保存当前线程的MDC值，在执行run()方法时再将保存的MDC值拷贝到异步线程中去。

public class MDCRunnable implements Runnable {

    private final Runnable runnable;

    private final Map<String, String> map;

    public MDCRunnable(Runnable runnable) {
        this.runnable = runnable;
        // 保存当前线程的MDC值
        this.map = MDC.getCopyOfContextMap();
    }

    @Override
    public void run() {
        // 传入已保存的MDC值
        for (Map.Entry<String, String> entry : map.entrySet()) {
            MDC.put(entry.getKey(), entry.getValue());
        }
        // 装饰器模式，执行run方法
        runnable.run();
        // 移除已保存的MDC值
        for (Map.Entry<String, String> entry : map.entrySet()) {
            MDC.remove(entry.getKey());
        }
    }
    
}

接着，我们需要对main函数里创建的Runnable实现类进行装饰

public class Main {

    private static final String KEY = "requestId";
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static final ExecutorService EXECUTOR = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {

        // 入口传入请求ID
        MDC.put(KEY, UUID.randomUUID().toString());

        // 主线程打印日志
        logger.debug("log in main thread");

        // 异步线程打印日志，用MDCRunnable装饰Runnable
        new Thread(new MDCRunnable(new Runnable() {
            @Override
            public void run() {
                logger.debug("log in other thread");
            }
        })).start();

        // 异步线程池打印日志，用MDCRunnable装饰Runnable
        EXECUTOR.execute(new MDCRunnable(new Runnable() {
            @Override
            public void run() {
                logger.debug("log in other thread pool");
            }
        }));
        EXECUTOR.shutdown();

        // 出口移除请求ID
        MDC.remove(KEY);

    }

}

执行main函数，将会输出以下日志，可以发现多线程也请求同一个requestId了

2023-03-04 20:41:16.255 [main] [requestId=6bc1ffaa-379f-489c-8f12-59dba843472d] DEBUG com.example.mdc.mdc.Main - log in main thread
2023-03-04 20:41:16.256 [Thread-0] [requestId=6bc1ffaa-379f-489c-8f12-59dba843472d] DEBUG com.example.mdc.mdc.Main - log in other thread
2023-03-04 20:41:16.256 [pool-1-thread-1] [requestId=6bc1ffaa-379f-489c-8f12-59dba843472d] DEBUG com.example.mdc.mdc.Main - log in other thread pool

3、MDC+Spring

对于一个 Spring 应用来说，我们想一下 Http 请求到达我们具体接口的时候，是不是还有 拦截器 HandlerInterceptor 和 过滤器 Filter 这两个，所以我们 把在 装有唯一序列标记的 MDC，就可以放这两个里面MDC.put("RequestId", UUID.randomUUID().toString());

我们可以让前端调用后端接口的时候，在 Header 里面生成一个唯一的字符串作为我们放 MDC的 RequestId

3.1 拦截器方式

public class WebLogMdcHandlerInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        MDC.put("RequestId", UUID.randomUUID().toString());
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        MDC.clear();
    }

    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request,
                                               HttpServletResponse response, Object handler) throws Exception {
        preHandle(request, response, handler);
    }
}

3.2 过滤器方式

@Component
public class MDCFilter implements Filter {

    private static final String REQUEST_ID_HEADER = "RequestId";
    private static final String REQUEST_ID = "RequestId";
    private static final String ProcessId_ID = "processId";

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        String requestId = httpRequest.getHeader(REQUEST_ID_HEADER);
        if (requestId == null) {
            requestId = UUID.randomUUID().toString();
        }
        MDC.put(REQUEST_ID, requestId);
        httpResponse.setHeader(REQUEST_ID_HEADER, requestId);
        int processId = getProcessID();
        MDC.put(ProcessId_ID, String.valueOf(processId));
        try {
            chain.doFilter(request, response);
        } finally {
            MDC.clear();
        }
    }

    @Override
    public void destroy() {
    }

    public static final int getProcessID() {
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        return Integer.valueOf(runtimeMXBean.getName().split("@")[0])
                .intValue();
    }
}

3.3 日志配置

在日志上下文增加参数，在日志中可以打印该参数，如RequestId，则日志配置：%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{RequestId}] [%thread] %-5level %logger{36} - %msg%n则 RequestId 会打印在中括号里，%X{参数名} 是格式

这里提供另一种配置方式，仅供参考，建议还是单独配置logback.xml

Configuration:
  Appenders:
    Console:  # 输出到控制台
      name: CONSOLE
      target: SYSTEM_OUT
      ThresholdFilter:
        level: ${sys:log.level.console} 
        onMatch: ACCEPT
        onMismatch: DENY
      PatternLayout:
        pattern: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{RequestId}] [%thread] [%-5level] [%logger:%L] [%m] %n"
    RollingFile: # 输出到文件，超过128MB归档
      - name: ROLLING_FILE
        ignoreExceptions: false
        fileName: ${log.path}/${}/default.log
        filePattern: "${log.path}/$${date:yyyy-MM}/${}/default-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          pattern: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{RequestId}] [%thread] [%-5level] [%logger:%L] [%m] %n"
        Policies:
          SizeBasedTriggeringPolicy:
            size: "128 MB"
        DefaultRolloverStrategy:
          max: 1000