Logging in Spring Boot can be optimized to enhance system throughput by adjusting logging strategies. This analysis uses Log4j2 integration as an example to explain how logging operates within the Spring Boot framework. The principles are similar for Logback, making it easy to transition between logging frameworks.

Versions:

• Spring Boot: 2.7.2
• Log4j2: 2.17.2

Log4j2 Core Architecture

When logging with Log4j2, the Logger object is the primary interface for outputting log messages. A Logger acts as a facade, with its behavior dictated by an associated LoggerConfig object. The LoggerConfig determines which Appender objects are used for output and sets the logging level.

LoggerConfig and Appender instances are typically defined in a configuration file, such as log4j2.xml. During initialization, Log4j2 loads this file and parses it into a Configuration object. Each entry under <Appenders> adds an Appender to the Configuration's appenders list, while entries under <Loggers> add LoggerConfigs to loggerConfigs, establishing relationships between LoggerConfigs and Appenders.

A LoggerContext holds the Configuration and manages Logger instances. When a Logger is requested, LoggerContext checks its registry; if not found, it creates a new Logger, associates it with the appropriate LoggerConfig from the Configuration, and caches it. This structure allows easy modifications, such as dynamic log level updates, by accessing the Configuration via LoggerContext.

In Spring Boot, operations on a Logger (e.g., setting the level for a Logger named com.example.App) are abstracted. Underneath, Log4j2 adjusts the corresponding LoggerConfig's level, while Logback directly modifies the Logger.

Spring Boot Logging Configuration

Spring Boot provides configuration properties for logging, even when using a custom Log4j2 configuration file. Key properties include:

• logging.file.name: Specifies a file name for log output (e.g., test.log in the project root).
• logging.file.path: Defines a directory for log output, with logs written to spring.log in that directory.
• logging.level: Sets the log level for specific Loggers (e.g., com.example.App: warn).

Logging Initialization in Spring Boot

Spring Boot initializes logging through the LoggingApplicationListener, which responds to events during startup:

1. ApplicationStartingEvent: Loads the LoggingSystem based on the org.springframework.boot.logging.LoggingSystem property and calls beforeInitialize() to add a filter that blocks all log output until initialization is complete.
2. ApplicationEnvironmentPreparedEvent: Processes environemnt properties, sets logging-related system properties, initializes the logging framework via LoggingSystem.initialize(), and configures LoggerGroups and log levels based on settings like logging.level.
3. ApplicationPreparedEvent: Registers LoggingSystem, LogFile, and LoggerGroups as beans in the Spring context.

LoggerGroups allow batch management of Loggers. Defined via logging.group, they group Loggers by functionality for easier level adjustments. Predefined groups include web and sql, with levels configurable through debug/trace flags or explicit logging.level settings.

Integration of Log4j2 in Spring Boot

Spring Boot handles Log4j2 integration by searching for configuration files in a specific order:

• If logging.config is not set, Spring Boot looks for standard files (e.g., log4j2.xml) or Spring-specific files (e.g., log4j2-spring.xml) in the classpath. If none are found, it falls back to built-in configurations (log4j2.xml or log4j2-file.xml in the LoggingSystem directory).
• If logging.config is set, it uses the specified file.

Multiple configurations can be loaded via logging.log4j2.config.override, combining them into a CompositeConfiguration. The initialization process loads the Configuration, starts it, and sets it in the LoggerContext, replacing any previous Configuration.

Dynamic Log Level Updates

Log levels can be updated dynamically without restarting the application. Spring Boot's spring-boot-actuator provides a LoggersEndpoint for this purpose. To enable HTTP access, configure:

management:
  endpoints:
    web:
      exposure:
        include: loggers
  endpoint:
    loggers:
      enabled: true

Endpoints allow querying and setting levels for Loggers and LoggerGroups. For example, a POST request to /actuator/loggers/{name} with a JSON payload like {"configuredLevel": "DEBUG"} updates the level.

Under the hood, LoggersEndpoint uses LoggingSystem.setLogLevel(). In Log4j2, this method finds or creates a LoggerConfig for the given name. If the LoggerConfig doesn't exist, it creates a LevelSetLoggerConfig (a subclass with additive=true to delegate logging to parent Appenders). The level is updated, and LoggerContext.updateLoggers() refreshes Logger associations.

Custom Log Level Updates

For lightweight solutions without spring-boot-actuator, create a custom endpoint using LoggingSystem:

@RestController
public class LogLevelController {
    private final LoggingSystem loggingSystem;

    public LogLevelController(LoggingSystem loggingSystem) {
        this.loggingSystem = loggingSystem;
    }

    @PostMapping("/log/level")
    public void updateLevel(@RequestBody LevelUpdateRequest request) {
        loggingSystem.setLogLevel(request.getLoggerName(), request.getLevel());
    }

    public static class LevelUpdateRequest {
        private String loggerName;
        private LogLevel level;
        // Getters and setters
    }
}

This approach leverages LoggingSystem to abstract framewrok details, enabling easy log level modifications.