Log dạng văn bản truyền thống nhanh chóng trở nên khó kiểm soát trên production. Với hàng trăm instance sinh ra hàng nghìn dòng mỗi giây, việc tìm một lỗi cụ thể trở thành ác mộng. Log có cấu trúc dạng JSON thay đổi tình hình này vì mỗi sự kiện đều có thể truy vấn và phân tích tự động.

Điểm chính

Spring Boot 4.x (dựa trên Spring Framework 7) hỗ trợ native cho structured logging JSON với các định dạng ECS, Logstash và GELF. Starter spring-boot-starter-opentelemetry mới cung cấp observability thống nhất mà không cần thư viện ngoài.

Vì sao Nên Áp dụng Structured Logging trong Spring Boot

Hạn chế của Log Văn bản Truyền thống

Một log văn bản điển hình trông như sau:

text

2026-08-22 10:15:32.456 INFO  [order-service,abc123] c.e.s.OrderService - Order created for user john@example.com, amount: 150.00€, items: 3

Định dạng này gây ra nhiều vấn đề trên production. Việc trích xuất thông tin cụ thể đòi hỏi các regex phức tạp và mong manh. Việc tương quan giữa các service buộc phải có quy ước nghiêm ngặt mà mỗi đội lại diễn giải theo cách khác nhau. Các công cụ phân tích như Elasticsearch khó lòng index hiệu quả các chuỗi không có cấu trúc này.

Lợi ích của Định dạng JSON

Cùng sự kiện đó ở dạng JSON có thể khai thác ngay lập tức:

json

{
  "@timestamp": "2026-08-22T10:15:32.456Z",
  "level": "INFO",
  "logger": "com.example.service.OrderService",
  "message": "Order created",
  "service": "order-service",
  "traceId": "abc123",
  "userId": "john@example.com",
  "orderId": "ORD-789456",
  "amount": 150.00,
  "currency": "EUR",
  "itemCount": 3
}

Mỗi trường đều có thể lọc và tổng hợp. Một truy vấn Elasticsearch có thể tìm ngay tất cả đơn hàng trên 100 € trong mười lăm phút gần nhất. Các dashboard Kibana trực quan hóa xu hướng mà không cần parsing thủ công. Điều này đặc biệt liên quan trong các câu hỏi phỏng vấn Spring Boot, nơi hiểu biết về các pattern observability production phân biệt ứng viên cấp cao.

Cấu hình Native Structured Logging của Spring Boot 4.x

Bật Log JSON có Cấu trúc

Spring Boot 4.x, dựa trên Spring Framework 7, giới thiệu hỗ trợ mature cho structured logging thông qua thuộc tính logging.structured. Cách tiếp cận này không cần thêm phụ thuộc nào và tích hợp trực tiếp với Logback 1.5.38.

yaml

# application.yml
# Native structured logging configuration for Spring Boot 4.x
logging:
  structured:
    # Output format: ecs (Elastic), logstash, gelf
    format:
      console: ecs
      file: ecs
  file:
    name: /var/log/app/application.log
  level:
    root: INFO
    com.example: DEBUG

Định dạng ECS (Elastic Common Schema) đảm bảo tương thích trực tiếp với Elasticsearch và Kibana mà không cần cấu hình bổ sung.

Tùy biến các Trường JSON

Để thêm các trường nghiệp vụ vào mỗi log, Spring Boot cho phép cấu hình các thuộc tính bổ sung.

yaml

# application.yml
# Custom fields in structured logs
logging:
  structured:
    format:
      console: ecs
    ecs:
      # Service information added to every log
      service:
        name: ${spring.application.name}
        version: ${app.version:1.0.0}
        environment: ${spring.profiles.active:default}
        node-name: ${HOSTNAME:unknown}

LoggingConfig.javajava

// Programmatic configuration for additional fields
package com.example.logging.config;

