在本教程中，你将学习如何使用 Elastic 可观察性监控 Java 应用程序：日志、基础设施指标、APM 和正常运行时间。通过本教程，你将学到：

创建示例 Java 应用程序。
使用 Filebeat 提取日志并在 Kibana 中查看你的日志。
使用 Metricbeat Prometheus 模块获取指标并在 Kibana 中查看你的指标。
使用 Elastic APM Java 代理检测你的应用程序。
使用 Heartbeat 监控您的服务并在 Kibana 中查看您的正常运行时间数据。

在下面的展示中，我将使用最新的 Elastic Stack 8.5.2 来进行展示。

安装

如果你还没有安装好自己的 Elasticsearch 及 Kibana，那么请按照我之前的文章：

在安装的时候，请参考 Elastic Stack 8.x 的安装指南进行安装。在安装的时候，我们需要针对 Elasticsearch 及 Kibana 做如下的调整：

Elasticsearch

我们需要在 config/elasticsearch.yml 文件中添加如下的部分：

config/elasticsearch.yml

xpack.security.authc.api_key.enabled: true

我们把上面的配置添加到 config/elasticsearch.yml 文件的最后面。这个是为了能够我们使用 API key 的方式来访问 Elasticsearch。修改完毕后，我们重新启动 Elasticsearch。这个是为了在下面我们使用 Elastic Agent 来安装 APM 集成。

Kibana

我们还必须为 Kibana 做一项修正。我们首先在 Kibana 的安装目录中使用如下的命令：

./bin/kibana-encryption-keys generate

上面的命令将生成三个 keys：



1.  Settings:
2.  xpack.encryptedSavedObjects.encryptionKey: e4fff0b64f35e01f8c00bd9ea1f87b8d
3.  xpack.reporting.encryptionKey: 9b24e172c750c789d90eac326f729de8
4.  xpack.security.encryptionKey: b4f867ecc76a4b03d1ecc178526ccab6

我们把上面的三个 keys 拷贝并粘贴到 config/kibana.yml 文件的最后面：

config/kibana.yml

添加完毕后，我们重新启动 Kibana。

这样我们就完成了 Elasticsearch 及 Kibana 的安装了。

创建一个 Java 应用

要创建 Java 应用程序，你需要 OpenJDK 14（或更高版本）和 Javalin Web 框架。该应用程序将包括主要端点、一个人为长时间运行的端点和一个需要轮询另一个数据源的端点。还会有一个后台作业在运行。我们按照如下的步骤来进行：

1）设置 Gradle 项目并创建以下 build.gradle 文件。

build.gradle

`

1.  plugins {
2.    id 'java'
3.    id 'application'
4.  }

6.  repositories {
7.    jcenter()
8.  }

10.  dependencies {
11.    implementation 'io.javalin:javalin:3.10.1'

13.    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
14.    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
15.  }

17.  application {
18.    mainClassName = 'de.spinscale.javalin.App'
19.  }

21.  test {
22.    useJUnitPlatform()
23.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)



1.  $ pwd
2.  /Users/liuxg/demos/apm/java_monitor
3.  $ ls
4.  build.gradle
5.  $ java -version
6.  java version "11.0.12" 2021-07-20 LTS
7.  Java(TM) SE Runtime Environment 18.9 (build 11.0.12+8-LTS-237)
8.  Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.12+8-LTS-237, mixed mode)

如上所示，我将使用 Java 11 来进行编译项目。

2）运行以下命令：



1.  echo "rootProject.name = 'javalin-app'" >> settings.gradle

3.  mkdir -p src/main/java/de/spinscale/javalin
4.  mkdir -p src/test/java/de/spinscale/javalin



1.  $ ls
2.  build.gradle    settings.gradle src

3）安装 Gradle 包装器。安装 Gradle 的一种简单方法是使用 sdkman 并运行 sdk install gradle 6.5.1。接下来在当前目录中运行 gradle wrapper 以安装 Gradle wrapper。我们也可以使用如下的命令来指定 gradle 的版本：

./gradlew wrapper --gradle-version 6.5.1

4）运行./gradlew clean check。你应该会看到一个成功的构建，它还没有构建或编译任何内容。



1.  $ ./gradlew clean check

3.  Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.

5.  You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.

7.  See https://docs.gradle.org/7.4.2/userguide/command_line_interface.html#sec:command_line_warnings

9.  BUILD SUCCESSFUL in 1s
10.  1 actionable task: 1 up-to-date

5）要创建 Javalin 服务器及其第一个端点（主要端点），请创建 src/main/java/de/spinscale/javalin/App.java 文件。



1.  package de.spinscale.javalin;

3.  import io.javalin.Javalin;

5.  public class App {
6.      public static void main(String[] args) {
7.          Javalin app = Javalin.create().start(8000);
8.          app.get("/", ctx -> ctx.result("Appsolutely perfect"));
9.      }
10.  }

`

