如何以编程方式更改 logback 的根日志记录级别

Question

我有以下 logback.xml 文件：

<configuration debug="true"> 

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

<root level="debug">
  <appender-ref ref="STDOUT" />
</root>
</configuration>

现在，在发生特定事件时，我想以编程方式将根记录器的级别从 debug 更改为 error。我不能使用变量替换，我必须在代码中执行此操作。

怎么办呢？谢谢。

Answer 1

试试这个：

import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;

Logger root = (Logger)LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
root.setLevel(Level.INFO);

请注意，您还可以告诉 logback 定期扫描您的配置文件，如下所示：

<configuration scan="true" scanPeriod="30 seconds" > 
  ...
</configuration> 

Answer 2

使用 logback 1.1.3 我必须执行以下操作（Scala 代码）：

import ch.qos.logback.classic.Logger
import org.slf4j.LoggerFactory    
...
val root: Logger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME).asInstanceOf[Logger]

Answer 3

我假设您正在使用 logback （来自配置文件）。

从 logback 手册，我看到

Logger rootLogger = LoggerFactory.getLogger(org.slf4j .Logger.ROOT_LOGGER_NAME);

也许这可以帮助您更改该值？

Answer 4

我认为您可以使用 MDC 以编程方式更改日志记录级别。下面的代码是更改当前线程上的日志记录级别的示例。此方法不会创建对 logback 实现的依赖性（SLF4J API 包含 MDC）。

<configuration>
  <turboFilter class="ch.qos.logback.classic.turbo.DynamicThresholdFilter">
    <Key>LOG_LEVEL</Key>
    <DefaultThreshold>DEBUG</DefaultThreshold>
    <MDCValueLevelPair>
      <value>TRACE</value>
      <level>TRACE</level>
    </MDCValueLevelPair>
    <MDCValueLevelPair>
      <value>DEBUG</value>
      <level>DEBUG</level>
    </MDCValueLevelPair>
    <MDCValueLevelPair>
      <value>INFO</value>
      <level>INFO</level>
    </MDCValueLevelPair>
    <MDCValueLevelPair>
      <value>WARN</value>
      <level>WARN</level>
    </MDCValueLevelPair>
    <MDCValueLevelPair>
      <value>ERROR</value>
      <level>ERROR</level>
    </MDCValueLevelPair>
  </turboFilter>
  ......
</configuration>

MDC.put("LOG_LEVEL", "INFO");

Answer 5

正如其他人所指出的，您只需创建 mockAppender ，然后创建一个 LoggingEvent 实例，该实例本质上侦听 mockAppender 内注册/发生的日志记录事件。

这是它在测试中的样子：

import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.Appender;

@RunWith(MockitoJUnitRunner.class)
public class TestLogEvent {

// your Logger
private Logger log = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);

// here we mock the appender
@Mock
private Appender<ILoggingEvent> mockAppender;

// Captor is generic-ised with ch.qos.logback.classic.spi.LoggingEvent
@Captor
private ArgumentCaptor<LoggingEvent> captorLoggingEvent;

/**
 * set up the test, runs before each test
 */
@Before
public void setUp() {
    log.addAppender(mockAppender);
}

/**
 * Always have this teardown otherwise we can stuff up our expectations. 
 * Besides, it's good coding practise
 */
@After
public void teardown() {
    log.detachAppender(mockAppender);
}


// Assuming this is your method
public void yourMethod() {
    log.info("hello world");
}

@Test
public void testYourLoggingEvent() {

    //invoke your method
    yourMethod();

    // now verify our logging interaction
    // essentially appending the event to mockAppender
    verify(mockAppender, times(1)).doAppend(captorLoggingEvent.capture());

    // Having a generic captor means we don't need to cast
    final LoggingEvent loggingEvent = captorLoggingEvent.getValue();

    // verify that info log level is called
    assertThat(loggingEvent.getLevel(), is(Level.INFO));

    // Check the message being logged is correct
    assertThat(loggingEvent.getFormattedMessage(), containsString("hello world"));
}
}

Answer 6

所以我基本上同意最上面的答案，但发现它在 2023 年略有不同。我发现以下工作

import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;

final LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
final Logger logger = loggerContext.exists(org.slf4j.Logger.ROOT_LOGGER_NAME); // give it your logger name
final Level newLevel = Level.toLevel("ERROR", null); // give it your log level
logger.setLevel(newLevel);

值得注意的主要区别是我必须使用 getILoggerFactory 而不是 getLogger代码>.要查看与此相关的其他帖子，请参阅以编程方式更改 Log4j2 中的日志级别 或者如果您希望每个请求都能执行此操作，请参阅 更改每个请求的 log4j 中的优先级

Answer 7

