I’ve implemented a rate limiter as a global filter for my Spring BFF, but nothing actually logs. I’m sure the logger should output something on every request the microservice receives.

Does anyone know where I may have gone wrong?

@Configuration
internal class RateLimiterConfig(
    private val requestRateLimiterGatewayFilterFactory: RequestRateLimiterGatewayFilterFactory,
    private val sessionProperties: SessionProperties
) {

    private val logger = LoggerFactory.getLogger(RateLimiterConfig::class.java)

    @Bean
    fun requestRateLimiterGatewayFilterFactory(): GlobalFilter {

        // create the rate limiter filter with the desired configuration
        val rateLimiterConfig = RequestRateLimiterGatewayFilterFactory.Config().apply {
            rateLimiter = redisRateLimiter()
            keyResolver = defaultKeyResolver()
            denyEmptyKey = true
            statusCode = HttpStatus.TOO_MANY_REQUESTS
            emptyKeyStatus = HttpStatus.BAD_REQUEST.name
        }

        val rateLimiterFilter = requestRateLimiterGatewayFilterFactory.apply(rateLimiterConfig)

        return GlobalFilter { exchange: ServerWebExchange, chain ->

            logger.info("Processing request: ${exchange.request.uri}")

            val keyResolver = rateLimiterConfig.keyResolver ?: defaultKeyResolver()

            keyResolver.resolve(exchange).doOnNext { key ->
                logger.info("Resolved key: $key")
            }.flatMap { key ->
                rateLimiterFilter.filter(exchange, chain).doOnSubscribe {
                    logger.info("Request started with key: $key")
                }.doOnSuccess {
                    logger.info("Request succeeded with key: $key")
                }.doOnError { throwable ->
                    logger.error("Request failed with key: $key", throwable)
                }
            }
        }
    }

    private fun redisRateLimiter(): RedisRateLimiter {
        return RedisRateLimiter(10, 20)
    }

    private fun defaultKeyResolver(): KeyResolver {
        return KeyResolver { exchange: ServerWebExchange ->
            val sessionId = exchange.request.cookies[sessionProperties.SESSION_COOKIE_NAME]?.first()?.value
            Mono.justOrEmpty(sessionId)
        }
    }

}

Thanks in advance!