1.  $ tree -L 7
2.  .
3.  ├── build.gradle
4.  ├── gradle
5.  │   └── wrapper
6.  │       ├── gradle-wrapper.jar
7.  │       └── gradle-wrapper.properties
8.  ├── gradlew
9.  ├── gradlew.bat
10.  ├── settings.gradle
11.  └── src
12.      ├── main
13.      │   └── java
14.      │       └── de
15.      │           └── spinscale
16.      │               └── javalin
17.      │                   └── App.java
18.      └── test
19.          └── java
20.              └── de
21.                  └── spinscale
22.                      └── javalin

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

在上面，我们的 web 服务器的端口地址为 8000。

6）运行 ./gradlew assemble

此命令编译了构建目录中的 App.class 文件。但是，无法启动服务器。让我们创建一个 jar，其中包含我们编译的类以及所有必需的依赖项。



1.  $ ./gradlew assemble

3.  Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.

5.  You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.

7.  See https://docs.gradle.org/7.4.2/userguide/command_line_interface.html#sec:command_line_warnings

9.  BUILD SUCCESSFUL in 4s
10.  5 actionable tasks: 5 executed

7）在 build.gradle 文件中，按此处所示编辑 plugins。



1.  plugins {
2.    id 'com.github.johnrengelman.shadow' version '6.0.0'
3.    id 'application'
4.    id 'java'
5.  }

8）运行./gradlew shadowJar。此命令创建一个 build/libs/javalin-app-all.jar 文件。shadowJar 插件需要有关其主类的信息。



1.  $ ./gradlew shadowJar

3.  Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.

5.  You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.

7.  See https://docs.gradle.org/7.4.2/userguide/command_line_interface.html#sec:command_line_warnings

9.  BUILD SUCCESSFUL in 21s
10.  2 actionable tasks: 1 executed, 1 up-to-date
11.  $ ls build/libs/javalin-app-all.jar 
12.  build/libs/javalin-app-all.jar

9）将以下代码片段添加到 build.gradle 文件中。



1.  jar {
2.    manifest {
3.      attributes 'Main-Class': 'de.spinscale.javalin.App'
4.    }
5.  }

10）在 builld.gradle 的 dependencies 里添加如下的项：



1.  dependencies {
2.    compile "org.slf4j:slf4j-simple:1.7.30"

4.    ...
5.  }

重新编译项目并启动服务器，并运行如下的命令：

java -jar build/libs/javalin-app-all.jar

打开另一个终端并运行 curl localhost:8000 以显示 HTTP 响应。

1.  $ curl localhost:8000
2.  Appsolutely perfect$

11）测试代码。将所有内容都放入 main() 方法会使测试代码变得困难。但是，专用处理程序可以解决此问题。重构 App 类。

App.java

`

1.  package de.spinscale.javalin;

3.  import io.javalin.Javalin;
4.  import io.javalin.http.Handler;

6.  public class App {

8.      public static void main(String[] args) {
9.          Javalin app = Javalin.create().start(8000);
10.          app.get("/", mainHandler());
11.      }

13.      static Handler mainHandler() {
14.          return ctx -> ctx.result("Appsolutely perfect");
15.      }
16.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

将 Mockito 和 Assertj 依赖项添加到 build.gradle 文件。



1.  dependencies {
2.    compile "org.slf4j:slf4j-simple:1.7.30"  
3.    implementation 'io.javalin:javalin:3.10.1'

5.    testImplementation 'org.mockito:mockito-core:3.5.10'
6.    testImplementation 'org.assertj:assertj-core:3.17.2'
7.    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
8.    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
9.  }

在 src/test/java/de/spinscale/javalin 中创建 AppTests.java 类文件。

AppTest.java

`

