原文連結：https://piotrminkowski.wordpress.com/2019/05/07/logging-with-spring-boot-and-elastic-stack/

作者： PiotrMińkowski

譯者：Yunooa

 

在本文中，我將介紹我的日誌庫，專門用於Spring Boot RESTful Web應用程式。關於這個庫的主要設想是：

• 使用完整正文記錄所有傳入的HTTP請求和傳出的HTTP響應
• 使用logstash-logback-encoder庫和Logstash與Elastic Stack整合
• 對於RestTemplate``和OpenFeign
  ,記錄所有可能發生的日誌
• 在單個API端點呼叫中跨所有通訊生成和傳遞關聯Id(correlationId)
• 計算和儲存每個請求的執行時間
• 可自動配置的庫——除了引入依賴項之外，不必執行任何操作，就能正常工作

1.簡述

我想在閱讀了文章的前言後，你可能會問為什麼我決定構建一個Spring Boot已有功能的庫。但問題是它真的具有這些功能？你可能會感到驚訝，因為答案是否定的。雖然可以使用一些內建的Spring元件例如CommonsRequestLoggingFilter輕鬆地記錄HTTP請求，但是沒有任何用於記錄響應主體(response body)的開箱即用機制。當然你可以基於Spring HTTP攔截器（HandlerInterceptorAdapter）或過濾器（OncePerRequestFilter）實現自定義解決方案，但這並沒有你想的那麼簡單。第二種選擇是使用Zalando Logbook

，它是一個可擴充套件的Java庫，可以為不同的客戶端和伺服器端技術啟用完整的請求和響應日誌記錄。這是一個非常有趣的庫，專門用於記錄HTTP請求和響應，它提供了許多自定義選項並支援不同的客戶端。因此，為了更高階， 你可以始終使用此庫。
我的目標是建立一個簡單的庫，它不僅記錄請求和響應，還提供自動配置，以便將這些日誌傳送到Logstash並關聯它們。它還會自動生成一些有價值的統計資訊，例如請求處理時間。所有這些值都應該傳送到Logstash。我們繼續往下看。

2.實現

從依賴開始吧。我們需要一些基本的Spring庫，它們包含spring-web，spring-context在內,並提供了一些額外的註解。為了與Logstash

整合，我們使用logstash-logback-encoder庫。Slf4j包含用於日誌記錄的抽象，而javax.servlet-api用於HTTP通訊。Commons IO不是必需的，但它提供了一些操作輸入和輸出流的有用方法。

