कैसे जड़ लॉगिंग स्तर को बदलने के लिए प्रोग्राम के रूप में

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> 

अब, एक विशिष्ट घटना की घटना पर, मैं प्रोग्राम के रूप में डिबग से जड़ लकड़हारा के स्तर को बदलना चाहते हैं से त्रुटि। मैं परिवर्तनीय प्रतिस्थापन का उपयोग नहीं कर सकता, यह अनिवार्य है कि मैं इसे कोड के भीतर करता हूं।

यह कैसे किया जा सकता है? धन्यवाद।

Answer 1

इस प्रयास करें:

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); 

ध्यान दें कि आप भी logback बता सकते हैं समय-समय पर इस तरह से अपनी कॉन्फ़िग फ़ाइल को स्कैन करने के LoggingEvent उदाहरण जो अनिवार्य रूप से पंजीकृत लॉगिंग ईवेंट को सुनता है/mockAppender के अंदर होता है।

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

Answer 2

मुझे लगता है कि आप लॉगबैक (कॉन्फ़िगरेशन फ़ाइल से) का उपयोग कर रहे हैं।

logback manual से, मैं देख रहा हूँ

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

शायद यह आप मान बदलने में मदद कर सकते हैं? आप बस mockAppender बनाने और उसके बाद बनाने

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

Answer 3

के रूप में दूसरों के द्वारा ने कहा,:

Answer 4

निम्नलिखित (स्काला कोड) करने के लिए logback 1.1.3 का उपयोग कर रहा था:

यहाँ कैसे यह परीक्षण में की तरह लग रहा है प्रोग्रामिंग के रूप में लॉगिंग स्तर बदलें। नीचे दिया गया कोड वर्तमान धागे पर लॉगिंग स्तर बदलने के लिए एक उदाहरण है। यह दृष्टिकोण लॉगबैक कार्यान्वयन पर निर्भरता नहीं बनाता है (एसएलएफ 4 जे एपीआई में एमडीसी शामिल है)।

<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

मुझे लगता है कि आप के लिए MDC उपयोग कर सकते हैं:

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