Spring Boot Logging

Spring Boot Logging: Using SLF4J, Logback, and Log4j2

Introduction

When I first started working with Spring Boot applications, debugging issues often meant adding System.out.println() statements throughout my code. While that worked for simple cases, I quickly realized it wasn't sustainable for professional applications. That's when I properly learned about logging frameworks, and it completely changed how I approached troubleshooting and monitoring my applications.

Logging is one of those foundational skills that separates amateur developers from professionals. It's not the most exciting topic, but mastering logging will save you countless hours of debugging headaches and help you build more robust applications.

In this post, I'll walk you through everything you need to know about logging in Spring Boot applications. We'll cover SLF4J, Logback, and Log4j2 with practical examples that you can implement right away. Whether you're just starting with Spring Boot or looking to improve your existing logging setup, this guide will help you implement professional-grade logging in your applications.

Usages

Before diving into implementation details, let's explore why proper logging is crucial and how it's used in real-world applications:

1. Application Troubleshooting

The most obvious use of logging is troubleshooting issues. Well-implemented logs help you trace the execution flow and identify where things went wrong without having to reproduce the issue with a debugger attached.

2. Performance Monitoring

Logs can track response times, resource usage, and other performance metrics. This helps identify bottlenecks and optimize your application.

3. User Activity Tracking

Logging user actions creates an audit trail that's valuable for security monitoring, understanding user behavior, and resolving customer support issues.

4. Health Monitoring

Production systems rely on logs to monitor application health. Sudden increases in error logs often indicate problems that need attention.

5. Compliance Requirements

Many industries have regulatory requirements that mandate logging specific types of events, especially related to security and data access.

Real-World Scenarios

Here are some practical examples of how logging helps in everyday development:

• API Request Validation: Logging invalid API requests helps identify integration issues with client applications.
• Third-Party Service Integration: Logging requests to and responses from external services helps debug integration issues.
• Background Job Processing: For scheduled tasks and async processes, logs provide visibility into execution that would otherwise be invisible.
• Security Events: Authentication attempts, permission changes, and data access can be logged for security monitoring.
• Application Lifecycle Events: Startup, shutdown, and configuration changes should be logged to understand the application's state changes.

Code Example

Let's implement a comprehensive logging setup in a Spring Boot application. I'll cover configuration for both Logback (Spring Boot's default) and Log4j2, along with practical examples of effective logging.

1. Basic SLF4J Usage

First, let's look at how to use SLF4J in a Spring Boot controller:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {

    // Create a logger instance for this class
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
        logger.info("UserController initialized");
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        logger.debug("Fetching user with ID: {}", id);
        
        try {
            User user = userService.findById(id);
            
            if (user != null) {
                logger.debug("Found user: {}", user.getUsername());
                return user;
            } else {
                logger.warn("User not found with ID: {}", id);
                throw new UserNotFoundException(id);
            }
        } catch (Exception e) {
            logger.error("Error fetching user with ID: " + id, e);
            throw e;
        }
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        logger.info("Creating new user: {}", user.getUsername());
        
        // Additional logging
        if (logger.isDebugEnabled()) {
            logger.debug("User details: email={}, role={}", 
                user.getEmail(), user.getRole());
        }
        
        return userService.create(user);
    }
}

2. Configuring Logback (Spring Boot Default)

Create a logback-spring.xml file in your src/main/resources directory:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property name="LOG_PATH" value="./logs" />
    <property name="LOG_ARCHIVE" value="${LOG_PATH}/archived" />
    
    <!-- Console Appender -->
    <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %highlight(%-5level) %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- File Appender for all logs -->
    <appender name="ApplicationLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/application.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_ARCHIVE}/application.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    
    <!-- File Appender for errors only -->
    <appender name="ErrorLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/error.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_ARCHIVE}/error.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    
    <!-- Specific logger configurations -->
    <logger name="com.example.myapp" level="DEBUG" />
    <logger name="org.springframework" level="INFO" />
    <logger name="org.hibernate" level="WARN" />
    
    <!-- Profile-specific configurations -->
    <springProfile name="development">
        <root level="DEBUG">
            <appender-ref ref="Console" />
            <appender-ref ref="ApplicationLog" />
            <appender-ref ref="ErrorLog" />
        </root>
    </springProfile>
    
    <springProfile name="production">
        <root level="INFO">
            <appender-ref ref="Console" />
            <appender-ref ref="ApplicationLog" />
            <appender-ref ref="ErrorLog" />
        </root>
    </springProfile>
</configuration>

3. Switching to Log4j2

First, exclude Logback and add Log4j2 dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

