Log Properties in a Spring Boot Application

1. Overview

Properties are one of the most useful mechanisms provided by Spring Boot. They may be provided from various places such as dedicated properties files, environment variables, etc. Because of that, it’s sometimes useful to find and log specific properties, for example while debugging.

In this short tutorial, we’ll see a few different ways to find and log properties in a Spring Boot application. 

First, we’ll create a simple test app that we’ll work on. Then, we’ll try three different ways to log specific properties.

2. Creating a Test Application

Let’s create a simple app with three custom properties.

We can use Spring Initializr to create a Spring Boot app template. We’ll use Java as the language. We’re free to choose other options such as Java version, project metadata, etc.

The next step is to add custom properties to our app. We’ll add those properties to a new application.properties file in src/main/resources:

app.name=MyApp
app.description=${app.name} is a Spring Boot application
bael.property=stagingValue

3. Logging Properties With Context Refreshed Event

The first way of logging properties in a Spring Boot application is to use Spring Events, especially the org.springframework.context.event.ContextRefreshedEvent class and the corresponding EventListener. We’ll show how to log all available properties and a more detailed version that prints properties only from a specific file.

3.1. Logging All Properties

Let’s start with creating a bean and the event listener method:

@Component
public class AppContextRefreshedEventPropertiesPrinter {

    @EventListener
    public void handleContextRefreshed(ContextRefreshedEvent event) {
        // event handling logic
    }
}

We annotate the event listener method with the org.springframework.context.event.EventListener annotation. Spring invokes the annotated method when ContextRefreshedEvent occurs.

The next step is to get an instance of org.springframework.core.env.ConfigurableEnvironment interface from the triggered event. The ConfigurableEnvironment interface provides a useful method, getPropertySources(), that we’ll use to get a list of all property sources, such as environment, JVM or property file variables:

ConfigurableEnvironment env = (ConfigurableEnvironment) event.getApplicationContext().getEnvironment();

Now let’s see how we can use it to print all properties, not only from the application.properties file, but also from environment, JVM variables and many more:

env.getPropertySources()
    .stream()
    .filter(ps -> ps instanceof MapPropertySource)
    .map(ps -> ((MapPropertySource) ps).getSource().keySet())
    .flatMap(Collection::stream)
    .distinct()
    .sorted()
    .forEach(key -> LOGGER.info("{}={}", key, env.getProperty(key)));

Firstly, we create a Stream from available property sources. Then, we use its filter() method to iterate over property sources that are instances of the org.springframework.core.env.MapPropertySource class.

As the name suggests, properties in that property source are stored in a map structure. We use this in the next step, in which we’re using the stream’s map() method to get the set of property keys.

Next, we’re using Stream‘s flatMap() method, because we want to iterate over a single property key, not a set of keys. We also want to have unique, not duplicated, properties printed in alphabetical order.

The last step is to log the property key and its value.

When we start the app, we should see a big list of properties fetched from various sources:

COMMAND_MODE=unix2003
CONSOLE_LOG_CHARSET=UTF-8
...
bael.property=defaultValue
app.name=MyApp
app.description=MyApp is a Spring Boot application
...
java.class.version=52.0
ava.runtime.name=OpenJDK Runtime Environment

3.2. Logging Properties Only From the application.properties File

If we want to log properties found in just the application.properties file, we can reuse almost all the code from earlier. We need to change only the lambda function passed to the filter() method:

env.getPropertySources()
    .stream()
    .filter(ps -> ps instanceof MapPropertySource && ps.getName().contains("application.properties"))
    ...

Now, when we start the app, we should see the following logs:

bael.property=defaultValue
app.name=MyApp
app.description=MyApp is a Spring Boot application

4. Logging Properties With Environment Interface

Another way to log properties is to use the org.springframework.core.env.Environment interface:

@Component
public class EnvironmentPropertiesPrinter {
    @Autowired
    private Environment env;

    @PostConstruct
    public void logApplicationProperties() {
        LOGGER.info("{}={}", "bael.property", env.getProperty("bael.property"));
        LOGGER.info("{}={}", "app.name", env.getProperty("app.name"));
        LOGGER.info("{}={}", "app.description", env.getProperty("app.description"));
    }
}

The only limitation compared to the context-refreshed event approach is that we need to know the property name to get its value. The environment interface doesn’t provide a method to list all properties. On the other hand, it’s definitely a shorter and easier technique.

When we start the app, we should see the same output as earlier:

bael.property=defaultValue 
app.name=MyApp 
app.description=MyApp is a Spring Boot application

5. Logging Properties With Spring Actuator

Spring Actuator is a very useful library that brings production-ready features to our application. The /env REST endpoint returns the current environment properties.

First, let’s add Spring Actuator library to our project:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
    <version>3.0.0</version>
</dependency>

Next, we need to enable the /env endpoint, because it’s disabled by default. Let’s open application.properties and add the following entries:

management.endpoints.web.exposure.include=env

Now, all we’ve to do is start the app and go to the /env endpoint. In our case the address is http://localhost:8080/actuator/env. We should see a large JSON containing all environment variables including our properties:

{
  "activeProfiles": [],
  "propertySources": [
    ...
    {
      "name": "Config resource 'class path resource [application.properties]' via location 'optional:classpath:/' (document #0)",
      "properties": {
        "app.name": {
          "value": "MyApp",
          "origin": "class path resource [application.properties] - 10:10"
        },
        "app.description": {
          "value": "MyApp is a Spring Boot application",
          "origin": "class path resource [application.properties] - 11:17"
        },
        "bael.property": {
          "value": "defaultValue",
          "origin": "class path resource [application.properties] - 13:15"
        }
      }
    }
   ...
  ]
}

6. Conclusion

In this article, we learned how to log properties in a Spring Boot application.

First, we created a test application with three custom properties. Then, we saw three different ways to retrieve and log desired properties.