Spring Boot如何禁用传递依赖kafka-clients日志但保留直接依赖日志

默认情况下，不管是你直接引入的kafka-clients还是其他库传递引入的，所有org.apache.kafka包下的类日志都会被同一个全局logger配置控制，所以直接设置<logger name="org.apache.kafka" level="off"/>会同时关闭所有相关日志。要实现区分控制，核心思路是通过日志的调用者上下文（调用栈）来过滤——你自己代码调用Kafka的类和内部库调用Kafka的类属于不同的包，以此作为区分依据。

针对Logback的实现方式 #

方式1：使用内置EvaluatorFilter（无需自定义类） #

先给org.apache.kafka设置你需要的日志级别（比如DEBUG），再添加过滤器拒绝来自目标内部库的调用日志：

<configuration>
    <!-- 自定义Appender，替换成你实际的日志输出配置 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="org.apache.kafka" level="DEBUG" additivity="false">
        <!-- 过滤来自内部库的Kafka日志，替换成你的内部库根包路径 -->
        <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
            <evaluator>
                <expression>callerData != null &amp;&amp; callerData[0].className.startsWith("com.yourcompany.internal.lib")</expression>
            </evaluator>
            <onMatch>DENY</onMatch>
            <onMismatch>ACCEPT</onMismatch>
        </filter>
        <appender-ref ref="CONSOLE"/>
    </logger>

    <root level="info">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

方式2：自定义过滤器（更灵活） #

如果需要复杂过滤逻辑，可以编写自定义Filter类：

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.filter.Filter;
import ch.qos.logback.core.spi.FilterReply;

public class KafkaCallerPackageFilter extends Filter<ILoggingEvent> {
    // 需要排除的内部库包路径
    private String excludedPackage;

    @Override
    public FilterReply decide(ILoggingEvent event) {
        StackTraceElement[] callerStack = event.getCallerData();
        if (callerStack == null) {
            return FilterReply.ACCEPT;
        }
        // 遍历调用栈，检查是否来自目标内部库
        for (StackTraceElement element : callerStack) {
            if (element.getClassName().startsWith(excludedPackage)) {
                return FilterReply.DENY;
            }
        }
        return FilterReply.ACCEPT;
    }

    // 提供setter用于配置文件注入
    public void setExcludedPackage(String excludedPackage) {
        this.excludedPackage = excludedPackage;
    }
}

然后在Logback配置中引用该过滤器：

<logger name="org.apache.kafka" level="DEBUG" additivity="false">
    <filter class="com.yourproject.filter.KafkaCallerPackageFilter">
        <!-- 替换成你的内部库根包路径 -->
        <excludedPackage>com.yourcompany.internal.lib</excludedPackage>
    </filter>
    <appender-ref ref="CONSOLE"/>
</logger>

针对Log4j2的实现方式 #

如果项目使用Log4j2，可以通过ScriptFilter实现类似逻辑：

<Configuration status="WARN">
    <Appenders>
        <Console name="CONSOLE" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Logger name="org.apache.kafka" level="DEBUG" additivity="false">
            <Filters>
                <ScriptFilter onMatch="DENY" onMismatch="ACCEPT">
                    <Script language="javascript">
                        var stackTrace = logEvent.getSourceStackTrace();
                        if (stackTrace != null) {
                            for (var i = 0; i < stackTrace.length; i++) {
                                // 替换成你的内部库根包路径
                                if (stackTrace[i].getClassName().startsWith("com.yourcompany.internal.lib")) {
                                    return true;
                                }
                            }
                        }
                        return false;
                    </Script>
                </ScriptFilter>
            </Filters>
            <AppenderRef ref="CONSOLE"/>
        </Logger>
        <Root level="info">
            <AppenderRef ref="CONSOLE"/>
        </Root>
    </Loggers>
</Configuration>

关键说明 #

• 核心逻辑：通过调用栈中的类包名判断日志来源——你自己代码调用Kafka时，调用栈顶层类属于项目包；内部库调用Kafka时，顶层类属于内部库包，以此区分。
• 如果内部库对Kafka的调用有多层封装，可以调整调用栈索引（比如callerData[1]），或者遍历整个调用栈检查是否包含目标包的类。
• 测试时可先将Kafka日志级别设为TRACE，观察调用栈信息，确认内部库的包路径是否正确。

内容的提问来源于stack exchange，提问作者Jignesh M. Khatri