I log testuali tradizionali diventano rapidamente ingestibili in produzione. Con centinaia di istanze che generano migliaia di righe al secondo, cercare un errore specifico si trasforma in un incubo. I log strutturati in JSON ribaltano la situazione rendendo ogni evento interrogabile e analizzabile in modo automatico.

Punto chiave

Spring Boot 4.x (basato su Spring Framework 7) supporta nativamente il logging strutturato in JSON con formati ECS, Logstash e GELF. Il nuovo spring-boot-starter-opentelemetry fornisce observability unificata senza dipendenze esterne.

Perché adottare il logging strutturato in Spring Boot

Limiti dei log testuali tradizionali

Un log testuale tipico ha questo aspetto:

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

Questo formato pone diversi problemi in produzione. Estrarre informazioni specifiche richiede regex complesse e fragili. La correlazione tra servizi impone convenzioni rigide che ogni team interpreta a modo proprio. Strumenti di analisi come Elasticsearch faticano a indicizzare in modo efficiente queste stringhe non strutturate.

Vantaggi del formato JSON

Lo stesso evento in JSON diventa immediatamente sfruttabile:

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
}

Ogni campo diventa filtrabile e aggregabile. Una query Elasticsearch trova all'istante tutti gli ordini superiori a 100 € degli ultimi quindici minuti. Le dashboard Kibana visualizzano i trend senza parsing manuale. Questo aspetto risulta particolarmente rilevante nelle domande di colloquio su Spring Boot, dove la comprensione dei pattern di observability in produzione distingue i candidati senior.

Configurazione nativa del logging strutturato in Spring Boot 4.x

Attivare i log JSON strutturati

Spring Boot 4.x, basato su Spring Framework 7, introduce un supporto maturo al logging strutturato tramite la proprietà logging.structured. Questo approccio non richiede alcuna dipendenza aggiuntiva e si integra direttamente con 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

Il formato ECS (Elastic Common Schema) garantisce compatibilità diretta con Elasticsearch e Kibana senza configurazione aggiuntiva.

Personalizzare i campi JSON

Per aggiungere campi di business a ogni log, Spring Boot consente di configurare attributi extra.

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);
    }
}

Questi campi compaiono in ogni riga di log e facilitano il filtraggio per team o regione nelle dashboard.

OpenTelemetry Starter per observability completa

Il nuovo standard in Spring Boot 4

Spring Boot 4.0 introduce spring-boot-starter-opentelemetry, sostituendo la complessa configurazione multi-dipendenza delle versioni precedenti. Questa singola dipendenza fornisce observability vendor-neutral con trace, metriche e correlazione dei log.

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>

Questo starter include l'API OpenTelemetry, il bridge Micrometer tracing e gli exporter OTLP. Spring Cloud Sleuth è ora considerato legacy, con OpenTelemetry come standard di settore per il tracing distribuito.

Configurare OpenTelemetry con i log strutturati

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:-}]"

Gli ID di trace e span vengono iniettati automaticamente nel MDC, correlando i log con le trace distribuite tra i servizi. Per approfondimenti sul monitoring in produzione, consultare la guida su Spring Boot Actuator con Micrometer e Prometheus.

Avviso di deprecazione

ZipkinWithOpenTelemetryTracingAutoConfiguration è deprecato e verrà rimosso in Spring Boot 4.2. Per compatibilità futura, migrare agli exporter OTLP nativi.

Configurazione classica di Logback con encoder JSON

Logstash Encoder per personalizzazione avanzata

Per esigenze di personalizzazione avanzata o durante la migrazione da versioni precedenti di Spring Boot, Logstash Logback Encoder 9.0 rimane disponibile. La versione 9.0 richiede Jackson 3.0 e Java 17 come minimo.

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>

Configurazione Logback completa

Il file logback-spring.xml offre il controllo totale sul formato di output.

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>

Questa configurazione attiva i log JSON solo in produzione, conservando log leggibili in sviluppo.

MDC per il tracing distribuito

Propagazione del contesto di trace

MDC (Mapped Diagnostic Context) arricchisce ogni log con informazioni di contesto come gli identificatori di richiesta o di trace.

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);
    }
}

Ogni log emesso durante l'elaborazione della richiesta conterrà automaticamente questi identificatori.

Uso di MDC nel codice di business

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");
        }
    }
}

Il log JSON risultante contiene tutte le informazioni necessarie per il debugging:

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"
}

Pronto a superare i tuoi colloqui su Spring Boot?

Pratica con i nostri simulatori interattivi, flashcards e test tecnici.

Esplora Spring Boot

Logging asincrono per le performance

Configurazione del thread pool

In produzione, le scritture sincrone dei log incidono sulla latenza delle richieste. L'appender asincrono disaccoppia il logging dal thread principale.

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>

Bugfix critico in Spring Boot 4.1.1