1.  package de.spinscale.javalin;

3.  import io.javalin.http.Context;
4.  import org.junit.jupiter.api.Test;

6.  import javax.servlet.http.HttpServletRequest;
7.  import javax.servlet.http.HttpServletResponse;
8.  import java.io.IOException;
9.  import java.nio.charset.StandardCharsets;
10.  import java.util.HashMap;

12.  import static de.spinscale.javalin.App.mainHandler;
13.  import static org.assertj.core.api.Assertions.assertThat;
14.  import static org.mockito.Mockito.mock;

16.  public class AppTests {

18.      final HttpServletRequest req = mock(HttpServletRequest.class);
19.      final HttpServletResponse res = mock(HttpServletResponse.class);
20.      final Context ctx = new Context(req, res, new HashMap<>());

22.      @Test
23.      public void testMainHandler() throws Exception {
24.          mainHandler().handle(ctx);

26.          String response = resultStreamToString(ctx);
27.          assertThat(response).isEqualTo("Appsolutely perfect");
28.      }

30.      private String resultStreamToString(Context ctx) throws IOException {
31.          final byte[] bytes = ctx.resultStream().readAllBytes();
32.          return new String(bytes, StandardCharsets.UTF_8);
33.      }
34.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

12）测试通过后，重新编译并打包应用程序。

./gradlew clean check shadowJar

摄入日志

日志可以是结帐、异常或 HTTP 请求等事件。对于本教程，让我们使用 log4j2 作为我们的日志记录实现。

添加日志记录实现

1）将依赖项添加到 build.gradle 文件中。



1.  dependencies {
2.    implementation 'io.javalin:javalin:3.10.1'
3.    implementation 'org.apache.logging.log4j:log4j-slf4j18-impl:2.13.3'

5.    ...
6.  }

2）要开始记录，请编辑 App.java 文件并更改处 handler。

注意：记录器调用必须在 lambda 内。否则，仅在启动期间记录日志消息

App.java

`

1.  package de.spinscale.javalin;

3.  import io.javalin.Javalin;
4.  import io.javalin.http.Handler;
5.  import org.slf4j.Logger;
6.  import org.slf4j.LoggerFactory;

8.  public class App {

10.      private static final Logger logger = LoggerFactory.getLogger(App.class);

12.      public static void main(String[] args) {
13.          Javalin app = Javalin.create();
14.          app.get("/", mainHandler());
15.          app.start(8000);
16.      }

18.      static Handler mainHandler() {
19.          return ctx -> {
20.              logger.info("This is an informative logging message, user agent [{}]", ctx.userAgent());
21.              ctx.result("Absolutely perfect");
22.          };
23.      }
24.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

3）在 src/main/resources/log4j2.xml 文件中创建一个 log4j2 配置。你可能需要先创建该目录。

mkdir -p src/main/resources

默认情况下，这会记录 ERROR 级别。对于 App 类，有一个额外的配置，以便也记录所有 INFO 日志。重新打包并重启后，日志信息显示在终端中。

./gradlew clean check shadowJar

在 terminal 中启动应用：

java -jar build/libs/javalin-app-all.jar

我们在另外一个 terminal 中执行如下的命令：

curl localhost:8000

我们可以在 web 应用中看到如下的输出：

日志请求

根据应用程序流量及其是否发生在应用程序之外，在应用程序级别记录每个请求是有意义的。

1）在 App.java 文件中，编辑 App 类。

App.java

`

1.  package de.spinscale.javalin;

3.  import io.javalin.Javalin;
4.  import io.javalin.http.Handler;
5.  import org.slf4j.Logger;
6.  import org.slf4j.LoggerFactory;

8.  public class App {

10.      private static final Logger logger = LoggerFactory.getLogger(App.class);

12.      public static void main(String[] args) {
13.          Javalin app = Javalin.create(config -> {
14.              config.requestLogger((ctx, executionTimeMs) -> {
15.                  logger.info("{} {} {} {} \"{}\" {}",
16.                          ctx.method(),  ctx.url(), ctx.req.getRemoteHost(),
17.                          ctx.res.getStatus(), ctx.userAgent(), executionTimeMs.longValue());
18.             });
19.          });
20.          app.get("/", mainHandler());
21.          app.start(8000);
22.      }

24.      static Handler mainHandler() {
25.          return ctx -> {
26.              logger.info("This is an informative logging message, user agent [{}]", ctx.userAgent());
27.              ctx.result("Absolutely perfect");
28.          };
29.      }
30.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

2）重新编译并启动应用程序。为每个请求记录日志消息。

创建 ISO8601 时间戳

在将日志提取到 Elasticsearch 服务之前，通过编辑 log4j2.xml 文件创建一个 ISO8601 时间戳。

注意：创建 ISO8601 时间戳后，就无需在提取日志时对时间戳进行任何计算，因为这是一个唯一的时间点，包括时区。一旦你在尝试跟踪数据流时跨数据中心运行，拥有时区就变得更加重要。

<PatternLayout pattern="%d{ISO8601_OFFSET_DATE_TIME_HHCMM} [%-5level] %logger{36} %msg%n"/>

把 log4j2.xml 文件中的 PatternLayout 替换为上面的句子。提取的日志条目包含如下时间戳：

从上面的输出中，我们可以看到有一个时间戳在日志中。

记录到文件和标准输出

1）要读取日志输出，让我们将数据写入文件和标准输出。这是一个新的 log4j2.xml 文件。

log4j2.xml

`

1.  <?xml version="1.0" encoding="UTF-8"?>
2.  <Configuration>
3.    <Appenders>
4.      <Console >
5.        <PatternLayout pattern="%highlight{%d{ISO8601_OFFSET_DATE_TIME_HHCMM} [%-5level] %logger{36} %msg%n}"/>
6.      </Console>
7.      <File >
8.        <PatternLayout pattern="%d{ISO8601_OFFSET_DATE_TIME_HHCMM} [%-5level] %logger{36} %msg%n"/>
9.      </File>
10.    </Appenders>
11.    <Loggers>
12.      <Logger />
13.      <Root level="ERROR">
14.        <AppenderRef ref="Console" />
15.        <AppenderRef ref="JavalinAppLog" />
16.      </Root>
17.    </Loggers>
18.  </Configuration>

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

2）重新启动应用程序并发送请求。日志将发送到 /tmp/javalin/app.log。

我们可以在 /tmp/javalin/app.log 查看日志的内容：



1.  $ cat /tmp/javalin/app.log 
2.  2022-11-30T19:56:36,308+08:00 [INFO ] de.spinscale.javalin.App This is an informative logging message, user agent [curl/7.82.0]
3.  2022-11-30T19:56:36,320+08:00 [INFO ] de.spinscale.javalin.App GET http://localhost:8000/ 127.0.0.1 200 "curl/7.82.0" 14

安装及配置 Filebeat

我们可以根据自己的系统来按照及配置 Filebeat。为了方便起见，我们可以直接到 Download Filebeat • Lightweight Log Analysis | Elastic 去下载适合自己操作系统的 Filebeat 安装包。根据我的 macOS，我使用如下的命令来进行下载：

wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-8.5.2-darwin-aarch64.tar.gz

我们使用如下的命令来进行解压缩：

tar xzf filebeat-8.5.2-darwin-aarch64.tar.gz

我们可以在 Filebeat 的安装目录下找到一个配置文件 filebeat.yml：



1.  $ pwd
2.  /Users/liuxg/elastic/filebeat-8.5.2-darwin-aarch64
3.  $ ls filebeat.yml 
4.  filebeat.yml

为了能配置我们的 filebeat.yml，我们可以先来创建一个 API key 来进行访问：

我们先把上面的 API key 拷贝下来，然后我们进行如下的配置：

filebeat.yml

我们还需要在 filebeat.yml 的开头部分进行如下的修改：



1.  name: javalin-app-shipper

3.  filebeat.inputs:
4.  - type: log
5.    paths:
6.      - /tmp/javalin/*.log

修改完上的部分后，我们进行如下的测试：

`

1.  $ ./filebeat test config
2.  Config OK
3.  $ ./filebeat test output
4.  elasticsearch: https://localhost:9200...
5.    parse url... OK
6.    connection...
7.      parse host... OK
8.      dns lookup... OK
9.      addresses: ::1, 127.0.0.1
10.      dial up... OK
11.    TLS...
12.      security: server's certificate chain verification is enabled
13.      handshake... OK
14.      TLS version: TLSv1.3
15.      dial up... OK
16.    talk to server... OK
17.    version: 8.5.2

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

上面表明：我们的配置是没有任何问题的，并且它可以正确地连接到 Elasticsearch。

我们接下来使用如下的命令来进行配置：

./filebeat setup



1.  $ ./filebeat setup
2.  Overwriting ILM policy is disabled. Set `setup.ilm.overwrite: true` for enabling.

4.  Index setup finished.
5.  Loading dashboards (Kibana must be running and reachable)
6.  Loaded dashboards
7.  Loaded Ingest pipelines

上面的命令将生成 index pattern, ingest pipeline, index template 及 dashboard。针对我们的情况，因为是自定义的日志格式，它生成的 filebeat-* 索引模式对我们是有用的。

发送数据到 Elasticsearch

我们接下来运行如下的命令：

./filebeat -e

在日志输出中，你应该看到以下行。

让我们为应用程序创建一些日志条目。你可以使用 wrk 之类的工具并运行以下命令向应用程序发送请求。

wrk -t1 -c 100 -d10s http://localhost:8000



1.  $ wrk -t1 -c 100 -d10s http://localhost:8000
2.  Running 10s test @ http://localhost:8000
3.    1 threads and 100 connections
4.    Thread Stats   Avg      Stdev     Max   +/- Stdev
5.      Latency    41.59ms   78.47ms 763.72ms   88.69%
6.      Req/Sec    12.39k    12.17k   42.90k    69.47%
7.    117212 requests in 10.04s, 15.31MB read
8.    Socket errors: connect 0, read 188, write 0, timeout 0
9.  Requests/sec:  11677.54
10.  Transfer/sec:      1.53MB

到 Kibana 中进行查看

1）打开 Discover：

我们可以在 Discover 中进行查看。我们可以看到有12,900 多个文档被写入。我们展开上面的日志：

你可以看到索引的数据不仅仅是事件。文件中有关于偏移量的信息，关于运送日志的组件的信息，输出中有运送者姓名的名称，还有一个包含日志行内容的消息字段。

你可以看到请求记录中存在缺陷。如果用户代理为 null，则返回 null 以外的内容。阅读我们的日志至关重要；然而，仅仅索引它们对我们没有任何好处。为了解决这个问题，这里有一个新的请求记录器。



1.  Javalin app = Javalin.create(config -> {
2.      config.requestLogger((ctx, executionTimeMs) -> {
3.          String userAgent = ctx.userAgent() != null ? ctx.userAgent() : "-";
4.          logger.info("{} {} {} {} \"{}\" {}",
5.                  ctx.method(), ctx.req.getPathInfo(), ctx.res.getStatus(),
6.                  ctx.req.getRemoteHost(), userAgent, executionTimeMs.longValue());
7.      });
8.  });

你可能还想在主处理程序的日志消息中修复此问题。



1.  static Handler mainHandler() {
2.      return ctx -> {
3.          String userAgent = ctx.userAgent() != null ? ctx.userAgent() : "-";
4.          logger.info("This is an informative logging message, user agent [{}]", userAgent);
5.          ctx.result("Absolutely perfect");
6.      };
7.  }

2）现在让我们看一下 Kibana 中的日志应用程序。选择可 Observability → Logs。

如果你想在工作中看到流功能，请在 sleep 时循环运行以下 curl 请求。

我们执行如下的命令：

while $(sleep 0.7) ; do curl localhost:8000 ; done

在 Logs 应用中，我们可以看到不断进来的日志。

查看其中一个被索引的文档，你可以看到日志消息包含在一个字段中。通过查看其中一份文件来验证这一点。



1.  GET filebeat-*/_search
2.  {
3.    "size": 1
4.  }

注意事项：

当你将 @timestamp 字段与日志 message 的 timestamp 进行比较时，你会注意到它的不同。这意味着在基于 @timestamp 字段进行过滤时，你得不到预期的结果。当前的 @timestamp 字段反映了在 Filebeat 中创建事件时的 timestamp，而不是日志事件在应用程序中发生时的 timestamp。
无法过滤特定字段，例如 HTTP 谓词、HTTP 状态代码、日志级别或生成日志消息的类

处理你的日志

结构化日志

要从单个日志行中将更多数据提取到多个字段中，需要对日志进行额外的结构化。

让我们再看看我们的应用程序生成的日志消息。

2022-11-30T20:44:32,184+08:00 [INFO ] de.spinscale.javalin.App This is an informative logging message, user agent [curl/7.82.0]

这条消息有四个部分：timestamp、log level、class 和 message。拆分规则也很明显，因为它们中的大多数都涉及空格。

好消息是，所有 Beats 都可以在使用处理器将日志行发送到 Elasticsearch 之前对其进行处理。如果这些处理器的能力不够，你始终可以让 Elasticsearch 使用摄入节点（ingest node）来完成繁重的工作。 Filebeat 中的许多模块就是这样做的。 Filebeat 中的模块是一种为特定软件解析特定日志文件格式的方法。

让我们通过使用几个处理器和一个 Filebeat 配置来尝试一下。

`

1.  processors:
2.    - add_host_metadata: ~
3.    - dissect:
4.        tokenizer: '%{timestamp} [%{log.level}] %{log.logger} %{message_content}'
5.        field: "message"
6.        target_prefix: ""
7.    - timestamp:
8.        field: "timestamp"
9.        layouts:
10.          - '2006-01-02T15:04:05.999Z0700'
11.        test:
12.          - '2020-07-18T04:59:51.123+0200'
13.    - drop_fields:
14.        fields: [ "message", "timestamp" ]
15.    - rename:
16.        fields:
17.          - from: "message_content"
18.          - to: "message"

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

dissect 处理器将日志 message 分成四个部分。如果要在消息字段中保留原始 message 的最后一部分，则需要先删除旧 message 字段，然后重命名该字段。 dissect 过滤器没法在里面替换 message。

还有一个专门的 timestamp 解析，以便 @timestamp 字段包含一个解析值。删除重复的字段，但确保原始 message 的一部分在消息字段中仍然可用。

重要：删除部分原始 message 是有争议的。保留原始 message 对我来说很有意义。对于上面的示例，如果解析 timestamp 没有按预期工作，调试可能会出现问题。

timestamp 的解析也略有不同，因为运行时间解析器只接受点作为秒和毫秒之间的分隔符。尽管如此，我们 log4j2 的默认输出仍然使用逗号。

任何一个都可以修复日志输出中的 timestamp，使其看起来像 Filebeat 所期望的那样。这导致以下图 pattern layout。

log4j2.xml

<PatternLayout pattern="%d{yyyy-MM-dd'T'HH:mm:ss.SSSZ} [%-5level] %logger{36} %msg%n"/>

修复 timestamp 解析是另一种方法，因为你并不总是可以完全控制日志并更改其格式。你可以使用一些第三方软件来解决这个问题。现在，这就足够了。

更改后重新启动 Filebeat，并通过运行此搜索（并索引另一条日志消息）来查看索引 JSON 文档中的更改内容。

很显然，我们现在看到的是结构化的数据。它更利用我们分析数据。你可以看到 message 字段只包含我们日志消息的最后一部分。此外，还有一个 log.level 和 log.logger 字段。

当日志级别为 INFO 时，它会在末尾添加额外的空间。你可以使用 script 处理器并调用 trim()。但是，无论日志级别长度如何，将我们的日志记录配置修复为不总是发出 5 个字符可能更容易。在写入标准输出时你仍然可以保留它。

log4j2.xml



1.  <File >
2.    <PatternLayout pattern="%d{yyyy-MM-dd'T'HH:mm:ss.SSSZ} [%level] %logger{36} %msg%n"/>
3.  </File>

解析异常

在日志记录的情况下，异常是一种特殊对待。它们跨越多行，因此在异常中不存在每行一条消息的旧规则。

在 App.java 中添加一个首先触发异常的端点，并确保使用异常映射器记录它。



1.  app.get("/exception", ctx -> {
2.      throw new IllegalArgumentException("not yet implemented");
3.  });

5.  app.exception(Exception.class, (e, ctx) -> {
6.      logger.error("Exception found", e);
7.      ctx.status(500).result(e.getMessage());
8.  });

调用 /exception 会向客户端返回一个 HTTP 500 错误，但它会像这样在日志中留下堆栈跟踪。

curl http://localhost:8000/exception

有一个属性有助于解析此堆栈跟踪。与常规日志消息相比，它似乎有所不同。每个新行都以空格开头，因此不同于以日期开头的日志消息。让我们将此逻辑添加到我们的 Beats 配置中。



1.  - type: log
2.    enabled: true
3.    paths:
4.      - /tmp/javalin/*.log
5.    multiline.pattern: ^20
6.    multiline.negate: true
7.    multiline.match: after

因此，上述设置的逐字翻译表示将所有内容都视为现有消息的一部分，而不是以一行 20 开头。 20 看起来像是你的时间戳的开始。一些用户喜欢将日期包裹在 [] 中以使其更易于理解。

注意：这会将状态引入你的日志记录中。你现在无法在多个处理器之间拆分日志文件，因为每个日志行仍可能属于当前事件。这不是一件坏事，但同样需要注意。

重新启动 Filebeat 和你的 Javalin 应用程序后，触发异常，你将在日志的消息字段中看到一个长堆栈跟踪。

配置日志轮换

为确保日志不会无限增长，让我们在日志配置中添加一些日志轮换。

log4j2.xml

`

1.  <?xml version="1.0" encoding="UTF-8"?>
2.  <Configuration>
3.    <Appenders>
4.      <Console >
5.        <PatternLayout pattern="%highlight{%d{ISO8601_OFFSET_DATE_TIME_HHCMM} [%-5level] %logger{36} %msg%n}"/>
6.      </Console>

8.      <RollingFile /tmp/javalin/%d{yyyy-MM-dd}-%i.log.gz">
9.        <PatternLayout pattern="%d{yyyy-MM-dd'T'HH:mm:ss.SSSZ} [%level] %logger{36} %msg%n"/>
10.        <Policies>
11.          <TimeBasedTriggeringPolicy />
12.          <SizeBasedTriggeringPolicy size="50 MB"/>
13.        </Policies>
14.        <DefaultRolloverStrategy max="20"/>
15.      </RollingFile>
16.    </Appenders>

18.    <Loggers>
19.      <Logger />
20.      <Root level="ERROR">
21.        <AppenderRef ref="Console" />
22.        <AppenderRef ref="JavalinAppLogRolling" />
23.      </Root>
24.    </Loggers>
25.  </Configuration>

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

该示例向我们的配置添加了一个 JavalinAppLogRolling appender，它使用与以前相同的日志记录模式，但如果新的一天开始或日志文件达到 50 兆字节，则会滚动。

如果创建了一个新的日志文件，旧的日志文件也会被 gzip 压缩以减少磁盘空间。 50 兆字节的大小是指解压后的文件大小，因此磁盘上可能存在的 20 个文件每个都将小得多。

摄取节点

内置模块（modules）几乎完全使用 Elasticsearch 的 Ingest 节点功能，而不是 Beats 处理器。

摄取管道最有用的部分之一是能够使用模拟管道 API 进行调试。

1）让我们使用 Kibana 中的 Dev Tools 面板编写一个类似于我们的 Filebeat 处理器的管道，运行以下命令：

`

1.  # Store the pipeline in Elasticsearch
2.  PUT _ingest/pipeline/javalin_pipeline
3.  {
4.    "processors": [
5.      {
6.        "dissect": {
7.          "field": "message",
8.          "pattern": "%{@timestamp} [%{log.level}] %{log.logger} %{message}"
9.        }
10.      },
11.      {
12.        "trim": {
13.          "field": "log.level"
14.        }
15.      },
16.      {
17.        "date": {
18.          "field": "@timestamp",
19.          "formats": [
20.            "ISO8601"
21.          ]
22.        }
23.      }
24.    ]
25.  }

27.  # Test the pipeline
28.  POST _ingest/pipeline/javalin_pipeline/_simulate
29.  {
30.    "docs": [
31.      {
32.        "_source": {
33.          "message": "2020-07-06T13:39:51,737+02:00 [INFO ] de.spinscale.javalin.App This is an informative logging message"
34.        }
35.      }
36.    ]
37.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

你可以在输出中看到管道创建的字段，现在看起来像早期的 Filebeat 处理器。由于摄取管道在文档级别工作，你仍然需要检查生成日志的异常情况，并让 Filebeat 从中创建一条消息。你甚至可以使用单个处理器实现 log level 的 trim，并且日期解析也非常简单，因为 Elasticsearch ISO8601 解析器在拆分秒和毫秒时正确识别逗号而不是点。

2）现在，进入 Filebeat 配置。首先，让我们删除除 add_host_metadata 处理器之外的所有处理器，以添加一些主机信息，如主机名和操作系统。



1.  processors:
2.    - add_host_metadata: ~

3）编辑 Elasticsearch 输出以确保在从 Filebeat 为文档编制索引时将引用管道。

4）重新启动 Filebeat 并查看日志是否按预期流入。

curl http://localhost:8000

将日志写入 JSON

你现在已经了解了如何在 Beats 或 Elasticsearch 中解析日志。如果我们不需要考虑手动解析日志和提取数据怎么办？

以纯文本形式写出日志是可行的，并且易于人类阅读。然而，首先将它们写成纯文本，使用解剖处理器解析它们，然后再次创建一个 JSON 听起来很乏味并且会消耗不必要的 CPU 周期。

虽然 log4j2 有一个 JSONLayout，但你可以更进一步使用名为 ecs-logging-java 的库。 ECS 日志记录的优势在于它使用 Elastic Common Schema。 ECS 定义了在 Elasticsearch 中存储事件数据时使用的一组标准字段，例如日志和指标。

1）不要编写我们的日志记录标准，而是使用现有的标准。让我们将日志记录依赖项添加到我们的 Javalin 应用程序中。

`

1.  dependencies {
2.    compile "org.slf4j:slf4j-simple:1.7.30"  
3.    implementation 'io.javalin:javalin:3.10.1'
4.    implementation 'org.apache.logging.log4j:log4j-slf4j18-impl:2.13.3'
5.    implementation 'co.elastic.logging:log4j2-ecs-layout:0.5.0'

7.    testImplementation 'org.mockito:mockito-core:3.5.10'
8.    testImplementation 'org.assertj:assertj-core:3.17.2'
9.    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
10.    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
11.  }

13.  // this is needed to ensure JSON logging works as expected when building
14.  // a shadow jar
15.  shadowJar {
16.    transform(com.github.jengelman.gradle.plugins.shadow.transformers.Log4j2PluginsCacheFileTransformer)
17.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

log4j2-ecs-layout 附带一个自定义，可用于滚动文件附加程序的日志记录设置

log4j2.xml



1.  <RollingFile /tmp/javalin/%d{yyyy-MM-dd}-%i.log.gz">
2.    <EcsLayout service/>
3.    <Policies>
4.      <TimeBasedTriggeringPolicy />
5.      <SizeBasedTriggeringPolicy size="50 MB"/>
6.    </Policies>
7.    <DefaultRolloverStrategy max="20"/>
8.  </RollingFile>

当你重新启动你的应用程序时，你将看到纯 JSON 写入您的日志文件。当你触发异常时，你会看到堆栈跟踪已经在你的单个文档中。这意味着 Filebeat 配置可以变得无状态甚至更轻量级。另外，Elasticsearch 端的 ingest pipeline 可以再次删除。

在运行之前，我们可以先删除之前的 app.log 文件以看得更加清楚：

rm -rf /tmp/javalin/app.log

curl http://localhost:8000/exception

我们再次查看 /tmp/javalin/app.log 文件：

2）你可以为 EcsLayout 配置更多参数，但明智地选择了默认值。让我们修复 Filebeat 配置并删除多行设置以及管道：

filebeat.yml



1.  filebeat.inputs:
2.  - type: log
3.    paths:
4.      - /tmp/javalin/*.log
5.    json.keys_under_root: true



1.  processors:
2.    - add_host_metadata: ~

如你所见，仅通过将日志写成 JSON，我们的整个日志记录设置就变得容易了很多，因此只要有可能，请尝试直接将日志写成 JSON。

重新运行 Filebeat，并在 Kibana 中进行查看：

好了，我今天就先讲到这里。在接下来的文章中，我将展示如何为这个 web 网站收集指标。敬请期待！

Observability：从零开始创建 Java 微服务并监控它 （一）

安装

Elasticsearch

Kibana

创建一个 Java 应用

摄入日志

添加日志记录实现

日志请求

创建 ISO8601 时间戳

记录到文件和标准输出

安装及配置 Filebeat

发送数据到 Elasticsearch

到 Kibana 中进行查看

处理你的日志

结构化日志

解析异常

配置日志轮换

摄取节点

将日志写入 JSON

Observability：从零开始创建 Java 微服务并监控它（一）