<properties>
    <java.version>11</java.version>
    <commons-io.version>2.6</commons-io.version>
    <javax-servlet.version>4.0.1</javax-servlet.version>
    <logstash-logback.version>5.3</logstash-logback.version>
    <spring.version>5.1.6.RELEASE</spring.version>
    <slf4j.version>1.7.26</slf4j.version></properties><dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>net.logstash.logback</groupId>
        <artifactId>logstash-logback-encoder</artifactId>
        <version>${logstash-logback.version}</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>${javax-servlet.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>${commons-io.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency></dependencies>

第一步是實現HTTP請求和響應包裝器。我們必須這樣做，因為無法讀取HTTP流兩次。如果想記錄請求或響應正文，在處理輸入流或將其返回給客戶端之前，首先必須讀取輸入流。Spring提供了HTTP請求和響應包裝器的實現，但由於未知原因，它們僅支援某些特定用例，如內容型別application/x-www-form-urlencoded。因為我們通常在RESTful應用程式之間的通訊中使用aplication/json內容型別，所以Spring ContentCachingRequestWrapper和ContentCachingResponseWrapper在這沒什麼用。
這是我的HTTP請求包裝器的實現，可以通過各種方式完成。這只是其中之一：

public class SpringRequestWrapper extends HttpServletRequestWrapper {

    private byte[] body;

    public SpringRequestWrapper(HttpServletRequest request) {
        super(request);
        try {
            body = IOUtils.toByteArray(request.getInputStream());
        } catch (IOException ex) {
            body = new byte[0];
        }
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return new ServletInputStream() {
            public boolean isFinished() {
                return false;
            }

            public boolean isReady() {
                return true;
            }

            public void setReadListener(ReadListener readListener) {

            }

            ByteArrayInputStream byteArray = new ByteArrayInputStream(body);

            @Override
            public int read() throws IOException {
                return byteArray.read();
            }
        };
    }
}

輸出流必須做同樣的事情，這個實現有點複雜：

public class SpringResponseWrapper extends HttpServletResponseWrapper {

    private ServletOutputStream outputStream;
    private PrintWriter writer;
    private ServletOutputStreamWrapper copier;

    public SpringResponseWrapper(HttpServletResponse response) throws IOException {
        super(response);
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        if (writer != null) {
            throw new IllegalStateException("getWriter() has already been called on this response.");
        }

        if (outputStream == null) {
            outputStream = getResponse().getOutputStream();
            copier = new ServletOutputStreamWrapper(outputStream);
        }

        return copier;
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        if (outputStream != null) {
            throw new IllegalStateException("getOutputStream() has already been called on this response.");
        }

        if (writer == null) {
            copier = new ServletOutputStreamWrapper(getResponse().getOutputStream());
            writer = new PrintWriter(new OutputStreamWriter(copier, getResponse().getCharacterEncoding()), true);
        }

        return writer;
    }

    @Override
    public void flushBuffer() throws IOException {
        if (writer != null) {
            writer.flush();
        }
        else if (outputStream != null) {
            copier.flush();
        }
    }

    public byte[] getContentAsByteArray() {
        if (copier != null) {
            return copier.getCopy();
        }
        else {
            return new byte[0];
        }
    }

}

我將ServletOutputStream包裝器實現放到另一個類中：

public class ServletOutputStreamWrapper extends ServletOutputStream {

    private OutputStream outputStream;
    private ByteArrayOutputStream copy;

    public ServletOutputStreamWrapper(OutputStream outputStream) {
        this.outputStream = outputStream;
        this.copy = new ByteArrayOutputStream();
    }

    @Override
    public void write(int b) throws IOException {
        outputStream.write(b);
        copy.write(b);
    }

    public byte[] getCopy() {
        return copy.toByteArray();
    }

    @Override
    public boolean isReady() {
        return true;
    }

    @Override
    public void setWriteListener(WriteListener writeListener) {

    }
}

因為我們需要在處理之前包裝HTTP請求流和響應流，所以我們應該使用HTTP過濾器。Spring提供了自己的HTTP過濾器實現。我們的過濾器擴充套件了它，並使用自定義請求和響應包裝來記錄有效負載。此外，它還生成和設定X-Request-ID，X-Correlation-ID header和請求處理時間。

public class SpringLoggingFilter extends OncePerRequestFilter {

    private static final Logger LOGGER = LoggerFactory.getLogger(SpringLoggingFilter.class);
    private UniqueIDGenerator generator;

    public SpringLoggingFilter(UniqueIDGenerator generator) {
        this.generator = generator;
    }

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        generator.generateAndSetMDC(request);
        final long startTime = System.currentTimeMillis();
        final SpringRequestWrapper wrappedRequest = new SpringRequestWrapper(request);
        LOGGER.info("Request: method={}, uri={}, payload={}", wrappedRequest.getMethod(),
                wrappedRequest.getRequestURI(), IOUtils.toString(wrappedRequest.getInputStream(),
                wrappedRequest.getCharacterEncoding()));
        final SpringResponseWrapper wrappedResponse = new SpringResponseWrapper(response);
        wrappedResponse.setHeader("X-Request-ID", MDC.get("X-Request-ID"));
        wrappedResponse.setHeader("X-Correlation-ID", MDC.get("X-Correlation-ID"));
        chain.doFilter(wrappedRequest, wrappedResponse);
        final long duration = System.currentTimeMillis() - startTime;
        LOGGER.info("Response({} ms): status={}, payload={}", value("X-Response-Time", duration),
                value("X-Response-Status", wrappedResponse.getStatus()),
                IOUtils.toString(wrappedResponse.getContentAsByteArray(), wrappedResponse.getCharacterEncoding()));
    }
}

3.自動配置

完成包裝器和HTTP過濾器的實現後，我們可以為庫準備自動配置。第一步是建立@Configuration包含所有必需的bean。我們必須註冊自定義HTTP過濾器SpringLoggingFilter，以及用於與Logstash和RestTemplateHTTP客戶端攔截器整合的logger appender：

@Configurationpublic class SpringLoggingAutoConfiguration {

    private static final String LOGSTASH_APPENDER_NAME = "LOGSTASH";

    @Value("${spring.logstash.url:localhost:8500}")
    String url;
    @Value("${spring.application.name:-}")
    String name;

    @Bean
    public UniqueIDGenerator generator() {
        return new UniqueIDGenerator();
    }

    @Bean
    public SpringLoggingFilter loggingFilter() {
        return new SpringLoggingFilter(generator());
    }

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        List<ClientHttpRequestInterceptor> interceptorList = new ArrayList<ClientHttpRequestInterceptor>();
        restTemplate.setInterceptors(interceptorList);
        return restTemplate;
    }

    @Bean
    public LogstashTcpSocketAppender logstashAppender() {
        LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
        LogstashTcpSocketAppender logstashTcpSocketAppender = new LogstashTcpSocketAppender();
        logstashTcpSocketAppender.setName(LOGSTASH_APPENDER_NAME);
        logstashTcpSocketAppender.setContext(loggerContext);
        logstashTcpSocketAppender.addDestination(url);
        LogstashEncoder encoder = new LogstashEncoder();
        encoder.setContext(loggerContext);
        encoder.setIncludeContext(true);
        encoder.setCustomFields("{\"appname\":\"" + name + "\"}");
        encoder.start();
        logstashTcpSocketAppender.setEncoder(encoder);
        logstashTcpSocketAppender.start();
        loggerContext.getLogger(Logger.ROOT_LOGGER_NAME).addAppender(logstashTcpSocketAppender);
        return logstashTcpSocketAppender;
    }

}

