时代Java，与您同行！关注微信公众号，关注前沿技术，微信搜索：nowjava或时代Java，也可点击这里扫码关注

时代Java

京东自营 618 + 国补 iPhone 历史最低价领 618 红包，最高25618元

Java 23 与 Spring Boot 3.3.4：Logback 日志配置指南

欢马劈雪

工程师 (已认证)

原创分享签约作者

发表于教程文章

在这篇文章中：

引言

在本篇文章中，我们将聚焦于 Spring Boot 应用的日志记录（Logback配置），探讨错误日志机制、事件格式及日志事件中捕获的信息类型。同时，我们还会介绍如何配置日志属性，例如日志文件命名、基于大小或时间的文件滚动策略，以及如何在 Spring Boot 应用中集成这些配置。

日志是任何应用的重要组成部分，特别是在生产环境中，它有助于监控、故障排除和审计。在 Spring Boot 应用中使用 Logback 时，遵循最佳实践可以确保日志既有用又高效，同时避免潜在的安全风险。

1. 日志级别的合理使用

TRACE：用于记录比 DEBUG 更详细的信息，通常仅在排查特定问题时使用。
DEBUG：用于开发过程中的详细诊断信息，避免在生产环境中使用 DEBUG 级别，以防影响性能和日志膨胀。
INFO：用于记录应用程序状态的常规信息，如启动信息、外部服务交互及应用流程关键节点，适用于生产环境。
WARN：用于记录非预期但不会影响应用正常运行的问题，例如使用已废弃的 API 或可恢复的错误。
ERROR：用于记录影响应用功能的严重问题，生产环境应重点监控。

最佳实践：

在开发环境中可以使用 DEBUG 级别日志，但生产环境应尽量使用 INFO 及更高级别。
仅记录关键事件，避免日志信息过载影响性能。

2. 避免记录敏感数据

避免在日志中记录用户密码、信用卡号或个人身份信息（PII），以防止安全风险。

最佳实践：

确保日志不包含会暴露安全信息的内容，如会话 ID、用户凭据等。
可以编写日志过滤工具，确保敏感数据不会被写入日志。

3. 使用滚动日志管理

为了防止日志文件过大影响性能和磁盘空间，推荐使用基于大小和时间的日志滚动策略。

最佳实践：使用 SizeAndTimeBasedRollingPolicy 配置日志文件滚动策略，例如：

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/app.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>/tmp/logs/app.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <maxFileSize>10MB</maxFileSize>
        <maxHistory>100</maxHistory>
        <totalSizeCap>3GB</totalSizeCap>
    </rollingPolicy>
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

maxFileSize：单个日志文件的最大大小（如 10MB）。
maxHistory：保留 100 天的日志文件。
totalSizeCap：日志文件总大小上限 3GB，防止磁盘占满。

4. 启用异步日志提高性能

同步日志记录会阻塞主线程，影响应用性能。使用异步日志可以缓解这一问题。

最佳实践：

<appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="FILE"/>
    <queueSize>5000</queueSize>
    <discardingThreshold>0</discardingThreshold>
</appender>

5. 记录有意义的日志信息

日志应当提供足够的上下文信息，使其易于理解和排查问题。

最佳实践：

包含类名和方法名（Logback 可自动捕获）。
记录请求或会话 ID，以便跟踪用户操作。
记录异常信息，包括完整的堆栈轨迹。

示例：

log.error("订单处理失败，用户ID: {}, 订单ID: {}", userId, orderId, exception);

6. 外部化日志配置

通过 logback-spring.xml 或外部属性文件管理日志配置，使其易于调整。

最佳实践：

使用 logback-spring.xml 定义日志行为。
通过环境变量调整日志路径或文件名。

7. 统一日志收集与监控

在微服务架构中，集中式日志管理有助于快速定位问题。

最佳实践：

使用 ELK（Elasticsearch、Logstash、Kibana）、Graylog 或 Splunk 进行日志聚合。
配置 Logback 发送日志到集中式系统，例如使用 SyslogAppender 或 Logstash TCP appender。