另一种方法是使用 Logback TurboFilter。这可以给我们更多的控制权。

更改记录器本身的级别只能让我们打开或关闭特定的记录器。如果我们想要为 user:123 或 team:456 获取 com.example.billing 中的所有内容，该怎么办？ code> 模块在接下来的 90 分钟 中，但留下来对其他一切都是 WARN？

如果我们使用 TurboFilter，我们就可以访问 MDC，从中获取用户上下文。我们可以访问动态配置系统来获取要匹配的用户的规则。

这就是 https://github.com/prefab-cloud/prefab-cloud-java 使用 prefab.cloud 作为动态配置和 UI。

简化：

public class PrefabMDCTurboFilter extends TurboFilter {

  private final ConfigClient configClient;

  PrefabMDCTurboFilter(ConfigClient configClient) {
    this.configClient = configClient;
  }

  public static void install(ConfigClient configClient) {
    PrefabMDCTurboFilter filter = new PrefabMDCTurboFilter(configClient);
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    loggerContext.addTurboFilter(filter);
  }

  @Override
  public FilterReply decide(
    Marker marker,
    Logger logger,
    Level level,
    String s,
    Object[] objects,
    Throwable throwable
  ) {
      Optional<Prefab.LogLevel> loglevelMaybe = configClient.getLogLevelFromStringMap(
        logger.getName(),
        MDC.getCopyOfContextMap()
      );
      if (loglevelMaybe.isPresent()) {
        Level calculatedMinLogLevelToAccept = LogbackLevelMapper.LEVEL_MAP.get(
          loglevelMaybe.get()
        );
        if (level.isGreaterOrEqual(calculatedMinLogLevelToAccept)) {
          return FilterReply.ACCEPT;
        }
        return FilterReply.DENY;
      }
      return FilterReply.NEUTRAL;
  }
}

Answer 8

您可以通过 LogManager.getLogManager().updateConfiguration() 方法拦截日志记录配置。只需检查包含 .level 后缀的配置属性，并将默认值替换为 Level.ALL 值。

public class Application {

    // Static initializer is executed when class is loaded by a class loader
    static {
        try {
            java.util.logging.LogManager.getLogManager().updateConfiguration(propertyName -> {
                // Check for the log level property
                if (propertyName.contains(".level")) {
                    // Level = ALL => logs all messages
                    return (oldValue, newValue) -> java.util.logging.Level.ALL.getName();
                } else {
                    // Identity mapper for other propeties
                    return (oldValue, newValue) -> newValue;
                }
            });
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

Answer 9

我似乎成功地做到了

org.jboss.logmanager.Logger logger = org.jboss.logmanager.Logger.getLogger("");
logger.setLevel(java.util.logging.Level.ALL);

然后从 netty 获取详细的日志记录，以下已经完成了

org.slf4j.impl.SimpleLogger.setLevel(org.slf4j.impl.SimpleLogger.TRACE);

Answer 10

这是一个控制器

@RestController
@RequestMapping("/loggers")
public class LoggerConfigController {

private final static org.slf4j.Logger LOGGER = LoggerFactory.getLogger(PetController.class);

@GetMapping()
public List<LoggerDto> getAllLoggers() throws CoreException {
    
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    
    List<Logger> loggers = loggerContext.getLoggerList();
    
    List<LoggerDto> loggerDtos = new ArrayList<>();
    
    for (Logger logger : loggers) {
        
        if (Objects.isNull(logger.getLevel())) {
            continue;
        }
        
        LoggerDto dto = new LoggerDto(logger.getName(), logger.getLevel().levelStr);
        loggerDtos.add(dto);
    }
    
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("All loggers retrieved. Total of {} loggers found", loggerDtos.size());
    }
    
    return loggerDtos;
}

@PutMapping
public boolean updateLoggerLevel(
        @RequestParam String name, 
        @RequestParam String level
)throws CoreException {
    
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    
    Logger logger = loggerContext.getLogger(name);
    
    if (Objects.nonNull(logger) && StringUtils.isNotBlank(level)) {
        
        switch (level) {
            case "INFO":
                logger.setLevel(Level.INFO);
                LOGGER.info("Logger [{}] updated to [{}]", name, level);
                break;
                
            case "DEBUG":
                logger.setLevel(Level.DEBUG);
                LOGGER.info("Logger [{}] updated to [{}]", name, level);
                break;
                
            case "ALL":
                logger.setLevel(Level.ALL);
                LOGGER.info("Logger [{}] updated to [{}]", name, level);
                break;
                
            case "OFF":
            default: 
                logger.setLevel(Level.OFF);
                LOGGER.info("Logger [{}] updated to [{}]", name, level);
        }
    }
    
    return true;
}

}