如何追蹤Spring MVC接口的請求響應

某些業務需求需要追蹤我們的接口訪問情況，也就是把請求和響應記錄下來。基本的記錄維度包含了請求入參（路徑query參數，請求體）、請求路徑（uri）、請求方法(method)、請求頭（headers）以及響應狀態、響應頭、甚至包含了敏感的響應體等等。今天總結了幾種方法，你可以按需選擇。

請求追蹤的實現方式

網關層

很多網關設施都具有httptrace的功能，可以幫助我們集中記錄請求流量的情況。Orange、Kong、Apache Apisix這些基於Nginx的網關都具有該能力，就連Nginx本身也提供了記錄httptrace日誌的能力。

優點是可以集中的管理httptrace日誌，免開發；缺點是技術要求高，需要配套的分發、存儲、查詢的設施。

Spring Boot Actuator

在Spring Boot中，其實提供了簡單的追蹤功能。你只需要集成：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

開啓/actuator/httptrace：

management:
  endpoints:
    web:
      exposure:
        include: 'httptrace'

就可以通過http://server:port/actuator/httptrace獲取最近的Http請求信息了。

不過在最新的版本中可能需要顯式的聲明這些追蹤信息的存儲方式，也就是實現HttpTraceRepository接口並注入Spring IoC。

例如放在內存中並限制爲最近的100條（不推薦生產使用）：

@Bean
public HttpTraceRepository httpTraceRepository(){
    return new InMemoryHttpTraceRepository();
}

追蹤日誌以json格式呈現：

記錄的維度不多，當然如果夠用的話可以試試。

優點在於集成起來簡單，幾乎免除開發；缺點在於記錄的維度不多，而且需要搭建緩衝消費這些日誌信息的設施。

CommonsRequestLoggingFilter

Spring Web模塊還提供了一個過濾器CommonsRequestLoggingFilter，它可以對請求的細節進行日誌輸出。配置起來也比較簡單：

@Bean
CommonsRequestLoggingFilter  loggingFilter(){
    CommonsRequestLoggingFilter loggingFilter = new CommonsRequestLoggingFilter();
    // 記錄 客戶端 IP信息
    loggingFilter.setIncludeClientInfo(true);
    // 記錄請求頭
    loggingFilter.setIncludeHeaders(true);
    // 如果記錄請求頭的話，可以指定哪些記錄，哪些不記錄
    // loggingFilter.setHeaderPredicate();
    // 記錄 請求體  特別是POST請求的body參數
    loggingFilter.setIncludePayload(true);
    // 請求體的大小限制 默認50
    loggingFilter.setMaxPayloadLength(10000);
    //記錄請求路徑中的query參數 
    loggingFilter.setIncludeQueryString(true);
    return loggingFilter;
}

而且必須開啓對CommonsRequestLoggingFilter的debug日誌：

logging:
  level:
    org:
      springframework:
        web:
          filter:
            CommonsRequestLoggingFilter: debug

一次請求會輸出兩次日誌，一次是在第一次經過過濾器前；一次是完成過濾器鏈後。

這裏多說一句其實可以改造成輸出json格式的。

優點是靈活配置、而且對請求追蹤的維度全面，缺點是隻記錄請求而不記錄響應。

ResponseBodyAdvice

Spring Boot統一返回體其實也能記錄，需要自行實現。這裏借鑑了CommonsRequestLoggingFilter解析請求的方法。響應體也可以獲取了，不過響應頭和狀態因爲生命週期還不清楚，這裏獲取還不清楚是否合適，不過這是一個思路。

/**
 * @author felord.cn
 * @since 1.0.8.RELEASE
 */