Spring Boot 4.1.1 corregge un problema critico in cui un encode JSON fallito poteva corrompere l'evento di log successivo sullo stesso thread (#51371). Aggiornare da 4.0.x o 4.1.0 per evitare corruzione silenziosa dei log.

Metriche del sistema di logging

Monitorare il sistema di logging stesso evita la perdita silenziosa dei log.

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);
    }
}

Un alert Prometheus su logback.async.queue.remaining < 100 segnala il rischio di perdita di log.

Integrazione con ELK Stack

Configurazione di Filebeat

Filebeat raccoglie i file JSON e li invia a Elasticsearch senza trasformazioni.

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 per l'arricchimento

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 in produzione per il logging Spring Boot

Informazioni da includere in modo sistematico

Ogni log deve contenere il minimo di informazioni utili per il debugging e la correlazione.

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()
    ));
}

Informazioni sensibili da escludere

I log non devono mai contenere dati personali o sensibili.

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;
    }
}

Livelli di log adeguati

Livello	Caso d'uso	Esempi
ERROR	Errore che richiede intervento	Eccezioni non recuperabili, fallimenti critici di transazione, indisponibilità di servizi esterni
WARN	Situazione anomala ma gestita	Retry in corso, degrado delle performance, risorse prossime ai limiti
INFO	Eventi di business significativi	Inizio/fine transazione, cambiamenti di stato importanti, azioni utente chiave
DEBUG	Informazioni diagnostiche	Dettagli di esecuzione, valori di variabili importanti, decisioni di branching
TRACE	Dettagli molto fini	Entry/exit di metodi, contenuti completi di oggetti, loop e iterazioni

Test e validazione dei log strutturati

Test unitari sulla struttura 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");
    }
}

Per pattern di integration testing che funzionano bene con il logging strutturato, consultare la guida a Testcontainers con Spring Boot.

Sources

Spring Boot 4.1.0 Release Announcement - Funzionalità di Spring Boot 4.1.0 inclusi aggiornamenti di observability
Spring Boot GitHub Releases - Bugfix versione 4.1.1 per corruzione JSON encode (#51371)
Logstash Logback Encoder 9.0 - Migrazione a Jackson 3 e requisito Java 17
OpenTelemetry with Spring Boot - Guida ufficiale all'integrazione OpenTelemetry

Checklist per il logging strutturato in Spring Boot 4.x

Il logging strutturato nativo con formato ECS, Logstash o GELF richiede solo la configurazione logging.structured.format
Il spring-boot-starter-opentelemetry sostituisce i setup legacy Sleuth con observability vendor-neutral
MDC propaga automaticamente gli ID di trace tra i servizi
Gli appender asincroni con neverBlock=true evitano che il logging influisca sulla latenza delle richieste
Logstash Logback Encoder 9.0 richiede Jackson 3.0 e Java 17
Spring Boot 4.1.1 corregge un bug critico di encoding JSON che interessava thread concorrenti
Il mascheramento dei dati sensibili garantisce la conformità GDPR nei log di produzione
Le metriche sulla capacità della coda asincrona permettono di creare alert prima della perdita dei log

Inizia a praticare!

Metti alla prova le tue conoscenze con i nostri simulatori di colloquio e test tecnici.

Crea il mio account gratuito

Logging strutturato in Spring Boot 2026: log JSON per la produzione con Logback e OpenTelemetry

Perché adottare il logging strutturato in Spring Boot

Limiti dei log testuali tradizionali

Vantaggi del formato JSON

Configurazione nativa del logging strutturato in Spring Boot 4.x

Attivare i log JSON strutturati

Personalizzare i campi JSON

OpenTelemetry Starter per observability completa

Il nuovo standard in Spring Boot 4

Configurare OpenTelemetry con i log strutturati

Configurazione classica di Logback con encoder JSON

Logstash Encoder per personalizzazione avanzata

Configurazione Logback completa

MDC per il tracing distribuito

Propagazione del contesto di trace

Uso di MDC nel codice di business

Pronto a superare i tuoi colloqui su Spring Boot?

Logging asincrono per le performance

Configurazione del thread pool

Metriche del sistema di logging

Integrazione con ELK Stack

Configurazione di Filebeat

Pipeline Elasticsearch per l'arricchimento

Best practice in produzione per il logging Spring Boot

Informazioni da includere in modo sistematico

Informazioni sensibili da escludere

Livelli di log adeguati

Test e validazione dei log strutturati

Test unitari sulla struttura JSON

Sources

Checklist per il logging strutturato in Spring Boot 4.x

Inizia a praticare!

Sapresti trovare il bug in Spring Boot?

Articoli correlati

Spring Boot Actuator: Monitoraggio in Produzione con Micrometer e Prometheus

Spring Boot Observability nel 2026: OpenTelemetry, Distributed Tracing e Domande per Colloqui

Spring Boot YAML vs Properties: Confronto Configurazioni e Domande da Colloquio 2026