Exploring Spring Boot Logging: My Journey from Filters to AOP

Recently, I was exploring Spring features to find an effective way to log requests and responses in my service. I experimented with several approaches and wanted to share my journey.

?? The Exploration

1. Filters: Started with servlet filters, ideal for HTTP requests and enforcing security at the web layer. However, their suitability primarily for servlet API interactions limited their use in my case. I needed a more flexible solution for detailed logging of internal service calls to other APIs, beyond the typical scope of servlet filters.
2. Interceptors: Gave these a shot next. They offered more granularity, especially with Spring MVC requests, providing pre- and post-processing methods around controller methods. While they excelled in tasks like logging and security within the Spring MVC framework, they weren't ideal for my need of unified request-response logging. Interceptors handle requests and responses separately, and lack the context outside of Spring MVC controllers, limiting their effectiveness for the comprehensive logging I was aiming for.
3. AOP (Aspect-Oriented Programming): This was the game changer! It enabled me to integrate detailed logging seamlessly into my application's workflow, capturing comprehensive data in a unified way.

?? Why AOP? AOP offered a streamlined approach to log detailed request and response information without intruding on my business logic. It's like having a dedicated, invisible helper accurately and efficiently handling all the logging.

@Slf4j
@Aspect
@Component
public class GlobalLoggingAspect {

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper()
                                                    .registerModule(new JavaTimeModule())
                                                    .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

    @Around("@annotation(logMethodDetails)")
    public Object logMethodDetails(ProceedingJoinPoint joinPoint, LogMethodDetails logMethodDetails) throws Throwable {
        if (!logMethodDetails.enabled()) {
            return joinPoint.proceed();
        }

        Instant startTime = Instant.now();
        Object result = null;
        Throwable caughtException = null;

        try {
            result = joinPoint.proceed();
            return result;
        } catch (Throwable e) {
            caughtException = e;
            throw e;
        } finally {
            long elapsedTime = Duration.between(startTime, Instant.now()).toMillis();
            String message = buildLogMessage(joinPoint, result, elapsedTime, logMethodDetails, caughtException);
            logAccordingToLevel(logMethodDetails.logLevel(), message);
        }
    }

    private void logAccordingToLevel(String logLevel, String message) {
        switch (logLevel.toUpperCase()) {
            case "TRACE" -> log.trace(message);
            case "DEBUG" -> log.debug(message);
            case "INFO" -> log.info(message);
            case "WARN" -> log.warn(message);
            case "ERROR" -> log.error(message);
            default -> log.debug(message);
        }
    }
}        

The GlobalLoggingAspect not only logged methods but also elegantly encapsulated the essence of each interaction, providing invaluable insights for debugging and monitoring.

Through this journey, I realized the power of AOP in handling such cross-cutting concerns in Spring Boot. It's not just limited to logging – AOP can be a powerful tool for transaction management, security, and much more.

?? Your Thoughts?

What unique challenges have you encountered with logging in Spring Boot? Have you used AOP in interesting ways in your projects? I'm curious to hear your stories and insights. Let’s share and grow together in our journey of software development! ??????????