@Slf4j
@RestControllerAdvice(basePackages = {"cn.felord.logging"})
public class RestBodyAdvice implements ResponseBodyAdvice<Object> {
    private static final int DEFAULT_MAX_PAYLOAD_LENGTH = 10000;
    public static final String REQUEST_MESSAGE_PREFIX = "Request [";
    public static final String REQUEST_MESSAGE_SUFFIX = "]";
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body,
                                  MethodParameter returnType,
                                  MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                  ServerHttpRequest request,
                                  ServerHttpResponse response) {

        ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) request;

        log.debug(createRequestMessage(servletServerHttpRequest.getServletRequest(), REQUEST_MESSAGE_PREFIX, REQUEST_MESSAGE_SUFFIX));
        Rest<Object> objectRest;
        if (body == null) {
            objectRest = RestBody.okData(Collections.emptyMap());
        } else if (Rest.class.isAssignableFrom(body.getClass())) {
            objectRest = (Rest<Object>) body;
        }
        else if (checkPrimitive(body)) {
            return RestBody.okData(Collections.singletonMap("result", body));
        }else {
            objectRest = RestBody.okData(body);
        }
        log.debug("Response Body ["+ objectMapper.writeValueAsString(objectRest) +"]");
        return objectRest;
    }


    private boolean checkPrimitive(Object body) {
        Class<?> clazz = body.getClass();
        return clazz.isPrimitive()
                || clazz.isArray()
                || Collection.class.isAssignableFrom(clazz)
                || body instanceof Number
                || body instanceof Boolean
                || body instanceof Character
                || body instanceof String;
    }


    protected String createRequestMessage(HttpServletRequest request, String prefix, String suffix) {
        StringBuilder msg = new StringBuilder();
        msg.append(prefix);
        msg.append(request.getMethod()).append(" ");
        msg.append(request.getRequestURI());


        String queryString = request.getQueryString();
        if (queryString != null) {
            msg.append('?').append(queryString);
        }


        String client = request.getRemoteAddr();
        if (StringUtils.hasLength(client)) {
            msg.append(", client=").append(client);
        }
        HttpSession session = request.getSession(false);
        if (session != null) {
            msg.append(", session=").append(session.getId());
        }
        String user = request.getRemoteUser();
        if (user != null) {
            msg.append(", user=").append(user);
        }

        HttpHeaders headers = new ServletServerHttpRequest(request).getHeaders();
        msg.append(", headers=").append(headers);

        String payload = getMessagePayload(request);
        if (payload != null) {
            msg.append(", payload=").append(payload);
        }

        msg.append(suffix);
        return msg.toString();
    }

    protected String getMessagePayload(HttpServletRequest request) {
        ContentCachingRequestWrapper wrapper =
                WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class);
        if (wrapper != null) {
            byte[] buf = wrapper.getContentAsByteArray();
            if (buf.length > 0) {
                int length = Math.min(buf.length, DEFAULT_MAX_PAYLOAD_LENGTH);
                try {
                    return new String(buf, 0, length, wrapper.getCharacterEncoding());
                } catch (UnsupportedEncodingException ex) {
                    return "[unknown]";
                }
            }
        }
        return null;
    }
}

別忘記配置ResponseBodyAdvice的logging級別爲DEBUG。

logstash-logback-encoder

這個是logstash的logback編碼器，可以結構化輸出httptrace爲json。引入：

<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>6.6</version>
</dependency>

在logback的配置中增加一個ConsoleAppender爲LogstashEncoder:

<configuration>
    <appender name="jsonConsoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="net.logstash.logback.encoder.LogstashEncoder"/>
    </appender>
    <root level=" INFO">
        <appender-ref ref="jsonConsoleAppender"/>
    </root>
</configuration>

然後同樣實現一個解析的Filter:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;

/**
 * @author felord.cn
 * @since 1.0.8.RELEASE
 */
@Order(1)
@Component
public class MDCFilter implements Filter {

    private final Logger LOGGER = LoggerFactory.getLogger(MDCFilter.class);
    private final String X_REQUEST_ID = "X-Request-ID";

    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;
        try {
            addXRequestId(req);
            LOGGER.info("path: {}, method: {}, query {}",
                    req.getRequestURI(), req.getMethod(), req.getQueryString());
            res.setHeader(X_REQUEST_ID, MDC.get(X_REQUEST_ID));
            chain.doFilter(request, response);
        } finally {
            LOGGER.info("statusCode {}, path: {}, method: {}, query {}",
                    res.getStatus(), req.getRequestURI(), req.getMethod(), req.getQueryString());
            MDC.clear();
        }
    }

    private void addXRequestId(HttpServletRequest request) {
        String xRequestId = request.getHeader(X_REQUEST_ID);
        if (xRequestId == null) {
            MDC.put(X_REQUEST_ID, UUID.randomUUID().toString());
        } else {
            MDC.put(X_REQUEST_ID, xRequestId);
        }
    }

}

這裏解析方式其實還可以更加精細一些。

不但可以記錄接口請求日誌，還可以結構化爲json：

{"@timestamp":"2021-08-10T23:48:51.322+08:00","@version":"1","message":"statusCode 200, path: /log/get, method: GET, query foo=xxx&bar=ooo","logger_name":"cn.felord.logging.MDCFilter","thread_name":"http-nio-8080-exec-1","level":"INFO","level_value":20000,"X-Request-ID":"7c0db56c-b1f2-4d85-ad9a-7ead67660f96"}

總結

今天介紹了不少記錄追蹤接口請求響應的方法，相對都比較簡單，如果你的項目做大了可能就要用到鏈路追蹤，以後有機會了再補這個坑。當然或許你有更好的方式，歡迎留言分享。

關注公衆號：Felordcn獲取更多資訊

個人博客：https://felord.cn