Spring Boot 記錄請求響應日志的常用手段

作者：碼農小胖哥 2021-08-11 05:00:48

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

[[416714]]

請求追蹤的實現方式

網關層

很多網關設施都具有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格式呈現：

Spring Boot Actuator記錄的httptrace

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

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

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

一次請求會輸出兩次日志，一次是在第一次經過過濾器前;一次是完成過濾器鏈后。

CommonsRequestLoggingFilter記錄請求日志

這里多說一句其實可以改造成輸出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"}

總結

今天介紹了不少記錄追蹤接口請求響應的方法，總有一款適合你。

本文轉載自微信公眾號「碼農小胖哥」，可以通過以下二維碼關注。轉載本文請聯系碼農小胖哥公眾號。

責任編輯：武曉燕來源：碼農小胖哥

Spring 日志手段