HowToDoInJava

A Guide to Logging in Spring Boot

By Lokesh Gupta | Filed Under: Spring Boot Logging

Logging in spring boot is very flexible and easy to configure. Spring boot supports various logging providers through some simple configuration. In this tutorial, we will look at various logging options and configurations supported by Spring boot.

Table of Contents

1. Default Zero Configuration Logging
2. Logback Logging
3. Log4j2 Logging
4. More examples

1. Default Zero Configuration Logging

Spring boot active enabled logging is determined by spring-boot-starter-logging artifact and it’s auto-configuration which enables anyone of supported logging providers (Java Util
Logging, Log4J2, and Logback) based on configuration provided.

If we do not provide any logging specific configuration, we will still see logs printed in “console”. These are because of default logging support provided in spring boot which uses Logback.

Spring boot’s internal logging is written with Apache Commons Logging so it is one and only mandatory dependency. Till, boot 1.x – we had to import it manually. Since boot 2.x, it is downloaded transitively. To be more precise, spring-boot-starter-web depends on spring-boot-starter-logging, which pulls in spring-jcl for us.

Spring boot auto-configuration provides default logging using Logback and it’s default configuration is provided in these config files.

1.1. Add log statements

To add log statements in application code, use org.slf4j.Logger and org.slf4j.LoggerFactory from SLF4J. It provides lots of useful methods for logging anf also decouple the logging implementation from application.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application 
{
	private static final Logger LOGGER=LoggerFactory.getLogger(Application.class);

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
		
		LOGGER.info("Simple log statement with inputs {}, {} and {}", 1,2,3);
	}
}

2019-07-28 12:16:57.129  INFO 3416 --- [main] 
com.howtodoinjava.demo.Application: Simple log statement with inputs 1, 2 and 3

1.2. Logging Level

Logback supports ERROR, WARN, INFO, DEBUG, or TRACE as logging level. By default, logging level is set to INFO. It means that code>DEBUG and TRACE messages are not visible.

To enable debug or trace logging, we can set the logging level in application.properties file. Also, we can pass the –debug or –trace arguments on the command line while starting the application.

# In properties file
debug=true

# In Console
$ java -jar target/my-app-0.0.1-SNAPSHOT.jar --trace

We can apply logging levels to specific packages as well. It can be done either in console or application.properties file.

# In Console
-Dlogging.level.org.springframework=ERROR 
-Dlogging.level.com.howtodoinjava=TRACE

# In properties file
logging.level.org.springframework=ERROR 
logging.level.com.howtodoinjava=TRACE

If the log level for a package is defined multiple times with different log levels, the lowest level will be used. TRACE is lowest and ERROR is highest.

1.3. Log format

The default log statement formatting is mentioned in defaults.xml file.

<conversionRule conversionWord="clr" 
converterClass="org.springframework.boot.logging.logback.ColorConverter" />

<conversionRule conversionWord="wex" 
converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />

<conversionRule conversionWord="wEx" 
converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />

<property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}})
{faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39})
{cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

<property name="FILE_LOG_PATTERN" value="${FILE_LOG_PATTERN:-%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} 
${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

It outputs following information.

  • Date and Time: Millisecond precision and easily sortable.
  • Log Level: ERROR, WARN, INFO, DEBUG, or TRACE.
  • Process ID.
  • A --- separator to distinguish the start of actual log messages.
  • Thread name: Enclosed in square brackets (may be truncated for console output).
  • Logger name: This is usually the source class name (often abbreviated).
  • The log message.

To customize the log format, use logging.pattern.console and logging.pattern.file properties.

# Logging pattern for the console
logging.pattern.console= %d{yyyy-MM-dd HH:mm:ss} - %logger{36} - %msg%n
 
# Logging pattern for file
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%

1.4. Logging to file

By default spring boot logs to console only. If we want to enable file logging, we can easily do it using simple property logging.file or logging.path.

When using logging.path, it will create a file named spring.log in mentioned package.

# Output to a temp_folder/file
logging.file=c:/temp/application.log

#logging.path=/my-folder/

# Logging pattern for file
logging.pattern.file= %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%

2. Logback Logging

The default logging is good enough for most usecases. But sometimes in enterprise applications, we need more fine control over logging with other complex requirements. In that case, having a dedicated logging configuration is suitable.

Spring boot by default uses logback, so to customize it’s behavior, all we need to add only logback.xml in classpath and define customization over the file.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

	<property name="LOG_LOCATION" value="c:/temp" />

	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
         	<pattern>%d{yyyy-MM-dd HH:mm:ss} - %logger{36} - %msg%n</pattern>
      	</encoder>
	</appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
      	<File>{LOG_LOCATION}/mylog.log</File>
      	<encoder>
	         <pattern>%d{yyyy-MM-dd HH:mm:ss} - %logger{36} - %msg%n</pattern>
	    </encoder>
	    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_LOCATION}/archived/mylog-%d{yyyy-MM-dd}.%i.log
            </fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
   	</appender> 

   	<root level="INFO">
    	<appender-ref ref="CONSOLE"/>
    	<appender-ref ref="FILE"/>
   	</root>

   	<!-- Application logs at trace level -->
   	<logger name="com.howtodoinjava" level="trace" additivity="false">
        <appender-ref ref="RollingFile" />
        <appender-ref ref="Console" />
    </logger>

</configuration>

3. Log4j2 Logging

Step 1: Exclude logback and include log4j2

As mentioned earlier, spring boot uses logback as default. So if we have to use any other logging framework e.g. log4j2, we must exclude logback from classpath of the application. Also, add spring-boot-starter-log4j2 to classpath.

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

Step 2: Add log4j2 configuration file

Now, add log4j2 specific configuration file in classpath (typically in resources folder). It can be named as any of the following:

  • log4j2-spring.xml
  • log4j2.xml

If we have logging configuration in any other file (e.g. log4j2.properties, applogs.xml etc), we can use logging.file property to specify it’s path application.properties file.

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" monitorInterval="30">
    <Properties>
        <Property name="LOG_PATTERN">%d{yyyy-MM-dd'T'HH:mm:ss.SSSZ} %p %m%n</Property>
        <Property name="APP_LOG_ROOT">c:/temp</Property>
    </Properties>
    <Appenders>
        <Console name="console" target="SYSTEM_OUT">
            <PatternLayout pattern="${LOG_PATTERN}" />
        </Console>
 
        <RollingFile name="file"
            fileName="${APP_LOG_ROOT}/SpringBoot2App/application.log"
            filePattern="${APP_LOG_ROOT}/SpringBoot2App/application-%d{yyyy-MM-dd}-%i.log">
            <PatternLayout pattern="${LOG_PATTERN}" />
            <Policies>
                <SizeBasedTriggeringPolicy size="19500KB" />
            </Policies>
            <DefaultRolloverStrategy max="1" />
        </RollingFile>
 
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="console" />
            <AppenderRef ref="file" />
        </Root>
    </Loggers>
</Configuration>

Step 3: With or without Slf4j

By default, if you are using SLF4J logger classes i.e. org.slf4j.Logger and org.slf4j.LoggerFactory, nothing needs to be changed in application code and all log statement will continue printing in target appenders.

If you are targeting to use log4j2 specific classes only, use org.apache.logging.log4j.Logger and org.apache.logging.log4j.LogManager.

I will recommend to use SLF4J logger classes.

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

@SpringBootApplication
public class Application 
{
	private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);

	public static void main(String[] args) {		
		SpringApplication.run(Application.class, args);

		LOGGER.info("Simple log statement with inputs {}, {} and {}", 1,2,3);
	}
}

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@SpringBootApplication
public class Application 
{
	private static Logger LOGGER = LogManager.getLogger(Application.class);

	public static void main(String[] args) {		
		SpringApplication.run(Application.class, args);

		LOGGER.info("Simple log statement with inputs 1, 2 and 3");
	}
}

4. More examples on spring boot logging

  1. Spring boot 2 log4j2.xml example
  2. Spring boot 2 log4j2.properties example
  3. Spring Boot logging with application.yml
  4. Spring boot logging with application.properties
  5. Spring boot embedded server logs config for tomcat, jetty & undertow
  6. Spring Boot Performance Logging with AspectJ AOP
  7. Spring Boot Logging with Lombok
  8. Spring boot multiple log files example
  9. Spring boot console logging configuration example
  10. Spring boot profile specific logging example

Drop me your questions related to logging configurations in spring boot.

Happy Learning !!

LinkedinRedditPocket

About Lokesh Gupta

Founded HowToDoInJava.com in late 2012. I love computers, programming and solving problems everyday. A family guy with fun loving nature. You can find me on Facebook, Twitter and Google Plus.

Ask Questions & Share Feedback

Please do not submit a comment only to say "Thank you".

*Want to Post Code Snippets or XML content? Please use [java] ... [/java] tags otherwise code may not appear partially or even fully. e.g.
[java] 
public static void main (String[] args) {
...
} 
[/java]