8. 使用 MDC（Mapped Diagnostic Context）添加上下文信息

MDC 允许在日志中自动插入请求 ID、用户 ID 等上下文信息，适用于多线程环境。

最佳实践：

使用 MDC 在日志中注入请求或会话特定的信息：

MDC.put( "requestId" , requestId); 
log.info( "正在处理请求" ); 
MDC.clear();

在 logback-spring.xml 中，在日志模式中包含 MDC 变量：

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%X{requestId}] - %msg%n</pattern>

9. 生产环境优化日志配置

最佳实践：

生产环境减少日志级别，通常使用 INFO 或更高级别。
采用日志压缩（如 .gz），节省磁盘空间。
监控日志大小，确保日志不会无限增长。
定期备份日志，避免磁盘损坏导致数据丢失。

10. 使用结构化日志（JSON 格式）

结构化日志便于搜索和分析，尤其适用于日志聚合工具（如 ELK、Splunk）。

示例（JSON 格式日志配置）：

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp/>
            <loggerName/>
            <logLevel/>
            <message/>
            <threadName/>
            <mdc/>
        </providers>
    </encoder>
</appender>

总结

适当选择日志级别（DEBUG、INFO、WARN、ERROR）。
避免记录敏感数据。
使用日志滚动策略管理文件大小。
启用异步日志提高性能。
记录详细、有意义的信息。
外部化日志配置，便于维护。
采用集中式日志收集工具（如 ELK）。
使用 MDC 添加上下文信息。
生产环境优化日志策略。
采用结构化日志（如 JSON 格式）提高分析效率。

本篇文章主要介绍了 Logback 在 Spring Boot 3.3.4 中的最佳实践，下一篇（第4部分）将探讨如何利用 AOP（面向切面编程）来优化日志管理。

整合所有内容

让我们将重点转移到在生产级应用程序中实施这些最佳实践。我们将探讨如何设置必要的依赖项和配置，以确保这些实践有效集成并发挥作用。

依赖项和日志库版本
应用程序属性
Spring Logback 配置