Now create a log4j2-spring.xml file in your src/main/resources directory:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Properties>
        <Property name="LOG_PATH">./logs</Property>
        <Property name="LOG_PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</Property>
    </Properties>
    
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="${LOG_PATTERN}" />
        </Console>
        
        <RollingFile name="ApplicationLog" 
                fileName="${LOG_PATH}/application.log" 
                filePattern="${LOG_PATH}/archived/application-%d{yyyy-MM-dd}-%i.log">
            <PatternLayout pattern="${LOG_PATTERN}" />
            <Policies>
                <TimeBasedTriggeringPolicy />
                <SizeBasedTriggeringPolicy size="10 MB" />
            </Policies>
            <DefaultRolloverStrategy max="30" />
        </RollingFile>
        
        <RollingFile name="ErrorLog" 
                fileName="${LOG_PATH}/error.log" 
                filePattern="${LOG_PATH}/archived/error-%d{yyyy-MM-dd}-%i.log">
            <PatternLayout pattern="${LOG_PATTERN}" />
            <Policies>
                <TimeBasedTriggeringPolicy />
                <SizeBasedTriggeringPolicy size="10 MB" />
            </Policies>
            <DefaultRolloverStrategy max="30" />
            <LevelRangeFilter minLevel="ERROR" maxLevel="ERROR" onMatch="ACCEPT" onMismatch="DENY" />
        </RollingFile>
    </Appenders>
    
    <Loggers>
        <Logger name="com.example.myapp" level="debug" additivity="false">
            <AppenderRef ref="Console" />
            <AppenderRef ref="ApplicationLog" />
            <AppenderRef ref="ErrorLog" />
        </Logger>
        
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console" />
            <AppenderRef ref="ApplicationLog" />
            <AppenderRef ref="ErrorLog" />
        </Logger>
        
        <Logger name="org.hibernate" level="warn" additivity="false">
            <AppenderRef ref="Console" />
            <AppenderRef ref="ApplicationLog" />
            <AppenderRef ref="ErrorLog" />
        </Logger>
        
        <Root level="info">
            <AppenderRef ref="Console" />
            <AppenderRef ref="ApplicationLog" />
            <AppenderRef ref="ErrorLog" />
        </Root>
    </Loggers>
</Configuration>

4. Using MDC for Contextual Logging

MDC (Mapped Diagnostic Context) is a powerful feature for tracking context across multiple log statements. Let's implement it with a request interceptor:

import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;

@Component
public class LoggingInterceptor implements HandlerInterceptor, WebMvcConfigurer {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // Generate a unique request ID
        String requestId = UUID.randomUUID().toString();
        MDC.put("requestId", requestId);
        
        // Add user info if available
        String username = getUsernameFromRequest(request);
        if (username != null) {
            MDC.put("username", username);
        }
        
        // Add other useful context
        MDC.put("ipAddress", request.getRemoteAddr());
        MDC.put("userAgent", request.getHeader("User-Agent"));
        
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                                Object handler, Exception ex) {
        // Clear the MDC context
        MDC.clear();
    }
    
    private String getUsernameFromRequest(HttpServletRequest request) {
        // Implementation depends on your authentication mechanism
        // This is just a placeholder
        return (String) request.getSession().getAttribute("username");
    }
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(this);
    }
}

Update your logging pattern to include the MDC fields:

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

5. Implementing a Logging Aspect for Method Tracing

Let's create an aspect to automatically log method entries/exits with execution times:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.myapp.service.*.*(..))")
    public Object logMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        Logger logger = LoggerFactory.getLogger(joinPoint.getTarget().getClass());
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getSimpleName();
        
        // Log method entry
        logger.debug("Entering {}::{} with arguments {}", className, methodName, joinPoint.getArgs());
        
        long startTime = System.currentTimeMillis();
        Object result;
        
        try {
            // Execute the method
            result = joinPoint.proceed();
            
            // Log method exit
            long executionTime = System.currentTimeMillis() - startTime;
            logger.debug("Exiting {}::{} with result: {} (executed in {}ms)", 
                    className, methodName, result, executionTime);
            
            return result;
        } catch (Exception e) {
            // Log the exception
            logger.error("Exception in {}::{} - Message: {}", className, methodName, e.getMessage(), e);
            throw e;
        }
    }
}

Explanation

Let's break down the key components of our logging implementation:

SLF4J Basics

SLF4J (Simple Logging Facade for Java) is an abstraction layer that allows you to use a single logging API while being able to switch between different logging implementations. In our example, we used SLF4J's Logger interface:

• private static final Logger logger = LoggerFactory.getLogger(UserController.class); - Creates a logger instance specific to the class.
• logger.debug("Fetching user with ID: {}", id); - Uses parameterized logging which is more efficient than string concatenation.
• if (logger.isDebugEnabled()) { ... } - Checks if debug logging is enabled before constructing complex log messages.

SLF4J provides different log levels (TRACE, DEBUG, INFO, WARN, ERROR) for categorizing the severity of log messages.

Logback Configuration

Logback is Spring Boot's default logging implementation. Our logback-spring.xml configuration includes:

• Appenders: Define where logs should be output (console, files)
• Pattern Layout: Format of log messages
• Rolling Policy: Automatically archive and rotate log files
• Loggers: Configure log levels for specific packages
• Profiles: Different logging configurations for development vs. production

The <springProfile> tags allow you to have different logging configurations based on which Spring profile is active.

Log4j2 Configuration