庫中的配置集合由Spring Boot載入。Spring Boot會檢查已釋出jar中是否存在META-INF/spring.factories檔案。該檔案應列出key等於EnableAutoConfiguration的配置類：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
pl.piomin.logging.config.SpringLoggingAutoConfiguration

4.與Logstash整合

通過自動配置的日誌記錄追加器(logging appender)實現與Logstash整合。我們可以通過在application.yml檔案中設定屬性spring.logstash.url來覆蓋Logstash目標URL:

spring:  application:    name: sample-app  logstash:    url: 192.168.99.100:5000

要在應用程式中啟用本文中描述的所有功能，只需要將我的庫包含在依賴項中：

<dependency>
    <groupId>pl.piomin</groupId>
    <artifactId>spring-boot-logging</artifactId>
    <version>1.0-SNAPSHOT</version></dependency>

在執行應用程式之前，您應該在計算機上啟動Elastic Stack。最好的方法是通過Docker容器。但首先要建立Docker網路，以通過容器名稱啟用容器之間的通訊。

$ docker network create es

現在，在埠9200啟動Elasticsearch的單個節點例項,我使用版本為6.7.2的Elastic Stack工具：

$ docker run -d --name elasticsearch --net es -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:6.7.2

執行Logstash時，需要提供包含輸入和輸出定義的其他配置。我將使用JSON編解碼器啟動TCP輸入，預設情況下不啟用。Elasticsearch URL設定為輸出。它還將建立一個包含應用程式名稱的索引。

input {
  tcp {
    port => 5000
    codec => json
  }
}
output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "micro-%{appname}"
  }
}

現在我們可以使用Docker容器啟動Logstash。它在埠5000上公開並從logstash.conf檔案中讀取配置：

docker run -d --name logstash --net es -p 5000:5000 -v ~/logstash.conf:/usr/share/logstash/pipeline/logstash.conf docker.elastic.co/logstash/logstash:6.7.2

最後，我們可以執行僅用於顯示日誌的Kibana:

$ docker run -d --name kibana --net es -e "ELASTICSEARCH_URL=http://elasticsearch:9200" -p 5601:5601 docker.elastic.co/kibana/kibana:6.7.2

啟動使用spring-boot-logging庫的示例應用程式後，POST請求中的日誌將顯示在Kibana中，如下所示：

相關推薦