1. 依赖项和日志库版本

  <!-- 日志记录 ========================================================== --> 
  < slf4j.version > 2.0.16 </ slf4j.version > 
  < logback.version > 1.5.8 </ logback.version > 
  < logstash.version > 8.0 </ logstash.version > 
  < janino.version > 3.1.12 </ janino.version > 
  < micrometer.version > 1.13.5 </ micrometer.version >

  <!-- ================================================================= -->
  <!-- SLF4J

 / LogBack / LogStash / Janino

 / Micrometer

 / Actuator

       -->  
  <!-- ================================================================= -->

  <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
  <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>${slf4j.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
  <dependency>
   <groupId>ch.qos.logback</groupId>
   <artifactId>logback-classic</artifactId>
   <version>${logback.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/net.logstash.logback/logstash-logback-encoder -->
  <dependency>
   <groupId>net.logstash.logback</groupId>
   <artifactId>logstash-logback-encoder</artifactId>
   <version>${logstash.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/org.codehaus.janino/janino -->
  <dependency>
   <groupId>org.codehaus.janino</groupId>
   <artifactId>janino</artifactId>
   <version>${janino.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/io.micrometer/micrometer-core -->
  <dependency>
   <groupId>io.micrometer</groupId>
   <artifactId>micrometer-core</artifactId>
   <version>${micrometer.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/io.micrometer/micrometer-registry-prometheus -->
  <dependency>
   <groupId>io.micrometer</groupId>
   <artifactId>micrometer-registry-prometheus</artifactId>
   <version>${micrometer.version}</version>
  </dependency>

  <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
   <version>${spring.boot.version}</version>
  </dependency>

1. SLF4J（Java 的简单日志外观）

目的：SLF4J 是各种日志记录框架（如 Logback、Log4j 等）的简单抽象。它为日志记录提供了统一的 API，但将实际的日志记录实现委托给底层日志记录框架。在 Spring Boot 应用程序中，您通常使用 SLF4J 进行日志记录，而实际日志记录由 Logback 或其他日志记录框架处理。
用法：使用 SLF4J 的 API 在您的应用程序中编写日志代码（例如，Logger logger = LoggerFactory.getLogger(ClassName.class);），SLF4J 会将日志转发到 Logback（或其他后端）。

2. Logback

目的：Logback 是一个功能强大、灵活且快速的日志记录框架，常用于 Spring Boot 应用程序中。它作为 SLF4J 背后的默认日志记录实现，并支持滚动日志、自定义编码器和附加器等高级功能。
使用：在logback-spring.xml或logback.xml中定义日志配置，指定日志格式，文件附加器，日志级别等。它可以将日志输出到控制台，文件或远程日志聚合系统。

3. Logstash 编码器

目的：该库为 Logback 提供了一个 LogstashEncoder，支持 JSON 日志记录，以便与 ELK（Elasticsearch、Logstash、Kibana）堆栈等日志聚合系统集成。它将日志格式化为 JSON，使其更易于在日志管理平台中处理和分析。
使用方式：使用logback-spring.xml中的LogstashEncoder将日志以JSON格式输出，以便兼容ELK等工具进行结构化日志分析。

4.Janino

用途：Janino 是一个嵌入式 Java 编译器，用于在 Logback 中启用配置文件中的条件日志记录逻辑。您可以使用它在日志记录配置中定义动态行为（如条件日志级别），而无需重新编译应用程序。
用法：它通常用于当您需要在 Logback 配置中编写复杂的条件表达式或过滤器时（例如，评估表达式以确定何时记录某些消息）。

5. Micrometer

用途：Micrometer 是一个指标检测库，它为 Spring Boot 应用程序中收集和报告指标提供了外观。它通常与日志记录结合使用，以收集性能和使用情况指标（例如错误率、请求时间），并可以将数据发送到 Prometheus、Datadog 或 Grafana 等监控系统。
用法：除了日志记录之外，您还可以使用 Micrometer 来检测应用程序的性能指标，从而可以监控错误率和响应时间等关键方面。它通常与 Spring Boot 的执行器集成以自动收集指标。

6. Spring Boot 执行器

目的：Spring Boot Actuator 提供内置的生产就绪功能，如监控、审计、指标收集和系统健康检查。它添加了几个端点，允许您监控和与 Spring Boot 应用程序交互，公开有关当前状态、配置和指标的信息。
用法：在 Spring Boot 应用程序中，通过包含 spring-boot-starter-actuator 依赖项来添加 Actuator 端点。您可以通过 application.properties 或 application.yml 中的配置自定义要公开和保护的端点

概括

SLF4J提供了日志记录 API 外观。
Logback是默认使用的实际日志实现。
Logstash启用 JSON 日志记录以进行外部日志处理。
Janino允许在日志配置中使用动态逻辑。
Micrometer收集应用程序指标以便与日志一起监控。
Actuator通过 HTTP 端点提供健康检查、指标、环境信息等。

2. 服务/应用程序属性

现在让我们检查一下 Spring Boot “ application.properties” 文件中定义的服务和服务器属性，以及它们如何在 Logback Spring XML 配置中应用。此配置管理控制台、纯文本文件和基于 JSON 的文件的输出。此外，我们将探讨如何使用应用程序属性 logsing.format 在纯文本和 JSON 日志格式之间动态切换。

# 各个组件的日志级别
logging.level.org.springframework.boot.web.servlet = 
DEBUGlogging.level.org.springframework.web.servlet.DispatcherServlet = 
DEBUGlogging.level.org.springframework.security.web.FilterChainProxy =DEBUG 

# 根级别日志
logging.level.root =INFO 

# 指定 logback 配置文件
logging.config =classpath:logback-spring.xml 

# 日志文件路径和滚动策略
logging.path =/tmp/logs/ ${service.api.name} 
logging.file.name = ${service.api.name} .v ${server.version} .log 

# 基于大小和时间的文件滚动名称的日志文件模式
logging.pattern.rolling-file-name = ${logging.path} / ${service.api.name} .v ${server.version} -%d{yyyy-MM-dd}-%i.log 

# 最大单个文件大小 = 10 MBlogging.file.max 
-size = 10 MB 

# 日志的保留和总大小上限
# 保留日志文件 100 天，最大上限为 3 GB 
login.file.max-history = 100 
login.file.total-size-cap = 3 GB

1. 各个组件的日志记录级别

logs.level.org.springframework.boot.web.servlet =DEBUG 
logs.level.org.springframework.web.servlet.DispatcherServlet =DEBUG 
logs.level.org.springframework.security.web.FilterChainProxy =DEBUG

日志记录.级别.org.springframework.boot.web.servlet=DEBUG

这会将 Spring Boot 的 org.springframework.boot.web.servlet 包的日志记录级别设置为 DEBUG。这对于在开发过程中获取详细信息非常有用，尤其是与 servlet 相关的操作（例如 Web 请求处理）。

日志记录.级别.org.springframework.web.servlet.DispatcherServlet=DEBUG

这会将 DispatcherServlet 的日志记录级别设置为 DEBUG。这个核心 Spring MVC 组件处理传入的 HTTP 请求并将它们路由到适当的处理程序（控制器）。将其设置为 DEBUG 会记录有关请求处理的详细信息。

日志记录.级别.org.springframework.安全.web.FilterChainProxy=DEBUG

这将启用 Spring Security 的 FilterChainProxy 的 DEBUG 日志记录。FilterChainProxy 管理处理传入 HTTP 请求的安全过滤器链。此日志记录可帮助您了解在请求处理期间应用的过滤器，并且在调试与安全相关的问题时非常有用。

2. 根级别日志记录

日志记录.级别.根=INFO

根记录器是应用程序中所有记录器的父记录器。将其设置为 INFO 可确保任何未在组件级别专门设置的日志记录（例如 DEBUG）将默认为 INFO。INFO 记录一般应用程序流程和事件，但会忽略详细的调试信息。

3.指定Logback配置文件

logging.config =classpath：logback-spring.xml

该属性指定Logback 配置文件的路径。在本例中，它指向位于类路径中的 logback-spring.xml。该文件包含 logger、appender、encoder 和滚动策略的详细配置。

4. 日志文件路径和滚动策略

logging.path=/tmp/logs/${service.api.name}
logging.file.name=${service.api.name}.v${server.version}

logging.path=/tmp/logs/${service.api.name}

此属性定义日志文件的存储目录。${service.api.name} 占位符指的是服务名称，通常在 application.properties 或环境变量中的其他地方定义。它有助于按服务组织日志。
示例：如果 service.api.name=myservice，则日志将存储在 /tmp/logs/myservice 中。

logging.file.name=${service.api.name}.v${server.version}

此属性定义日志文件的基本名称。${server.version} 占位符指的是服务的版本。
示例：如果 service.api.name=myservice 且 server.version=1.0，则日志文件将命名为 myservice.v1.0.log。

5. 滚动日志文件模式

logs.pattern.rolling-file-name = ${logging.path} / ${logging.file.name} -%d{yyyy-MM-dd}-%i

此属性定义滚动日志文件模式，用于日志根据时间（例如，每日）和大小滚动时使用。
该模式包括：
${logging.path}：存储日志的目录。
${logging.file.name}：服务名称和版本占位符，确保日志文件名对于服务和版本是唯一的。
%d{yyyy-MM-dd}：日期模式，每天创建一个新的日志文件（例如，myservice.v1.0–2024–10–11.log）。
%i：滚动索引。当日志文件在同一天超过一定大小时，它将附加一个递增索引（例如，myservice.v1.0–2024–10–11–1.log，myservice.v1.0–2024–10–11–2.log）。

6. 最大单个文件大小

logging.file.max-size=10MB

此属性设置单个日志文件在滚动到新文件之前的最大大小。一旦日志文件达到 10MB，Logback 将根据之前定义的滚动文件模式创建一个新文件。这有助于管理日志文件大小并确保单个日志文件不会变得太大，否则可能难以管理。

7. 日志的保留和总大小上限

logging.file.max-history=100
logging.file.total-size-cap=3GB

logging.file.max-history=100:

此属性定义要保留多少天或日志文件。在这种情况下，Logback 将保留日志文件 100 天（或 100 个滚动文件），并且将自动删除较旧的日志。这有助于管理磁盘空间并仅保留最近的日志以供分析。

logging.file.total-size-cap=3GB:

此属性定义所有日志文件的总大小上限。一旦总日志文件大小超过 3GB，Logback 将开始删除最旧的日志文件，即使它们在 100 天的保留期内。这可确保日志文件不会占用太多磁盘空间，并为磁盘空间有限的环境提供保障。

概括：

日志记录级别：您已将 Spring 的 servlet、安全性和 Web 组件的特定日志记录级别设置为 DEBUG，以捕获这些组件的详细信息，同时将全局日志记录级别保持在 INFO 以避免冗长。
日志文件路径和命名：日志文件存储在/tmp/logs/${service.api.name}中，日志文件名包含服务名称和版本，以便于在不同服务或版本之间轻松区分。
滚动日志：日志根据时间（每日）和文件大小（每个文件最大 10MB）滚动。一旦日志超过 10MB，就会创建一个带有递增索引的新文件。
保留：日志文件保存 100 天或直到日志总大小超过 3GB，之后删除较旧的日志。

通过使用这些属性，应用程序可以实现高效的日志管理，在捕获足够的信息和确保日志不会不受控制地增长之间取得平衡，从而导致潜在的磁盘空间问题。

3.Spring Logback 配置

此 logback-spring.xml 配置为 Spring Boot 应用程序定义了动态日志记录设置，允许使用应用程序配置（application.properties 或 application.yml）中定义的属性在JSON和纯文本日志记录格式之间切换。

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="120 seconds">
 <include resource="logback-spring-scope.xml"/>
 <include resource="logback-spring-appenders-text.xml"/>
 <include resource="logback-spring-appenders-json.xml"/>
 
 <!-- 定义条件记录器 --> 
 <!-- 如果日志格式 == JSON --> 
 <if condition='property("LOG_FORMAT").contains("json")'>
  <then>
   <root level="INFO">
    <appender-ref ref="STDOUT_JSON"/>
    <appender-ref ref="ASYNC_JSON"/>
   </root>
   <logger level="info" name="ms-service-info">
    <appender-ref ref="STDOUT_JSON"/>
    <appender-ref ref="ASYNC_JSON"/>
   </logger>
   <logger level="debug" name="io.fusion.air.microservice.adapters.security">
    <appender-ref ref="STDOUT_JSON"/>
    <appender-ref ref="ASYNC_JSON"/>
   </logger>
   <logger  level="trace" name="io.fusion.air.microservice.security.JsonWebTokenValidator">
    <appender-ref ref="STDOUT_JSON"/>
    <appender-ref ref="ASYNC_JSON"/>
   </logger>
  </then>
  <!-- 如果日志格式 == PLAIN --> 
  <else>
   <root level="INFO">
    <appender-ref ref="STDOUT_TEXT"/>
    <appender-ref ref="ASYNC_TEXT"/>
   </root>
   <logger level="info" name="ms-service-info">
    <appender-ref ref="STDOUT_TEXT" />
    <appender-ref ref="ASYNC_TEXT" />
   </logger>
   <logger level="debug" name="io.fusion.air.microservice.adapters.security">
    <appender-ref ref="STDOUT_TEXT" />
    <appender-ref ref="ASYNC_TEXT" />
   </logger>
   <logger  level="trace" name="io.fusion.air.microservice.security.JsonWebTokenValidator">
    <appender-ref ref="STDOUT_TEXT" />
    <appender-ref ref="ASYNC_TEXT" />
   </logger>
  </else>
 </if>
</configuration>

logback-spring.xml配置由多个文件组成，包括：

核心文件：logback-spring.xml
范围文件：logback-spring-scope.xml（资源文件夹）
Appender JSON：logback-spring-appenders-json.xml（资源文件夹）
附加器文本：logback-spring-appenders-text.xml（资源文件夹）

让我们逐一介绍每个部分并解释其目的：

1. 全局配置

<configuration scan="true" scanPeriod="120 seconds">

scan=“true”：如果 logback-spring.xml 文件发生变化，则启用自动重新加载配置。
scanPeriod=“120 秒”：系统每 120 秒检查一次配置的变化，如果检测到任何修改则重新加载。

2. Spring 属性定义 - logback-spring-scope.xml

<included>
   <springProperty scope="context" name="LOG_PATH" source="logging.path"/>
   <springProperty scope="context" name="LOG_FILE" source="logging.file.name"/>
   <springProperty scope="context" name="LOG_FILE_PATTERN" source="logging.pattern.rolling-file-name"/>
   <springProperty scope="context" name="LOG_FILE_MAX_SIZE" source="logging.file.max-size"/>
   <springProperty scope="context" name="LOG_FILE_MAX_HISTORY" source="logging.file.max-history"/>
   <springProperty scope="context" name="LOG_FILE_SIZE_CAP" source="logging.file.total-size-cap"/>
   <springProperty scope="context" name="LOG_FORMAT" source="logging.format"/>
</included>

这些 springProperty 元素从应用程序的 application.properties 或环境变量中提取值。

3. JSON 日志 - logback-spring-appenders-json.xml

控制台 JSON 附加器（所有附加器均在 <included> 标签内）

<appender name="STDOUT_JSON" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp/>
            <loggerName/>
            <logLevel/>
            <message/>
            <threadName/>
            <mdc/>
        </providers>
    </encoder>
</appender>

STDOUT_JSON：使用Logstash 编码器以 JSON 格式将日志输出到控制台。
它包括时间戳、记录器名称、日志级别、消息、线程名称和 MDC（映射诊断上下文）字段等关键元素。

文件 JSON 附加器（所有附加器均位于 <included> 标签内）

<appender name="FILE_JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_PATH}/${LOG_FILE}.json</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>${LOG_FILE_PATTERN}.json</fileNamePattern>
        <maxFileSize>${LOG_FILE_MAX_SIZE}</maxFileSize>
        <maxHistory>${LOG_FILE_MAX_HISTORY}</maxHistory>
        <totalSizeCap>${LOG_FILE_SIZE_CAP}</totalSizeCap>
    </rollingPolicy>
    <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp/>
            <loggerName/>
            <logLevel/>
            <message/>
            <threadName/>
            <mdc/>
        </providers>
    </encoder>
</appender>

FILE_JSON：将日志以 JSON 格式输出到文件。日志会根据文件大小和时间进行滚动更新，达到 maxHistory 或 totalSizeCap 后会删除旧日志。
滚动基于时间（每日）和大小（例如每个文件 10MB）进行。
日志使用 LoggingEventCompositeJsonEncoder 以 JSON 格式存储。

LogStash JSON 搜索器 — logback-spring-appenders-json-logstash.xml

    <!-- 定义 Logstash TCP Appender --> 
    <appender name="TCP_JSON" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <!-- 您的 Logstash 服务器的地址 --> 
        <destination>logstash-host:5000</destination> <!-- 更改为您的 Logstash 主机和端口 -->

        <!-- 可选：JSON 格式的编码器 --> 
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp />
                <loggerName />
                <threadName />
                <logLevel />
                <message />
                <context />
                <mdc />
                <stackTrace />
            </providers>
        </encoder>

        <!-- 可选：如果 Logstash 暂时无法访问，则继续重试 --> 
        <connectionStrategy class="net.logstash.logback.appender.retry.ConnectionStrategy">
            <minDelay>5000</minDelay>  <!-- 5 秒后重试 --> 
            <maxDelay>60000</maxDelay> <!-- 最大重试延迟为 60 秒 -->
        </connectionStrategy>

        <!-- 可选：设置连接丢失时的重新连接延迟 --> 
        <reconnectionDelay>5000</reconnectionDelay> <!-- 如果断开连接，每 5 秒重新连接一次 -->

        <!-- 可选：设置队列大小 --> 
        <queueSize>5000</queueSize>  <!-- 如果 Logstash 不可用，则将事件记录到队列 --> 
    </appender>

可靠的日志传递：LogstashTcpSocketAppender 确保通过持久 TCP 连接将日志发送到 Logstash。如果 Logstash 无法访问，它可以重试连接并暂时将日志事件排队。
JSON 格式：日志以结构化的 JSON 格式发送，使得 Logstash 更容易解析和处理数据。
弹性：通过重试策略、重新连接延迟和缓冲日志事件的队列，此附加器可确保在出现临时网络或 Logstash 可用性问题时不会丢失日志。

4. 纯文本日志记录 - logback-spring-appenders-text.xml

控制台纯文本附加器（所有附加器均位于 <included> 标签内）

<appender name="STDOUT_TEXT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} |Service=%X{Service} |%-5level| %logger{36}:%L |IP=%X{IP}:%X{Port}| Proto=%X{Protocol}| URI=%X{URI}| User=%X{user}| ReqID=%X{ReqId}| %msg%n</pattern>
    </encoder>
</appender>

STDOUT_TEXT：以纯文本格式将日志输出到控制台。日志模式包括：
时间戳、日志级别、记录器名称、行号和 MDC 字段（例如服务、IP、协议、URI、用户、ReqID）。

文件纯文本附加器（所有附加器均在 <included> 标签内）

<appender name="FILE_TEXT" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_PATH}/${LOG_FILE}.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>${LOG_FILE_PATTERN}.log</fileNamePattern>
        <maxFileSize>${LOG_FILE_MAX_SIZE}</maxFileSize>
        <maxHistory>${LOG_FILE_MAX_HISTORY}</maxHistory>
        <totalSizeCap>${LOG_FILE_SIZE_CAP}</totalSizeCap>
    </rollingPolicy>
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} |Service=%X{Service} |%-5level| %logger{36}:%L |IP=%X{IP}:%X{Port}| Proto=%X{Protocol}| URI=%X{URI}| User=%X{user}| ReqID=%X{ReqId}| %msg%n</pattern>
    </encoder>
</appender>

FILE_TEXT：将日志以纯文本格式输出到文件。日志根据文件大小和时间滚动，类似于 JSON 附加器，但采用纯文本格式。

5. 异步日志记录

使用异步日志记录，确保日志写入不会阻塞主线程，从而提高性能。

异步文本记录器（所有附加器均位于 <included> 标签内）

<appender name="ASYNC_TEXT" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="FILE_TEXT" />
    <queueSize>5000</queueSize>
    <discardingThreshold>0</discardingThreshold>
</appender>

ASYNC_TEXT：包装 FILE_TEXT 附加器，启用队列大小为 5000 个事件的异步日志写入。

异步 JSON 记录器（所有附加器均位于 <included> 标签内）

6. 基于格式的条件记录器

配置根据logging.format属性（在application.properties文件中）有条件地在JSON和纯文本日志记录之间切换。

如果格式为 JSON

 <if condition='property("LOG_FORMAT").contains("json")'>
    <then>
       <root level="INFO">
          <appender-ref ref="STDOUT_JSON"/>
          <appender-ref ref="ASYNC_JSON"/>
       </root>
       <logger level="info" name="ms-service-info">
          <appender-ref ref="STDOUT_JSON"/>
          <appender-ref ref="ASYNC_JSON"/>
       </logger>
       <logger level="debug" name="io.fusion.air.microservice.adapters.security">
          <appender-ref ref="STDOUT_JSON"/>
          <appender-ref ref="ASYNC_JSON"/>
       </logger>
       <logger  level="trace" name="io.fusion.air.microservice.security.JsonWebTokenValidator">
          <appender-ref ref="STDOUT_JSON"/>
          <appender-ref ref="ASYNC_JSON"/>
       </logger>
    </then>

展开阅读全文

本文系作者在时代Java发表，未经许可，不得转载。

如有侵权，请联系nowjava@qq.com删除。

编辑于 05-20 14:17:392025-05-20 14:17:39

教程文章

文章订阅