Log4j2 is an alternative logging implementation that offers better performance than Logback in high-throughput scenarios. The configuration structure is different but serves the same purpose:

• Properties: Define reusable variables
• Appenders: Define output destinations
• Loggers: Configure log levels by package
• Filters: Control which log events go to which appenders

MDC (Mapped Diagnostic Context)

MDC is a powerful feature that allows you to add contextual information to log messages. Our implementation uses a Spring interceptor to:

• Generate a unique request ID for each HTTP request
• Add username information when available
• Include IP address and user agent information
• Automatically clean up the MDC after request processing

This makes tracking issues across multiple log entries much easier, especially in concurrent environments.

AOP Logging

The Aspect-Oriented Programming approach automatically logs method entries, exits, execution times, and exceptions without cluttering your business logic. This is particularly useful for:

• Performance monitoring (method execution times)
• Debugging complex method flows
• Ensuring consistent logging across all service methods

Best Practices

Based on my experience with logging in production Spring Boot applications, here are some best practices to follow:

1. Use the Right Log Levels

Each log level serves a specific purpose:

• ERROR: Application errors that need immediate attention (exceptions, system failures)
• WARN: Situations that aren't failures but may require attention (deprecated API usage, recoverable issues)
• INFO: Significant application events (startup, shutdown, configuration changes, business milestones)
• DEBUG: Detailed information useful for debugging (method entries/exits, variable values)
• TRACE: Very detailed information (rarely used except in specific troubleshooting scenarios)

2. Structure Log Messages Consistently

Follow these guidelines for log message content:

• Be specific and descriptive
• Include relevant context (IDs, usernames)
• For errors, include both the error message and the exception stack trace
• Use a consistent format across your application

// Good example
logger.error("Failed to process payment for order #{} - {}", orderId, e.getMessage(), e);

// Poor example
logger.error("Error occurred");

3. Use Parameterized Logging

Always use SLF4J's parameterized logging instead of string concatenation:

// Good - Efficient
logger.debug("Processing order {} for customer {}", orderId, customerId);

// Bad - Creates unnecessary string objects even if debug is disabled
logger.debug("Processing order " + orderId + " for customer " + customerId);

4. Configure Appropriate Log Rotation

Prevent disk space issues with proper log rotation:

• Use time-based rotation (daily is common)
• Set maximum file size limits
• Define retention policies (how many days/files to keep)
• Consider compression for archived logs

5. Separate Application and Error Logs

Configure separate log files for different purposes:

• General application logs (all levels)
• Error-only logs (easier to monitor critical issues)
• Access logs (for API requests)
• Separate logs for specific components (if needed)

6. Add Context with MDC

Use MDC to add these contextual elements to every log message:

• Request/transaction IDs (to track request flow)
• Username or user ID (for user activity tracking)
• Session ID (for session-based applications)
• Source IP and user agent (for security tracking)

7. Consider JSON Logging in Production

In production environments with log aggregation systems (like ELK stack or Splunk), consider using JSON format for structured logging:

<appender name="JsonConsole" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
</appender>

8. Don't Log Sensitive Information

Be careful about what you log:

• Never log passwords, API keys, or tokens
• Be cautious with personally identifiable information (PII)
• Consider masking sensitive fields like credit card numbers

// Bad - Logs sensitive data
logger.debug("User {} logging in with password {}", username, password);

// Good - Logs only necessary information
logger.debug("Login attempt for user {}", username);

9. Test Your Logging Configuration

Verify that your logging configuration works as expected:

• Test log rotation and archiving
• Verify different log levels work correctly
• Make sure sensitive data isn't being logged
• Check performance impact of logging in high-throughput scenarios

10. Use Async Appenders for High-Volume Applications

For high-throughput applications, consider async appenders to improve performance:

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

Conclusion

Proper logging is an essential aspect of building production-ready Spring Boot applications. It helps with troubleshooting, performance monitoring, security auditing, and much more. By implementing the patterns and practices covered in this post, you'll create a robust logging system that makes your application easier to maintain and operate.

Let's recap what we've covered:

• Using SLF4J as a logging façade to write implementation-agnostic code
• Configuring both Logback and Log4j2 for different scenarios
• Adding context to logs with MDC to track requests across multiple log entries
• Implementing AOP for automatic method tracing and performance logging
• Best practices for log levels, message formatting, and sensitive data handling

Remember that good logging is a balance — too little makes troubleshooting difficult, but too much creates noise and performance overhead. Start with the basics outlined here, then evolve your logging strategy based on your application's specific needs.

Once you've implemented proper logging, consider taking it to the next level by integrating with a log aggregation system like the ELK stack (Elasticsearch, Logstash, Kibana) or Splunk to centralize logs from multiple services and create dashboards and alerts.

What logging practices have you found most useful in your Spring Boot applications? Have any questions about the implementation details covered here? Drop a comment below, and let's discuss!

---

Description: Master Spring Boot logging with this comprehensive guide to SLF4J, Logback, and Log4j2. Learn best practices, implementation strategies, and advanced techniques with real-world examples to effectively monitor and troubleshoot your applications.