import org.springframework.boot.logging.structured.StructuredLogFormatterCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LoggingConfig {

    @Bean
    StructuredLogFormatterCustomizer<EcsStructuredLogFormatter> ecsCustomizer() {
        return formatter -> formatter
            // Adds static fields to all logs
            .addStaticField("team", "backend")
            .addStaticField("region", System.getenv("AWS_REGION"))
            // Customizes exception formatting
            .setIncludeStacktrace(true)
            .setStacktraceMaxLength(5000);
    }
}

Các trường này xuất hiện trong mọi dòng log, giúp lọc theo đội nhóm hoặc khu vực trên dashboard.

OpenTelemetry Starter cho Observability Toàn diện

Tiêu chuẩn Mới trong Spring Boot 4

Spring Boot 4.0 giới thiệu spring-boot-starter-opentelemetry, thay thế setup multi-dependency phức tạp trước đây. Một dependency duy nhất này cung cấp observability vendor-neutral bao gồm traces, metrics và log correlation.

xml

<!-- pom.xml -->
<!-- OpenTelemetry starter for Spring Boot 4.x -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-opentelemetry</artifactId>
</dependency>
<!-- Log correlation for Logback -->
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-logback-appender-1.0</artifactId>
    <version>2.21.0-alpha</version>
</dependency>

Starter này bao gồm OpenTelemetry API, Micrometer tracing bridge và OTLP exporters. Spring Cloud Sleuth hiện được coi là legacy, với OpenTelemetry là tiêu chuẩn ngành cho distributed tracing.

Cấu hình OpenTelemetry với Structured Logs

yaml

# application.yml
# OpenTelemetry configuration with structured logging
spring:
  application:
    name: order-service
    group: commerce

otel:
  exporter:
    otlp:
      endpoint: http://otel-collector:4317
      protocol: grpc
  resource:
    attributes:
      service.namespace: production
      deployment.environment: prod

logging:
  structured:
    format:
      console: ecs
  pattern:
    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"

Trace và span ID được tự động inject vào MDC, tương quan log với distributed traces xuyên suốt các service. Để biết thêm về setup monitoring production, xem hướng dẫn Spring Boot Actuator với Micrometer và Prometheus.

Thông báo Deprecation

ZipkinWithOpenTelemetryTracingAutoConfiguration đã deprecated và được lên lịch xóa trong Spring Boot 4.2. Hãy chuyển sang native OTLP exporters để tương thích trong tương lai.

Cấu hình Logback Cổ điển với JSON Encoder

Logstash Encoder cho Tùy biến Nâng cao

Với các nhu cầu tùy biến nâng cao hoặc khi chuyển từ các phiên bản Spring Boot cũ, Logstash Logback Encoder 9.0 vẫn khả dụng. Lưu ý rằng phiên bản 9.0 yêu cầu Jackson 3.0 và tối thiểu Java 17.

xml

<!-- pom.xml -->
<!-- Dependency for JSON logging with Logback (Jackson 3 required) -->
<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>9.0</version>
</dependency>

Cấu hình Logback Đầy đủ

File logback-spring.xml cung cấp toàn quyền kiểm soát định dạng đầu ra.

xml

