Observability:从零开始创建 Java 微服务并监控它

Posted Elastic 中国社区官方博客

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Observability:从零开始创建 Java 微服务并监控它相关的知识,希望对你有一定的参考价值。

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

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

在下面的展示中,我将使用最新的 Elastic Stack 8.5.2 来进行展示。为了方便大家的学习,源码可以在地址 https://github.com/liu-xiao-guo/java_observability 进行下载。


安装

如果你还没有安装好自己的 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:

Settings:
xpack.encryptedSavedObjects.encryptionKey: e4fff0b64f35e01f8c00bd9ea1f87b8d
xpack.reporting.encryptionKey: 9b24e172c750c789d90eac326f729de8
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

plugins 
  id 'java'
  id 'application'


repositories 
  jcenter()


dependencies 
  implementation 'io.javalin:javalin:3.10.1'

  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'


application 
  mainClassName = 'de.spinscale.javalin.App'


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

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

2)运行以下命令:

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

mkdir -p src/main/java/de/spinscale/javalin
mkdir -p src/test/java/de/spinscale/javalin
$ ls
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。 你应该会看到一个成功的构建,它还没有构建或编译任何内容。

$ ./gradlew clean check

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

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

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

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

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

package de.spinscale.javalin;

import io.javalin.Javalin;

public class App 
    public static void main(String[] args) 
        Javalin app = Javalin.create().start(8000);
        app.get("/", ctx -> ctx.result("Appsolutely perfect"));
    
$ tree -L 7
.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src
    ├── main
    │   └── java
    │       └── de
    │           └── spinscale
    │               └── javalin
    │                   └── App.java
    └── test
        └── java
            └── de
                └── spinscale
                    └── javalin

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

6)运行 ./gradlew assemble

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

$ ./gradlew assemble

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

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

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

BUILD SUCCESSFUL in 4s
5 actionable tasks: 5 executed

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

plugins 
  id 'com.github.johnrengelman.shadow' version '6.0.0'
  id 'application'
  id 'java'

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

$ ./gradlew shadowJar

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

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

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

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

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

jar 
  manifest 
    attributes 'Main-Class': 'de.spinscale.javalin.App'
  

10)在 builld.gradle 的 dependencies 里添加如下的项:

dependencies 
  compile "org.slf4j:slf4j-simple:1.7.30"

  ...

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

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

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

$ curl localhost:8000
Appsolutely perfect$ 

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

App.java

package de.spinscale.javalin;

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

public class App 

    public static void main(String[] args) 
        Javalin app = Javalin.create().start(8000);
        app.get("/", mainHandler());
    

    static Handler mainHandler() 
        return ctx -> ctx.result("Appsolutely perfect");
    

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

dependencies 
  compile "org.slf4j:slf4j-simple:1.7.30"  
  implementation 'io.javalin:javalin:3.10.1'

  testImplementation 'org.mockito:mockito-core:3.5.10'
  testImplementation 'org.assertj:assertj-core:3.17.2'
  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'

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

AppTest.java

package de.spinscale.javalin;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;

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

public class AppTests 

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

    @Test
    public void testMainHandler() throws Exception 
        mainHandler().handle(ctx);

        String response = resultStreamToString(ctx);
        assertThat(response).isEqualTo("Appsolutely perfect");
    

    private String resultStreamToString(Context ctx) throws IOException 
        final byte[] bytes = ctx.resultStream().readAllBytes();
        return new String(bytes, StandardCharsets.UTF_8);
    

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

./gradlew clean check shadowJar

摄入日志 

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

添加日志记录实现

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

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

  ...

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

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

App.java

package de.spinscale.javalin;

import io.javalin.Javalin;
import io.javalin.http.Handler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App 

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

    public static void main(String[] args) 
        Javalin app = Javalin.create();
        app.get("/", mainHandler());
        app.start(8000);
    

    static Handler mainHandler() 
        return ctx -> 
            logger.info("This is an informative logging message, user agent []", ctx.userAgent());
            ctx.result("Absolutely perfect");
        ;
    

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

package de.spinscale.javalin;

