Reactive Spring Boot+Log4j2：按请求头动态设置单请求日志级别

要实现单请求的DEBUG日志隔离，核心是避免全局修改日志级别，而是利用Reactor上下文（Context）传递请求标记，结合Log4j2的过滤器实现请求级别的日志输出控制——因为Reactive环境下线程复用，直接修改Logger级别会导致跨请求污染，必须用上下文绑定的方式实现隔离。

步骤1：配置Log4j2全局级别并自定义请求过滤器 #

首先需要把Log4j2的全局日志级别设为DEBUG（让所有日志都能到达Appender层面），然后通过自定义过滤器控制只有携带指定请求头的请求才输出DEBUG日志，其他请求仅输出INFO及以上。

编写Log4j2自定义过滤器 #

创建一个Log4j2插件类，用于检测请求上下文标记并过滤日志：

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import org.apache.logging.log4j.core.filter.AbstractFilter;
import org.apache.logging.log4j.core.filter.Filter;
import org.apache.logging.log4j.core.Node;

@Plugin(
    name = "RequestDebugFilter",
    category = Node.CATEGORY,
    elementType = Filter.ELEMENT_TYPE,
    printObject = true
)
public class RequestDebugFilter extends AbstractFilter {
    private static final String DEBUG_LOG_MARKER_KEY = "DEBUG_LOG_ENABLED";

    @Override
    public Result filter(LogEvent event) {
        // 从ThreadContext获取请求标记
        String debugEnabled = event.getContextMap().get(DEBUG_LOG_MARKER_KEY);
        if ("true".equals(debugEnabled)) {
            // 开启请求级DEBUG：允许所有级别日志通过
            return Result.NEUTRAL;
        } else {
            // 未开启：仅允许INFO及以上级别日志通过
            return event.getLevel().isMoreSpecificThan(Level.INFO) ? Result.NEUTRAL : Result.DENY;
        }
    }

    @PluginFactory
    public static RequestDebugFilter createFilter() {
        return new RequestDebugFilter();
    }
}

修改Log4j2配置文件 #

在log4j2.xml（或log4j2.yml）中配置全局Root级别为DEBUG，并在Appender中引入自定义过滤器：

<Configuration status="INFO">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
            <!-- 启用自定义请求级过滤器 -->
            <Filters>
                <RequestDebugFilter/>
            </Filters>
        </Console>
    </Appenders>
    <Loggers>
        <!-- 全局设为DEBUG，交给过滤器控制实际输出 -->
        <Root level="DEBUG">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

步骤2：通过WebFilter传递请求标记到Reactor上下文 #

编写WebFilter拦截请求，检测X-Debug-Logging请求头，并将标记存入Reactor的请求上下文（Context）——Reactor Context与请求的订阅序列绑定，完全隔离于其他请求：

import org.springframework.stereotype.Component;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class DebugLoggingHeaderFilter implements WebFilter {
    private static final String DEBUG_LOG_MARKER_KEY = "DEBUG_LOG_ENABLED";
    private static final String DEBUG_HEADER = "X-Debug-Logging";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        // 解析请求头，判断是否开启DEBUG日志
        boolean enableDebug = Boolean.parseBoolean(
            exchange.getRequest().getHeaders().getFirst(DEBUG_HEADER)
        );
        // 将标记写入Reactor上下文，跟随请求全生命周期
        return chain.filter(exchange)
                .contextWrite(context -> context.put(DEBUG_LOG_MARKER_KEY, enableDebug));
    }
}

步骤3：同步Reactor上下文到Log4j2 ThreadContext #

由于Log4j2默认从ThreadContext读取上下文数据，而Reactive环境下线程会频繁切换，需要注册Reactor钩子，将Reactor Context中的标记同步到当前线程的ThreadContext，并在请求结束后清理，避免污染后续请求：

import org.apache.logging.log4j.ThreadContext;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Hooks;

import javax.annotation.PostConstruct;

@Configuration
public class ReactorThreadContextSyncConfig {
    private static final String DEBUG_LOG_MARKER_KEY = "DEBUG_LOG_ENABLED";

    @PostConstruct
    public void setupThreadContextSync() {
        Hooks.onEachOperator(operator -> operator
                // 每个信号处理时，同步Reactor上下文到ThreadContext
                .doOnEach(signal -> {
                    if (signal.hasContext()) {
                        Boolean debugEnabled = signal.getContext().getOrDefault(DEBUG_LOG_MARKER_KEY, false);
                        if (debugEnabled) {
                            ThreadContext.put(DEBUG_LOG_MARKER_KEY, "true");
                        } else {
                            ThreadContext.remove(DEBUG_LOG_MARKER_KEY);
                        }
                    }
                })
                // 请求终止或取消时清理ThreadContext
                .doOnTerminate(() -> ThreadContext.remove(DEBUG_LOG_MARKER_KEY))
                .doOnCancel(() -> ThreadContext.remove(DEBUG_LOG_MARKER_KEY))
        );
    }
}

关键注意事项 #

1. 全局日志级别必须设为DEBUG：如果全局级别是INFO，DEBUG日志会被Logger直接拦截，无法到达Appender层面，自定义过滤器也就无法生效。
2. ThreadContext必须及时清理：Reactor的线程是复用的，请求结束后必须清除ThreadContext中的标记，否则会导致后续请求继承错误的日志标记。
3. Reactor上下文的绑定性：Reactor Context与请求的Mono/Flux序列强绑定，完全隔离于其他请求，不会出现跨请求的标记污染问题。

验证效果 #

• 当请求携带X-Debug-Logging: true时，该请求的所有DEBUG日志会被输出，其他并行请求仍仅输出INFO及以上日志。
• 请求结束后，ThreadContext标记被自动清理，不会影响后续请求的日志级别。

内容的提问来源于stack exchange，提问作者Rahul verma