<!-- src/main/resources/logback-spring.xml -->
<!-- Logback configuration for structured JSON logs -->
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- Spring Boot properties -->
    <springProperty scope="context" name="appName" source="spring.application.name" defaultValue="app"/>
    <springProperty scope="context" name="appVersion" source="app.version" defaultValue="1.0.0"/>

    <!-- JSON console appender for production -->
    <appender name="JSON_CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <!-- Custom fields added to every log -->
            <customFields>{"service":"${appName}","version":"${appVersion}"}</customFields>
            <!-- Includes MDC (tracing context) -->
            <includeMdcKeyName>traceId</includeMdcKeyName>
            <includeMdcKeyName>spanId</includeMdcKeyName>
            <includeMdcKeyName>userId</includeMdcKeyName>
            <includeMdcKeyName>requestId</includeMdcKeyName>
            <!-- ISO8601 timestamp format -->
            <timestampPattern>yyyy-MM-dd'T'HH:mm:ss.SSSZ</timestampPattern>
            <!-- Complete stack traces -->
            <throwableConverter class="net.logstash.logback.stacktrace.ShortenedThrowableConverter">
                <maxDepthPerThrowable>30</maxDepthPerThrowable>
                <maxLength>4096</maxLength>
                <shortenedClassNameLength>36</shortenedClassNameLength>
                <rootCauseFirst>true</rootCauseFirst>
            </throwableConverter>
        </encoder>
    </appender>

    <!-- Rolling JSON file appender -->
    <appender name="JSON_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>/var/log/${appName}/application.json</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>/var/log/${appName}/application.%d{yyyy-MM-dd}.%i.json.gz</fileNamePattern>
            <maxHistory>30</maxHistory>
            <maxFileSize>100MB</maxFileSize>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <customFields>{"service":"${appName}","version":"${appVersion}"}</customFields>
        </encoder>
    </appender>

    <!-- Text appender for development -->
    <appender name="TEXT_CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Activation by Spring profile -->
    <springProfile name="prod,staging">
        <root level="INFO">
            <appender-ref ref="JSON_CONSOLE"/>
            <appender-ref ref="JSON_FILE"/>
        </root>
    </springProfile>

    <springProfile name="dev,local">
        <root level="DEBUG">
            <appender-ref ref="TEXT_CONSOLE"/>
        </root>
    </springProfile>
</configuration>

Cấu hình này chỉ bật log JSON ở môi trường production, đồng thời giữ log dễ đọc ở môi trường phát triển.

MDC cho Distributed Tracing

Lan truyền Context Trace

MDC (Mapped Diagnostic Context) bổ sung vào mỗi log những thông tin context như request id hay trace id.

TracingFilter.javajava

// Filter for automatic trace context injection
package com.example.logging.filter;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;
import java.util.UUID;

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TracingFilter extends OncePerRequestFilter {

    // Standard MDC keys for tracing
    private static final String TRACE_ID_KEY = "traceId";
    private static final String SPAN_ID_KEY = "spanId";
    private static final String REQUEST_ID_KEY = "requestId";
    private static final String USER_ID_KEY = "userId";

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        try {
            // Retrieve or generate trace identifiers
            String traceId = extractOrGenerate(request, "X-Trace-Id", TRACE_ID_KEY);
            String spanId = generateSpanId();
            String requestId = extractOrGenerate(request, "X-Request-Id", REQUEST_ID_KEY);
            String userId = request.getHeader("X-User-Id");

            // Inject into MDC to appear in all logs
            MDC.put(TRACE_ID_KEY, traceId);
            MDC.put(SPAN_ID_KEY, spanId);
            MDC.put(REQUEST_ID_KEY, requestId);
            if (userId != null) {
                MDC.put(USER_ID_KEY, userId);
            }

            // Propagate to responses for inter-service chaining
            response.setHeader("X-Trace-Id", traceId);
            response.setHeader("X-Request-Id", requestId);

            filterChain.doFilter(request, response);

        } finally {
            // Clean MDC after each request
            MDC.clear();
        }
    }

    private String extractOrGenerate(HttpServletRequest request, String header, String key) {
        String value = request.getHeader(header);
        return value != null ? value : UUID.randomUUID().toString().replace("-", "").substring(0, 16);
    }

    private String generateSpanId() {
        return UUID.randomUUID().toString().replace("-", "").substring(0, 8);
    }
}

Mọi log phát ra trong quá trình xử lý request sẽ tự động chứa các id này.

Sử dụng MDC trong Code Nghiệp vụ

OrderService.javajava