import io.javalin.Javalin;
import io.javalin.http.Handler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App 

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

    public static void main(String[] args) 
        Javalin app = Javalin.create(config -> 
            config.requestLogger((ctx, executionTimeMs) -> 
                logger.info("    \\"\\" ",
                        ctx.method(),  ctx.url(), ctx.req.getRemoteHost(),
                        ctx.res.getStatus(), ctx.userAgent(), executionTimeMs.longValue());
           );
        );
        app.get("/", mainHandler());
        app.start(8000);
    

    static Handler mainHandler() 
        return ctx -> 
            logger.info("This is an informative logging message, user agent []", ctx.userAgent());
            ctx.result("Absolutely perfect");
        ;
    

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

创建 ISO8601 时间戳

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

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

<PatternLayout pattern="%dISO8601_OFFSET_DATE_TIME_HHCMM [%-5level] %logger36 %msg%n"/>

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

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

记录到文件和标准输出

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

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%highlight%dISO8601_OFFSET_DATE_TIME_HHCMM [%-5level] %logger36 %msg%n"/>
    </Console>
    <File name="JavalinAppLog" fileName="/tmp/javalin/app.log">
      <PatternLayout pattern="%dISO8601_OFFSET_DATE_TIME_HHCMM [%-5level] %logger36 %msg%n"/>
    </File>
  </Appenders>
  <Loggers>
    <Logger name="de.spinscale.javalin.App" level="INFO"/>
    <Root level="ERROR">
      <AppenderRef ref="Console" />
      <AppenderRef ref="JavalinAppLog" />
    </Root>
  </Loggers>
</Configuration>

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

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

$ cat /tmp/javalin/app.log 
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]
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:

$ pwd
/Users/liuxg/elastic/filebeat-8.5.2-darwin-aarch64
$ ls filebeat.yml 
filebeat.yml

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

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

filebeat.yml

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

name: javalin-app-shipper

filebeat.inputs:
- type: log
  paths:
    - /tmp/javalin/*.log

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

$ ./filebeat test config
Config OK
$ ./filebeat test output
elasticsearch: https://localhost:9200...
  parse url... OK
  connection...
    parse host... OK
    dns lookup... OK
    addresses: ::1, 127.0.0.1
    dial up... OK
  TLS...
    security: server's certificate chain verification is enabled
    handshake... OK
    TLS version: TLSv1.3
    dial up... OK
  talk to server... OK
  version: 8.5.2

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

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

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

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

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

发送数据到 Elasticsearch

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

./filebeat -e

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

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

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

到 Kibana 中进行查看

1)打开 Discover:

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

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

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

Javalin app = Javalin.create(config -> 
    config.requestLogger((ctx, executionTimeMs) -> 
        String userAgent = ctx.userAgent() != null ? ctx.userAgent() : "-";
        logger.info("    \\"\\" ",
                ctx.method(), ctx.req.getPathInfo(), ctx.res.getStatus(),
                ctx.req.getRemoteHost(), userAgent, executionTimeMs.longValue());
    );
);

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

static Handler mainHandler() 
    return ctx -> 
        String userAgent = ctx.userAgent() != null ? ctx.userAgent() : "-";
        logger.info("This is an informative logging message, user agent []", userAgent);
        ctx.result("Absolutely perfect");
    ;

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

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

我们执行如下的命令:

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

 

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

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

GET filebeat-*/_search

  "size": 1

注意事项:

  • 当你将 @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 配置来尝试一下。

processors:
  - add_host_metadata: ~
  - dissect:
      tokenizer: '%timestamp [%log.level] %log.logger %message_content'
      field: "message"
      target_prefix: ""
  - timestamp:
      field: "timestamp"
      layouts:
        - '2006-01-02T15:04:05.999Z0700'
      test:
        - '2020-07-18T04:59:51.123+0200'
  - drop_fields:
      fields: [ "message", "timestamp" ]
  - rename:
      fields:
        - from: "message_content"
        - to: "message"

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

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

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

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

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

 log4j2.xml

