Logging in Spring WebFlux

Logging in Spring WebFlux is important for monitoring, debugging, and tracing the flow of requests through the reactive application. Here is how to effectively use logging in a Spring WebFlux application. There are log logger frameworks available in the market to handle logs in the software application. Here, we use built logger functionality in WebFlux by defining the Logger object by using LoggerFactory in this application.

Logger Creation:

private static final Logger logger = LoggerFactory.getLogger(ControllerClass.class);

Key Features of Logging in Spring WebFlux:

Below we provide the list of key features of the logger in the Spring WebFlux component.

Steps To Implement Logging in Spring WebFlux

To Implement logging in spring WebFlux, here we created a Spring Boot project which is maven type. For this project, we use below dependencies.

Project Dependencies:

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Project Folder:

Below is the project structure, after successfully creating the project.

Step 1: Create logback-spring.xml

Once the project was successfully created, we created an XML configuration file named logback-spring.xml in the resource folder. This file is used to define the log pattern.

You can see this file in the project folder image above.

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

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

    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>

    <logger name="org.springframework.web" level="DEBUG" />
    <logger name="org.springframework.web.reactive" level="DEBUG" />
</configuration>

Step 2: Create RestController

Once the XML configuration file for logging is created, we proceeded to create a RestController class named LogHandler, annotated with @RestController. This class is responsible for defining the API endpoints and implementing the necessary business logic. Below, we provide the code for this handler. Inside the class, we instantiated an object for the Logger class using the LoggerFactory class, which takes the class name as the target input class.

package com.app;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;

import reactor.core.publisher.Mono;

@RestController
public class LogController {
    private static final Logger logger = LoggerFactory.getLogger(LogController.class);
    public Mono<ServerResponse> welcomeMsg(ServerRequest request){
        logger.info("Inside welcome method");
        return ServerResponse.ok().bodyValue("Welcome to GeeksForGeeks");
    }
    
    public Mono<ServerResponse> sumOfNumbers(ServerRequest request){
        logger.info("Inside sum Of Numbers method");
        int sum = 0;
        int n = 10;
        for(int i=1; i<=n; i++)
            sum= sum+i;
        return ServerResponse.ok().bodyValue("Sum of "+" n :" + sum);
    }
}

• In the above class, we created two different types of APIs to test the logger functionality in the Handler class.
• Firstly, we created a method named welcomeMsg(). This method returns a String type of Mono object in the form of a Server Response. In this method, we added a logger message as you can see in the above code.
• Following that, we created another method called sumOfNumbers() in a similar manner. This method calculates the sum of N numbers and returns the result in the form of a Server Response.

Step 3: Create a Router Function

Finally, we created a Router Function class named LogConfig using the @Configuration Spring annotation. In this class, we define the API endpoints with related mappings by auto-wiring the LogHandler class. We autowire the LogHandler because we need access to the API methods from LogHandler. Using the RouterFunction interface, we define the routes, which return a route.

package com.app;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;

@Configuration
public class LogConfig {
    
    @Autowired
    private LogController handler;
    
    @Bean
    RouterFunction<ServerResponse> route() {
        return RouterFunctions.route(RequestPredicates.GET("/api/welcome"), handler::welcomeMsg)
                .andRoute(RequestPredicates.GET("/api/sum"), handler::sumOfNumbers);
    }
}

In the above LogConfig class, we define two routing points for two methods in the LogHandler class. Here, the router function returns a Server Response for every route in the LogConfig class.

Step 4: Running the Application

Once the project development is completed with the required logic, we can run this project as a Spring Boot App or by using Maven commands. Run the project as a Spring Boot App, and it will run on port 8080 with the Netty server by default.

Step 5: Testing with Postman

Now, let's test the API endpoint using the Postman tool.

welcome API:

This API is GET Mapping

http://localhost:8080/api/welcome

Output:

sum API:

This API is GET Mapping

http://localhost:8080/api/sum

Here the N value is 10.

Output:

Step 6: Observing Logs

Now we need to trace loggers in the application. Open the console and observe the logs. Based on these logs, we can trace the execution of the application. Below, we provide the final output image for the logger, marked for a better understanding of the concept.