// Business service with enriched contextual logging
package com.example.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    public Order createOrder(CreateOrderRequest request) {
        // Add business information to MDC context
        MDC.put("orderId", request.getOrderId());
        MDC.put("customerId", request.getCustomerId());

        try {
            log.info("Creating order with {} items", request.getItems().size());

            // Business logic...
            Order order = processOrder(request);

            log.info("Order created successfully, total: {} {}",
                order.getTotal(), order.getCurrency());

            return order;

        } catch (Exception e) {
            // Exception appears with full MDC context
            log.error("Failed to create order", e);
            throw e;
        } finally {
            // Clean business keys added
            MDC.remove("orderId");
            MDC.remove("customerId");
        }
    }
}

Log JSON sinh ra chứa toàn bộ thông tin cần thiết cho việc debug:

json

{
  "@timestamp": "2026-08-22T10:15:32.456Z",
  "level": "INFO",
  "logger": "com.example.service.OrderService",
  "message": "Order created successfully, total: 150.00 EUR",
  "traceId": "a1b2c3d4e5f67890",
  "spanId": "12345678",
  "requestId": "req-abc-123",
  "userId": "user-456",
  "orderId": "ORD-789",
  "customerId": "CUST-321"
}

Sẵn sàng chinh phục phỏng vấn Spring Boot?

Luyện tập với mô phỏng tương tác, flashcards và bài kiểm tra kỹ thuật.

Khám phá Spring Boot

Logging Bất đồng bộ cho Hiệu năng

Cấu hình Thread Pool

Ở production, các thao tác ghi log đồng bộ ảnh hưởng đến độ trễ của request. Appender bất đồng bộ tách phần logging ra khỏi luồng chính.

xml

<!-- logback-spring.xml -->
<!-- High-performance asynchronous appender configuration -->
<appender name="ASYNC_JSON" class="ch.qos.logback.classic.AsyncAppender">
    <!-- Pending log buffer size -->
    <queueSize>1024</queueSize>
    <!-- Never block the calling thread -->
    <neverBlock>true</neverBlock>
    <!-- Threshold before dropping DEBUG/TRACE logs -->
    <discardingThreshold>20</discardingThreshold>
    <!-- Include caller information (expensive) -->
    <includeCallerData>false</includeCallerData>
    <!-- Actual appender for writing -->
    <appender-ref ref="JSON_FILE"/>
</appender>

<springProfile name="prod">
    <root level="INFO">
        <appender-ref ref="ASYNC_JSON"/>
    </root>
</springProfile>

Sửa lỗi nghiêm trọng trong Spring Boot 4.1.1

