it-swarm.com.de

So ändern Sie die Stammprotokollierungsstufe programmgesteuert

Ich habe die folgende Datei 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>

Beim Auftreten eines bestimmten Ereignisses möchte ich jetzt programmgesteuert die Ebene des Root-Loggers von debug in error ändern. Ich kann keine Variablensubstitution verwenden, es ist zwingend, dass ich dies im Code mache.

Wie geht das? Vielen Dank.

117
Kai Sternad

Versuche dies:

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

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

Beachten Sie, dass Sie logback auch anweisen können, Ihre Konfigurationsdatei regelmäßig wie folgt zu scannen:

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

Ich gehe davon aus, dass Sie die Rückmeldung verwenden (aus der Konfigurationsdatei).

Von logback manual verstehe ich

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

Vielleicht kann Ihnen das helfen, den Wert zu ändern?

10
Raghuram

mit logback 1.1.3 musste ich folgendes tun (Scala-Code):

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

Wie von anderen angegeben, erstellen Sie einfach mockAppender und dann eine LoggingEvent-Instanz, die im Wesentlichen auf das Protokollierungsereignis wartet, das in mockAppender registriert/geschieht. 

So sieht es im Test aus: 

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"));
}
}
3
Simple-Solution

Ich denke, Sie können MDC verwenden, um den Protokolliergrad programmgesteuert zu ändern. Der folgende Code ist ein Beispiel zum Ändern der Protokollierungsstufe für den aktuellen Thread. Dieser Ansatz schafft keine Abhängigkeit von der Logback-Implementierung (SLF4J-API enthält 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");
1
satob

Ich scheine Erfolg zu haben

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

Um eine detaillierte Protokollierung von netty zu erhalten, haben die folgenden Schritte ausgeführt

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