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 微服务并监控它