Spring Boot 4.1.1 đã sửa một vấn đề nghiêm trọng khi JSON encode thất bại có thể làm hỏng event log tiếp theo trên cùng thread (#51371). Hãy nâng cấp từ 4.0.x hoặc 4.1.0 để tránh log corruption không được phát hiện.

Metrics của Hệ thống Logging

Giám sát chính hệ thống logging giúp tránh việc mất log một cách âm thầm.

LoggingMetrics.javajava

// Exposing Logback metrics via Micrometer
package com.example.logging.metrics;

import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.Appender;
import ch.qos.logback.classic.AsyncAppender;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import jakarta.annotation.PostConstruct;
import java.util.Iterator;

@Component
public class LoggingMetrics {

    private final MeterRegistry registry;

    public LoggingMetrics(MeterRegistry registry) {
        this.registry = registry;
    }

    @PostConstruct
    void registerMetrics() {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        Logger rootLogger = context.getLogger(Logger.ROOT_LOGGER_NAME);

        // Iterate through appenders to find AsyncAppenders
        Iterator<Appender<ILoggingEvent>> it = rootLogger.iteratorForAppenders();
        while (it.hasNext()) {
            Appender<ILoggingEvent> appender = it.next();
            if (appender instanceof AsyncAppender asyncAppender) {
                registerAsyncMetrics(asyncAppender);
            }
        }
    }

    private void registerAsyncMetrics(AsyncAppender appender) {
        String appenderName = appender.getName();

        // Current queue size
        Gauge.builder("logback.async.queue.size", appender, AsyncAppender::getQueueSize)
            .tag("appender", appenderName)
            .description("Current async appender queue size")
            .register(registry);

        // Remaining capacity
        Gauge.builder("logback.async.queue.remaining", appender, AsyncAppender::getRemainingCapacity)
            .tag("appender", appenderName)
            .description("Remaining capacity in async queue")
            .register(registry);

        // Number of dropped logs
        Gauge.builder("logback.async.discarded", appender, AsyncAppender::getNumberOfElementsInQueue)
            .tag("appender", appenderName)
            .description("Number of discarded log events")
            .register(registry);
    }
}

Cảnh báo Prometheus với điều kiện logback.async.queue.remaining < 100 cảnh báo nguy cơ mất log.

Tích hợp ELK Stack

Cấu hình Filebeat

Filebeat thu thập các file JSON và gửi về Elasticsearch mà không cần biến đổi.

yaml

# filebeat.yml
# Filebeat configuration for Spring Boot JSON logs
filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/*/application.json
    # Automatic JSON parsing
    json:
      keys_under_root: true
      overwrite_keys: true
      add_error_key: true
      message_key: message

processors:
  # Add Kubernetes metadata if available
  - add_kubernetes_metadata:
      host: ${NODE_NAME}
      matchers:
        - logs_path:
            logs_path: "/var/log/containers/"
  # Parse timestamp
  - timestamp:
      field: "@timestamp"
      layouts:
        - '2006-01-02T15:04:05.000Z'
        - '2006-01-02T15:04:05.000-07:00'
      test:
        - '2026-08-22T10:15:32.456Z'

output.elasticsearch:
  hosts: ["elasticsearch:9200"]
  index: "logs-%{[service]}-%{+yyyy.MM.dd}"
  pipeline: "spring-boot-logs"

setup.template:
  name: "logs"
  pattern: "logs-*"

Pipeline Elasticsearch để Làm giàu Dữ liệu

json

{
  "description": "Spring Boot logs enrichment",
  "processors": [
    {
      "geoip": {
        "field": "client.ip",
        "target_field": "client.geo",
        "ignore_missing": true
      }
    },
    {
      "user_agent": {
        "field": "user_agent.original",
        "target_field": "user_agent",
        "ignore_missing": true
      }
    },
    {
      "set": {
        "field": "event.ingested",
        "value": "{{_ingest.timestamp}}"
      }
    },
    {
      "script": {
        "description": "Classify log level severity",
        "source": "def level = ctx.level; if (level == 'ERROR') ctx.severity = 4; else if (level == 'WARN') ctx.severity = 3; else if (level == 'INFO') ctx.severity = 2; else ctx.severity = 1;"
      }
    }
  ]
}

Best Practice Production cho Logging Spring Boot

Thông tin Cần đưa vào Một cách Có hệ thống

Mỗi log nên chứa lượng thông tin tối thiểu phục vụ debug và đối chiếu.

StructuredLogger.javajava

// Helper for consistent structured logs
package com.example.logging;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import java.util.Map;
import java.util.function.Supplier;

public final class StructuredLogger {

    private final Logger delegate;

    private StructuredLogger(Class<?> clazz) {
        this.delegate = LoggerFactory.getLogger(clazz);
    }

    public static StructuredLogger getLogger(Class<?> clazz) {
        return new StructuredLogger(clazz);
    }

    // Log with temporary business context
    public void info(String message, Map<String, String> context) {
        try {
            context.forEach(MDC::put);
            delegate.info(message);
        } finally {
            context.keySet().forEach(MDC::remove);
        }
    }

    // Log with supplier for lazy evaluation
    public void debug(Supplier<String> messageSupplier, Map<String, String> context) {
        if (delegate.isDebugEnabled()) {
            try {
                context.forEach(MDC::put);
                delegate.debug(messageSupplier.get());
            } finally {
                context.keySet().forEach(MDC::remove);
            }
        }
    }

    // Error log with full context
    public void error(String message, Throwable t, Map<String, String> context) {
        try {
            context.forEach(MDC::put);
            delegate.error(message, t);
        } finally {
            context.keySet().forEach(MDC::remove);
        }
    }
}

java

// Usage in business code
private static final StructuredLogger log = StructuredLogger.getLogger(PaymentService.class);

public void processPayment(Payment payment) {
    log.info("Processing payment", Map.of(
        "paymentId", payment.getId(),
        "amount", String.valueOf(payment.getAmount()),
        "currency", payment.getCurrency(),
        "method", payment.getMethod().name()
    ));
}

Thông tin Nhạy cảm Cần loại trừ

Log không bao giờ được chứa dữ liệu cá nhân hoặc nhạy cảm.

SensitiveDataFilter.javajava

// Sensitive data masking utility
package com.example.logging.filter;

import java.util.regex.Pattern;

public final class SensitiveDataFilter {

    // Sensitive data patterns to mask
    private static final Pattern EMAIL_PATTERN =
        Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");
    private static final Pattern CREDIT_CARD_PATTERN =
        Pattern.compile("\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b");
    private static final Pattern PASSWORD_PATTERN =
        Pattern.compile("(?i)(password|pwd|secret|token)[\"']?\\s*[:=]\\s*[\"']?[^\\s,}\"']+");

    private SensitiveDataFilter() {}

    // Utility method to mask data
    public static String maskSensitiveData(String input) {
        if (input == null) return null;

        String result = input;
        result = EMAIL_PATTERN.matcher(result).replaceAll("[EMAIL_MASKED]");
        result = CREDIT_CARD_PATTERN.matcher(result).replaceAll("[CARD_MASKED]");
        result = PASSWORD_PATTERN.matcher(result).replaceAll("$1=[REDACTED]");

        return result;
    }
}

Mức Log Phù hợp

Level	Trường hợp sử dụng	Ví dụ
ERROR	Thất bại cần can thiệp	Exception không thể phục hồi, thất bại giao dịch nghiêm trọng, dịch vụ ngoài không khả dụng
WARN	Tình huống bất thường nhưng được xử lý	Đang retry, hiệu năng suy giảm, tài nguyên gần đạt giới hạn
INFO	Sự kiện nghiệp vụ quan trọng	Bắt đầu/kết thúc giao dịch, thay đổi trạng thái quan trọng, hành động người dùng chính
DEBUG	Thông tin chẩn đoán	Chi tiết thực thi, giá trị biến quan trọng, quyết định rẽ nhánh
TRACE	Chi tiết rất nhỏ	Entry/exit method, nội dung object đầy đủ, vòng lặp và iteration

Kiểm thử và Xác thực Structured Logs

Unit Test cho Cấu trúc JSON

StructuredLoggingTest.javajava

// Structured log validation tests
package com.example.logging;

import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import static org.assertj.core.api.Assertions.assertThat;

class StructuredLoggingTest {

    private ListAppender<ILoggingEvent> listAppender;
    private Logger logger;

    @BeforeEach
    void setUp() {
        logger = (Logger) LoggerFactory.getLogger(StructuredLoggingTest.class);
        listAppender = new ListAppender<>();
        listAppender.start();
        logger.addAppender(listAppender);
    }

    @Test
    void shouldIncludeMdcFieldsInLog() {
        // Given
        MDC.put("traceId", "test-trace-123");
        MDC.put("userId", "user-456");

        // When
        logger.info("Test message with MDC context");

        // Then
        ILoggingEvent event = listAppender.list.get(0);
        assertThat(event.getMDCPropertyMap())
            .containsEntry("traceId", "test-trace-123")
            .containsEntry("userId", "user-456");

        MDC.clear();
    }

    @Test
    void shouldLogExceptionWithStackTrace() {
        // Given
        Exception testException = new RuntimeException("Test error");

        // When
        logger.error("Operation failed", testException);

        // Then
        ILoggingEvent event = listAppender.list.get(0);
        assertThat(event.getThrowableProxy()).isNotNull();
        assertThat(event.getThrowableProxy().getMessage()).isEqualTo("Test error");
    }
}

Để biết các pattern integration testing hoạt động tốt với structured logging, xem hướng dẫn Testcontainers Spring Boot integration testing.

Nguồn tham khảo

Spring Boot 4.1.0 Release Announcement - Các tính năng Spring Boot 4.1.0 bao gồm cập nhật observability
Spring Boot GitHub Releases - Bản sửa lỗi version 4.1.1 cho JSON encode corruption (#51371)
Logstash Logback Encoder 9.0 - Migration Jackson 3 và yêu cầu Java 17
OpenTelemetry with Spring Boot - Hướng dẫn tích hợp OpenTelemetry chính thức

Checklist Structured Logging cho Spring Boot 4.x

Native structured logging với định dạng ECS, Logstash hoặc GELF chỉ cần cấu hình logging.structured.format
spring-boot-starter-opentelemetry thay thế setup Sleuth legacy bằng observability vendor-neutral
MDC truyền các identifier trace tự động giữa các service
Appender async với neverBlock=true ngăn logging ảnh hưởng đến latency request
Logstash Logback Encoder 9.0 yêu cầu Jackson 3.0 và Java 17
Spring Boot 4.1.1 sửa bug nghiêm trọng về JSON encoding ảnh hưởng concurrent threads
Masking dữ liệu nhạy cảm đảm bảo tuân thủ GDPR trong log production
Metrics về capacity của async queue cho phép alerting trước khi xảy ra mất log

Bắt đầu luyện tập!

Kiểm tra kiến thức với mô phỏng phỏng vấn và bài kiểm tra kỹ thuật.

Tạo tài khoản miễn phí

Spring Boot Structured Logging 2026: Log JSON cho Production với Logback và OpenTelemetry

Vì sao Nên Áp dụng Structured Logging trong Spring Boot

Hạn chế của Log Văn bản Truyền thống

Lợi ích của Định dạng JSON

Cấu hình Native Structured Logging của Spring Boot 4.x

Bật Log JSON có Cấu trúc

Tùy biến các Trường JSON

OpenTelemetry Starter cho Observability Toàn diện

Tiêu chuẩn Mới trong Spring Boot 4

Cấu hình OpenTelemetry với Structured Logs

Cấu hình Logback Cổ điển với JSON Encoder

Logstash Encoder cho Tùy biến Nâng cao

Cấu hình Logback Đầy đủ

MDC cho Distributed Tracing

Lan truyền Context Trace

Sử dụng MDC trong Code Nghiệp vụ

Sẵn sàng chinh phục phỏng vấn Spring Boot?

Logging Bất đồng bộ cho Hiệu năng

Cấu hình Thread Pool

Metrics của Hệ thống Logging

Tích hợp ELK Stack

Cấu hình Filebeat

Pipeline Elasticsearch để Làm giàu Dữ liệu

Best Practice Production cho Logging Spring Boot

Thông tin Cần đưa vào Một cách Có hệ thống

Thông tin Nhạy cảm Cần loại trừ

Mức Log Phù hợp

Kiểm thử và Xác thực Structured Logs

Unit Test cho Cấu trúc JSON

Nguồn tham khảo

Checklist Structured Logging cho Spring Boot 4.x

Bắt đầu luyện tập!

Bạn có tìm ra lỗi trong Spring Boot không?

Bài viết liên quan

Observability trong Spring Boot 2026: OpenTelemetry, Distributed Tracing va Cau hoi Phong van

Spring Boot Actuator: Giám Sát Sản Xuất với Micrometer và Prometheus

Spring Boot YAML vs Properties: So Sánh Cấu Hình và Câu Hỏi Phỏng Vấn 2026