<PatternLayout pattern="%dyyyy-MM-dd'T'HH:mm:ss.SSSZ [%-5level] %logger36 %msg%n"/>

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

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

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

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

 log4j2.xml

<File name="JavalinAppLog" fileName="/tmp/javalin/app.log">
  <PatternLayout pattern="%dyyyy-MM-dd'T'HH:mm:ss.SSSZ [%level] %logger36 %msg%n"/>
</File>

解析异常

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

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

app.get("/exception", ctx -> 
    throw new IllegalArgumentException("not yet implemented");
);

app.exception(Exception.class, (e, ctx) -> 
    logger.error("Exception found", e);
    ctx.status(500).result(e.getMessage());
);

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

curl http://localhost:8000/exception

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

- type: log
  enabled: true
  paths:
    - /tmp/javalin/*.log
  multiline.pattern: ^20
  multiline.negate: true
  multiline.match: after

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

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

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

配置日志轮换

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

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%highlight%dISO8601_OFFSET_DATE_TIME_HHCMM [%-5level] %logger36 %msg%n"/>
    </Console>

    <RollingFile name="JavalinAppLogRolling" fileName="/tmp/javalin/app.log" filePattern="/tmp/javalin/%dyyyy-MM-dd-%i.log.gz">
      <PatternLayout pattern="%dyyyy-MM-dd'T'HH:mm:ss.SSSZ [%level] %logger36 %msg%n"/>
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="50 MB"/>
      </Policies>
      <DefaultRolloverStrategy max="20"/>
    </RollingFile>
  </Appenders>

  <Loggers>
    <Logger name="de.spinscale.javalin.App" level="INFO"/>
    <Root level="ERROR">
      <AppenderRef ref="Console" />
      <AppenderRef ref="JavalinAppLogRolling" />
    </Root>
  </Loggers>
</Configuration>

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

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

摄取节点

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

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

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

# Store the pipeline in Elasticsearch
PUT _ingest/pipeline/javalin_pipeline

  "processors": [
    
      "dissect": 
        "field": "message",
        "pattern": "%@timestamp [%log.level] %log.logger %message"
      
    ,
    
      "trim": 
        "field": "log.level"
      
    ,
    
      "date": 
        "field": "@timestamp",
        "formats": [
          "ISO8601"
        ]
      
    
  ]


# Test the pipeline
POST _ingest/pipeline/javalin_pipeline/_simulate

  "docs": [
    
      "_source": 
        "message": "2020-07-06T13:39:51,737+02:00 [INFO ] de.spinscale.javalin.App This is an informative logging message"
      
    
  ]

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

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

processors:
  - 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 应用程序中。

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

  testImplementation 'org.mockito:mockito-core:3.5.10'
  testImplementation 'org.assertj:assertj-core:3.17.2'
  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'


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

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

log4j2.xml

<RollingFile name="JavalinAppLogRolling" fileName="/tmp/javalin/app.log" filePattern="/tmp/javalin/%dyyyy-MM-dd-%i.log.gz">
  <EcsLayout serviceName="my-javalin-app"/>
  <Policies>
    <TimeBasedTriggeringPolicy />
    <SizeBasedTriggeringPolicy size="50 MB"/>
  </Policies>
  <DefaultRolloverStrategy max="20"/>
</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

filebeat.inputs:
- type: log
  paths:
    - /tmp/javalin/*.log
  json.keys_under_root: true

 

 

processors:
  - add_host_metadata: ~

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

重新运行 Filebeat,并在 Kibana 中进行查看:

好了,我今天就先讲到这里。在接下来的文章 “Observability:从零开始创建 Java 微服务并监控它 (二)” 中,我将展示如何为这个 web 网站收集指标等。

以上是关于Observability:从零开始创建 Java 微服务并监控它的主要内容,如果未能解决你的问题,请参考以下文章

Observability:从零开始创建 Java 微服务并监控它

Observability:从零开始创建 Java 微服务并监控它

云原生 | 从零开始学istio二Istio核心特性与架构

使用Java语言从零开始创建区块链

Java从零开始学习——Java数组

Java从零开始学习——Java数组