@Override public Level getAppenderThreshold(String appenderName) throws AppenderThresholdNotSupported { for (Map.Entry<String, Appender> entry : getAllAppenders().entrySet()) { if (entry.getKey().equals(appenderName)) { Appender appender = entry.getValue(); for (Object filter : appender.getCopyOfAttachedFiltersList()) { if (filter instanceof ThresholdFilter) { try { Field field = filter.getClass().getDeclaredField("level"); field.setAccessible(true); return (Level) field.get(filter); } catch (NoSuchFieldException | IllegalAccessException e) { log.error("Error getting appender " + appenderName + " level", e); throw new AppenderThresholdNotSupported(appenderName); } } } } } throw new AppenderThresholdNotSupported(appenderName); }
private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config, String logFile) { RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN); encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext())); appender.setEncoder(encoder); config.start(encoder); appender.setFile(logFile); FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy(); rollingPolicy.setFileNamePattern(logFile + ".%i"); appender.setRollingPolicy(rollingPolicy); rollingPolicy.setParent(appender); config.start(rollingPolicy); SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); triggeringPolicy.setMaxFileSize("10MB"); appender.setTriggeringPolicy(triggeringPolicy); config.start(triggeringPolicy); config.appender("FILE", appender); return appender; }
private void setMetricsMarkerLogbackFilter(LoggerContext context) { log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME); OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator(); onMarkerMetricsEvaluator.setContext(context); onMarkerMetricsEvaluator.addMarker("metrics"); onMarkerMetricsEvaluator.start(); EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>(); metricsFilter.setContext(context); metricsFilter.setEvaluator(onMarkerMetricsEvaluator); metricsFilter.setOnMatch(FilterReply.DENY); metricsFilter.start(); for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) { for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext();) { Appender<ILoggingEvent> appender = it.next(); if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) { log.debug("Filter metrics logs from the {} appender", appender.getName()); appender.setContext(context); appender.addFilter(metricsFilter); appender.start(); } } } }
/** * Starts or stops logging to the console. * * @param start starts or stops logging to the console. */ @SuppressWarnings("rawtypes") public static void logToConsole(boolean start) { Logger rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); if (rootLogger != null && rootLogger instanceof ch.qos.logback.classic.Logger) { Appender appender = ((ch.qos.logback.classic.Logger) rootLogger).getAppender(CONSOLE_APPENDER_NAME); if (appender != null) { if (start) { appender.start(); } else { appender.stop(); } return; } } logger.warn("Unable to reconfigure Logback console logger (appender name '" + CONSOLE_APPENDER_NAME + "')."); }
private void setMetricsMarkerLogbackFilter(LoggerContext context) { log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME); OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator(); onMarkerMetricsEvaluator.setContext(context); onMarkerMetricsEvaluator.addMarker("metrics"); onMarkerMetricsEvaluator.start(); EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>(); metricsFilter.setContext(context); metricsFilter.setEvaluator(onMarkerMetricsEvaluator); metricsFilter.setOnMatch(FilterReply.DENY); metricsFilter.start(); for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) { for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext(); ) { Appender<ILoggingEvent> appender = it.next(); if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) { log.debug("Filter metrics logs from the {} appender", appender.getName()); appender.setContext(context); appender.addFilter(metricsFilter); appender.start(); } } } }
@Override public Appender<E> build(final LoggerContext context, final String applicationName, final LayoutFactory<E> layoutFactory, final LevelFilterFactory<E> levelFilterFactory, final AsyncAppenderFactory<E> asyncAppenderFactory) { final Appender<E> appender = new FifoLogbackAppender<>(); appender.setContext(context); appender.addFilter(levelFilterFactory.build(threshold)); getFilterFactories().forEach(f -> appender.addFilter(f.build())); appender.start(); appender.setName(APPENDER_NAME); return appender; }
@BeforeClass @SuppressWarnings("unchecked") public static void init() { loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); appender = new CdpAppender(); appender.setContext(loggerContext); appender.start(); appender.setName(CdpAppender.class.getName()); Logger logger = loggerContext.getLogger("cdp4j.flow"); logger.addAppender((Appender<ILoggingEvent>) appender); factory = new Launcher().launch(); session = factory.create(); session.enableConsoleLog(); URL url = TestAll.class.getResource("/session-test.html"); session.navigate(url.toString()); }
@Test public void shouldSetConsoleAppenderForServiceAndRequestLogs() { final String requestLoggerName = "requestlogger"; SecondBaseLogger.setupLoggingStdoutOnly(KEYS, VALUES, requestLoggerName); final ch.qos.logback.classic.Logger rootLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger( org.slf4j.Logger.ROOT_LOGGER_NAME); final Appender<ILoggingEvent> serviceConsoleAppender = rootLogger.getAppender( "SERVICECONSOLEAPPENDER"); assertThat(serviceConsoleAppender, notNullValue()); final ch.qos.logback.classic.Logger requestLogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(requestLoggerName); final Appender<ILoggingEvent> requestLogConsoleAppender = requestLogger.getAppender( "REQUESTLOGCONSOLEAPPENDER"); assertThat(requestLogConsoleAppender, notNullValue()); }
/** * Initialize the logger, in order to display all the log messages in a text * logger on the gui. */ private void initLogger() { LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); // find the appender which is an instance of the text area appender and set the text area where it should put the text for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) { // iterate the appenders in order to find the wanted one for (Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext();) { Appender<ILoggingEvent> appender = index.next(); // just the TextAreaAppender type is needed to be correctly initialised if (appender instanceof TextAreaAppender) { ((TextAreaAppender) appender).setTextArea(jTALog, jTAShortLog); } } } }
@Override public Appender<ILoggingEvent> build(LoggerContext context, String s, Layout<ILoggingEvent> layout) { Preconditions.checkNotNull(context); WiretapAppender appender = new WiretapAppender(); final PatternLayoutEncoder patternEncoder = new PatternLayoutEncoder(); patternEncoder.setContext(context); patternEncoder.setPattern("%-5p [%thread] [%d] %c: %m%n%rEx"); patternEncoder.start(); appender.setContext(context); appender.setName("wiretap-appender"); appender.setEncoder(patternEncoder); addThresholdFilter(appender, threshold); appender.start(); return wrapAsync(appender); }
public Appender<ILoggingEvent> build( LoggerContext context, String applicationName, LayoutFactory<ILoggingEvent> layoutFactory, LevelFilterFactory<ILoggingEvent> levelFilterFactory, AsyncAppenderFactory<ILoggingEvent> asyncAppenderFactory ) { final LoggingEventCompositeJsonEncoder encoder = new LoggingEventCompositeJsonEncoder(); encoder.setContext(context); encoder.getProviders().addProvider(withPattern("{ \"type\": \"system\" }", new LoggingEventPatternJsonProvider(), context)); encoder.getProviders().addProvider(withName("timestamp", new LoggingEventFormattedTimestampJsonProvider(), context)); encoder.getProviders().addProvider(new LogLevelJsonProvider() ); encoder.getProviders().addProvider(new MessageJsonProvider() ); encoder.getProviders().addProvider(new StackTraceJsonProvider() ); encoder.start(); final ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<>(); appender.setContext(context); appender.setEncoder(encoder); appender.start(); return wrapAsync(appender, asyncAppenderFactory); }
public static void startLogback() { long startTime = System.nanoTime(); Config config = Configs.DEFAULT.logging(); LogbackConfig logbackConfig = getLogbackConfig(config); LogbackManager logbackMgr = LogbackManager.INSTANCE; RollingFileAppender<ILoggingEvent> fileAppender = logbackMgr.createRollingFileAppender(logbackConfig); ConsoleAppender<ILoggingEvent> consoleAppender = logbackMgr .createConsoleAppender(APPENDER_CONSOLE, config.getString(KEY_LOG_PATTERN_CONSOLE)); List<Appender<ILoggingEvent>> appenderList = new ArrayList<>(); appenderList.add(consoleAppender); appenderList.add(fileAppender); logbackMgr.getAppenders().addAll(appenderList); LoggerContext context = logbackMgr.getLoggerContext(); initRootLogger(context, consoleAppender, config); addLoggers(config, appenderList); addAsyncAppender(config, fileAppender); context.start(); context.getLogger(LogbackInitializer.class).info(INIT_MSG, elapsedMillis(startTime)); }
/** * Initializes the logger and the requested log level. * * @param level Logging level threshold */ @SuppressWarnings("unchecked") public static void configure(final Level level) { final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); root.setLevel(level); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(root.getLoggerContext()); encoder.setPattern("%msg%n"); encoder.start(); Iterator<Appender<ILoggingEvent>> iterator = root.iteratorForAppenders(); while (iterator.hasNext()) { Appender<ILoggingEvent> appender = iterator.next(); if (appender instanceof OutputStreamAppender) { ((OutputStreamAppender) appender).setEncoder(encoder); } appender.stop(); appender.start(); } }
private Appender<ILoggingEvent> configureAppender(LoggerContext loggerContext, String name, Config config) throws ReflectiveOperationException { List<Object> children = new ArrayList<>(); @SuppressWarnings("unchecked") Class<Appender<ILoggingEvent>> clazz = (Class<Appender<ILoggingEvent>>) Class .forName(config.getString("class")); Appender<ILoggingEvent> appender = this.configureObject(loggerContext, clazz, config, children); appender.setName(name); for (Object child : children) { if (child instanceof RollingPolicy) { ((RollingPolicy) child).setParent((FileAppender<?>) appender); } if (child instanceof LifeCycle) { ((LifeCycle) child).start(); } } appender.start(); return appender; }
protected Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setContext(loggerContext); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}"); rolling.setMaxHistory(maxBackupIndex); rolling.setParent(appender); rolling.start(); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setContext(loggerContext); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); layout.start(); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
@org.junit.Test public void testAppender() { ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); Appender mockAppender = mock(Appender.class); root.addAppender(mockAppender); Appender<ILoggingEvent> appender = root.getAppender("SNMP"); LOG.info("server error", new RuntimeException("info message")); LOG.error("server error", new RuntimeException("error message")); verify(mockAppender,times(2)).doAppend(argThat(new ArgumentMatcher<ILoggingEvent>() { @Override public boolean matches(final Object argument) { return ((LoggingEvent) argument).getFormattedMessage().contains("server error"); } })); Assert.assertThat(appender.getClass().getName(), is(equalTo("com.sathwik.logback.appender.SNMPTrapAppender"))); }
@Test public void getFeatureState_should_return_null_when_name_not_found_exception_is_wrapped() throws Exception{ final Appender<ILoggingEvent> mockAppender = TestLogUtils.addMockAppenderLog(); // Given doReturn(context).when(repository).getInitialContext(); // stub expected behavior of lookup method NamingException exception = new NamingException("jndi exception"); exception.initCause(new NameNotFoundException("invalid name")); doThrow(exception).when(context).lookup(anyString()); // When FeatureState feature = repository.getFeatureState(MyFeature.FEATURE1); // Then assertThat(feature).isNull(); }
public void initRule() { Appender dbTabAppender = buildAppender("TDDL_Vtab_Appender", "tddl-db-tab.log", "%m"); Appender vSlotAppender = buildAppender("TDDL_Vtab_Appender", "tddl-vslot.log", "%m"); Appender dynamicRuleAppender = buildAppender("TDDL_DynamicRule_Appender", "tddl-dynamic-rule.log", "%m"); ch.qos.logback.classic.Logger logger = (Logger) LoggerInit.TDDL_LOG.getDelegate(); logger.setAdditive(false); logger.detachAndStopAllAppenders(); logger.addAppender(dbTabAppender); logger.setLevel(Level.INFO); logger = (Logger) LoggerInit.VSLOT_LOG.getDelegate(); logger.setAdditive(false); logger.detachAndStopAllAppenders(); logger.addAppender(vSlotAppender); logger.setLevel(Level.INFO); logger = (Logger) LoggerInit.DYNAMIC_RULE_LOG.getDelegate(); logger.setAdditive(false); logger.detachAndStopAllAppenders(); logger.addAppender(dynamicRuleAppender); logger.setLevel(Level.INFO); }
@Override protected void append(E event) { if (!isStarted()) { return; } String discriminatingValue = discriminator.getDiscriminatingValue(event); long timestamp = getTimestamp(event); Appender<E> appender = appenderTracker.getOrCreate(discriminatingValue, timestamp); // marks the appender for removal as specified by the user if (eventMarksEndOfLife(event)) { appenderTracker.endOfLife(discriminatingValue); } appenderTracker.removeStaleComponents(timestamp); appender.doAppend(event); }
@SuppressWarnings("unchecked") @Test(timeout = 5000) public void getAppenderBoom() { Appender<Integer> mockAppender1 = mock(Appender.class); when(mockAppender1.getName()).thenThrow(new OutOfMemoryError("oops")); aai.addAppender(mockAppender1); try { // appender.getName called as a result of next statement aai.getAppender("foo"); } catch (OutOfMemoryError e) { // this leaves the read lock locked. } Appender<Integer> mockAppender2=mock(Appender.class); // the next call used to freeze with the earlier ReadWriteLock lock // implementation aai.addAppender(mockAppender2); }
@SuppressWarnings("unchecked") @Test(timeout = 5000) public void detachAppenderBoom() throws InterruptedException { Appender<Integer> mockAppender = mock(Appender.class); when(mockAppender.getName()).thenThrow(new OutOfMemoryError("oops")); mockAppender.doAppend(17); aai.addAppender(mockAppender); Thread t = new Thread(new Runnable() { public void run() { try { // appender.getName called as a result of next statement aai.detachAppender("foo"); } catch (OutOfMemoryError e) { // this leaves the write lock locked. } } }); t.start(); t.join(); // the next call used to freeze with the earlier ReadWriteLock lock // implementation aai.appendLoopOnAppenders(17); }
@Test public void getGetAppender() throws Exception { NOPAppender<TestEvent> test = new NOPAppender<TestEvent>(); test.setName("test"); test.start(); aai.addAppender(test); NOPAppender<TestEvent> testOther = new NOPAppender<TestEvent>(); testOther.setName("testOther"); testOther.start(); aai.addAppender(testOther); Appender<TestEvent> a = aai.getAppender("testOther"); assertNotNull("Could not find appender", a); assertTrue("Wrong appender", a == testOther); a = aai.getAppender("test"); assertNotNull("Could not find appender", a); assertTrue("Wrong appender", a == test); a = aai.getAppender("NotThere"); assertNull("Appender was returned", a); }
@Test public void sessionFinalizationShouldCauseLingering() throws JoranException { String mdcKey = "linger"; String mdcVal = "session" + diff; configure(SIFT_FOLDER_PREFIX + "lingering.xml"); MDC.put(mdcKey, mdcVal); logger.debug("linger 1"); logger.debug(ClassicConstants.FINALIZE_SESSION_MARKER, "linger 2"); long now = System.currentTimeMillis(); SiftingAppender sa = (SiftingAppender) root.getAppender("SIFT"); AppenderTracker<ILoggingEvent> tracker = sa.getAppenderTracker(); assertEquals(1, tracker.allKeys().size()); Appender<ILoggingEvent> appender = tracker.find(mdcVal); assertTrue(appender.isStarted()); tracker.removeStaleComponents(now + AppenderTracker.LINGERING_TIMEOUT + 1); // previously lingering appenders should be closed upon timeout assertFalse(appender.isStarted()); // and they should be gone assertEquals(0, tracker.allKeys().size()); }
@BeforeClass public void setUp() throws JoranException { URL logConfigResource = getClass().getResource("/org/artifactory/traffic/logback.xml"); File logConfigFile = new File(logConfigResource.getFile()); Assert.assertNotNull(logConfigFile, "Cannot locate logback configuration file."); Assert.assertTrue(logConfigFile.exists(), "Cannot locate logback configuration file."); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(lc); lc.stop(); configurator.doConfigure(logConfigFile); Logger logger = lc.getLogger(TrafficLogger.class); Appender<ILoggingEvent> appender = logger.getAppender("TRAFFIC"); System.out.println(appender); }
protected Appender buildAppender(String name, String fileName, String pattern) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setContext(loggerContext); rolling.setParent(appender); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}"); rolling.start(); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setContext(loggerContext); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); layout.start(); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
private Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) { RollingFileAppender appender = new RollingFileAppender(); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}"); rolling.setMaxHistory(maxBackupIndex); rolling.setParent(appender); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
public void doTest(String configFile) throws JoranException { JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(context); configurator.doConfigure(configFile); Appender<IAccessEvent> appender = context.getAppender("DB"); for (int i = 0; i < 10; i++) { IAccessEvent event = DummyAccessEventBuilder.buildNewAccessEvent(); appender.doAppend(event); } StatusPrinter.print(context); // check that there were no errors assertEquals(Status.INFO, statusChecker.getHighestLevel(0)); }
@Override public void setVerboseMode(boolean on) { PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder(); patternLayoutEncoder.setPattern("[%d{HH:mm:ss.SSS}] [%highlight(%level)] %msg%n"); patternLayoutEncoder.setContext(loggerContext); patternLayoutEncoder.start(); Appender<ILoggingEvent> consoleAppender = new ConsoleAppender(); ((OutputStreamAppender) consoleAppender).setEncoder(patternLayoutEncoder); consoleAppender.setContext(loggerContext); consoleAppender.start(); loggerContext.getLogger("com.paypal.butterfly.cli").detachAppender("CONSOLE"); loggerContext.getLogger("ROOT").addAppender(consoleAppender); }
@Override public void addAppender(Appender<ILoggingEvent> appender) { if (emergencyAppender == null) { emergencyAppender = appender; } else { addWarn("One and only one appender may be attached to " + getClass().getSimpleName()); addWarn("Ignoring additional appender named [" + appender.getName() + "]"); } }
@Override public Appender<ILoggingEvent> getAppender(String name) { if (emergencyAppender != null && name != null && name.equals(emergencyAppender.getName())) { return emergencyAppender; } else { return null; } }
@Override public boolean detachAppender(Appender<ILoggingEvent> appender) { if (emergencyAppender == appender) { emergencyAppender = null; return true; } else { return false; } }
/** * Allow only selected logger to print DEBUG events to STDOUT and FILE. * Other loggers are allowed to print ERRORS only. */ private static void addSampleLogger(final String loggerName) { if (CUSTOM_FILTER == null) { CUSTOM_FILTER = new CustomFilter(); final LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Appender ca = loggerContext.getLogger("ROOT").getAppender("STDOUT"); ca.clearAllFilters(); ca.addFilter(CUSTOM_FILTER); } CUSTOM_FILTER.addVisibleLogger(loggerName); }
private static void verifyLog( final Appender mockAppender, final ArgumentCaptor<LoggingEvent> captorLoggingEvent, final String expectedMessage) { verify(mockAppender, times(1)).doAppend(captorLoggingEvent.capture()); final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); assertThat(loggingEvent.getLevel(), is(Level.INFO)); assertThat(loggingEvent.getFormattedMessage(), is(expectedMessage)); }
private static void verifyLog( final Appender mockAppender, final ArgumentCaptor<LoggingEvent> captorLoggingEvent, final int expectedNumOfInvocations, final String expectedLogMessage) { verify(mockAppender, times(expectedNumOfInvocations)).doAppend(captorLoggingEvent.capture()); final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); assertThat(loggingEvent.getLevel(), is(Level.INFO)); assertThat(loggingEvent.getFormattedMessage(), is(expectedLogMessage)); }
private static Path getLogFromLogback( final File logbackConfig ) { try { LoggerContext loggerContext = new LoggerContext(); JoranConfigurator jc = new JoranConfigurator(); jc.setContext( loggerContext ); loggerContext.reset(); jc.doConfigure( logbackConfig ); for ( Logger logger : loggerContext.getLoggerList() ) { for ( Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext(); ) { Appender<ILoggingEvent> appender = index.next(); if ( appender instanceof FileAppender ) { return Paths.get( ( (FileAppender) appender ).getFile() ); } } } return null; } catch ( Exception e ) { return null; } }