private void configureLoggerContextByURL(LoggerContext context, URL url) { try { JoranConfigurator configurator = new JoranConfigurator(); context.reset(); configurator.setContext(context); configurator.doConfigure(url); } catch (JoranException e) { } StatusPrinter.printInCaseOfErrorsOrWarnings(context); }
/** * To disable the logger from some classes that throw errors and some other spam stuff into our console. * */ private void disableLogger(Class<?> clazz) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger l = loggerContext.getLogger(clazz); ((ch.qos.logback.classic.Logger) l).setLevel(Level.OFF); }
/** * Retrieve all configured logback loggers. * * @param showAll If set return ALL loggers, not only the configured ones. * @return List of Loggers */ public static List<ch.qos.logback.classic.Logger> getLoggers(final boolean showAll) { final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); final List<ch.qos.logback.classic.Logger> loggers = new ArrayList<ch.qos.logback.classic.Logger>(); for (ch.qos.logback.classic.Logger log : lc.getLoggerList()) { if(showAll == false) { if(log.getLevel() != null || LoggingUtil.hasAppenders(log)) { loggers.add(log); } } else { loggers.add(log); } } return loggers; }
public void stop() { reset(); fireOnStop(); resetAllListeners(); super.stop(); }
protected void configureWith(URL resource) { JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext((LoggerContext) loggerFactory); ((LoggerContext) loggerFactory).reset(); // the statusManager keeps a copy of all logback status messages even after reset, so we clear that ((LoggerContext) loggerFactory).getStatusManager().clear(); try { configurator.doConfigure(resource); } catch (JoranException ignore) { } StatusPrinter.printInCaseOfErrorsOrWarnings((Context) loggerFactory); }
private static LoggerContext configureContext(LoggerContext context, Map<String, String> substitutionVariables) { context.reset(); for (Map.Entry<String, String> entry : substitutionVariables.entrySet()) { context.putProperty(entry.getKey(), entry.getValue()); } return context; }
(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ROOT_LOGGER_NAME); final LoggerContext context = rootLogger.getLoggerContext(); context.reset(); final PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setContext(context); ple.setPattern("%d{HH:mm:ss.SSS} %-5level %logger{1} %F:%L - %msg%n"); ple.start(); fileAppender.start(); rootLogger.setLevel(Level.DEBUG); rootLogger.addAppender(fileAppender);
private void hijackJDKLogging() { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); final Logger root = (Logger)LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); final LevelChangePropagator propagator = new LevelChangePropagator(); propagator.setContext(root.getLoggerContext()); propagator.setResetJUL(true); root.getLoggerContext().addListener(propagator); }
@Test public void log_to_ce_file() { LoggerContext ctx = underTest.configure(props); Logger root = ctx.getLogger(Logger.ROOT_LOGGER_NAME); Appender<ILoggingEvent> appender = root.getAppender("file_ce"); assertThat(appender).isInstanceOf(FileAppender.class); FileAppender fileAppender = (FileAppender) appender; assertThat(fileAppender.getFile()).isEqualTo(new File(logDir, "ce.log").getAbsolutePath()); assertThat(fileAppender.getEncoder()).isInstanceOf(PatternLayoutEncoder.class); PatternLayoutEncoder encoder = (PatternLayoutEncoder) fileAppender.getEncoder(); assertThat(encoder.getPattern()).isEqualTo("%d{yyyy.MM.dd HH:mm:ss} %-5level ce[%X{ceTaskUuid}][%logger{20}] %msg%n"); }
@Test public void configure_turns_off_some_MsSQL_driver_logger() { LoggerContext context = underTest.configure(props); Stream.of("com.microsoft.sqlserver.jdbc.internals", "com.microsoft.sqlserver.jdbc.ResultSet", "com.microsoft.sqlserver.jdbc.Statement", "com.microsoft.sqlserver.jdbc.Connection") .forEach(loggerName -> assertThat(context.getLogger(loggerName).getLevel()).isEqualTo(Level.OFF)); }
@Test public void isOperational_must_log_once_when_master_is_not_elected() { MemoryAppender<ILoggingEvent> memoryAppender = new MemoryAppender<>(); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); lc.reset(); memoryAppender.setContext(lc); memoryAppender.start(); lc.getLogger(EsProcessMonitor.class).addAppender(memoryAppender); EsConnector esConnector = mock(EsConnector.class); when(esConnector.getClusterHealthStatus()) .thenThrow(new MasterNotDiscoveredException("Master not elected -test-")); EsProcessMonitor underTest = new EsProcessMonitor(mock(Process.class), ProcessId.ELASTICSEARCH, esConnector); assertThat(underTest.isOperational()).isFalse(); assertThat(memoryAppender.events).isNotEmpty(); assertThat(memoryAppender.events) .extracting(ILoggingEvent::getLevel, ILoggingEvent::getMessage) .containsOnlyOnce( tuple(Level.INFO, "Elasticsearch is waiting for a master to be elected. Did you start all the search nodes ?") ); // Second call must not log another message assertThat(underTest.isOperational()).isFalse(); assertThat(memoryAppender.events) .extracting(ILoggingEvent::getLevel, ILoggingEvent::getMessage) .containsOnlyOnce( tuple(Level.INFO, "Elasticsearch is waiting for a master to be elected. Did you start all the search nodes ?") ); }
@Test public void root_logger_writes_to_console_with_formatting_and_to_sonar_log_file_when_running_from_ITs() { emulateRunFromCommandLine(true); LoggerContext ctx = underTest.configure(); Logger rootLogger = ctx.getLogger(ROOT_LOGGER_NAME); verifyAppConsoleAppender(rootLogger.getAppender("APP_CONSOLE")); verifySonarLogFileAppender(rootLogger.getAppender("file_sonar")); assertThat(rootLogger.iteratorForAppenders()).hasSize(2); ctx.getLoggerList() .stream() .filter(logger -> !ROOT_LOGGER_NAME.equals(logger.getName())) .forEach(AppLoggingTest::verifyNoFileAppender); }
private void setLevelToOff(Level globalLogLevel) { Properties properties = new Properties(); properties.setProperty("sonar.log.level", globalLogLevel.toString()); LoggerContext context = underTest.apply(newLogLevelConfig().offUnlessTrace("fii").build(), new Props(properties)); assertThat(context.getLogger("fii").getLevel()).isEqualTo(Level.OFF); }
LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME); rootLogger.detachAndStopAllAppenders(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n"); encoder.start(); fileAppender.setEncoder(encoder); rootLogger.addAppender(fileAppender); rootLogger.setLevel(Level.toLevel(level)); rootLogger.setAdditive(false);
@Test public void do_not_log_to_console() { LoggerContext ctx = underTest.configure(props); Logger root = ctx.getLogger(Logger.ROOT_LOGGER_NAME); Appender appender = root.getAppender("CONSOLE"); assertThat(appender).isNull(); }
@Test public void gobbler_logger_writes_to_console_without_formatting_when_running_from_command_line() { emulateRunFromCommandLine(false); LoggerContext ctx = underTest.configure(); Logger gobblerLogger = ctx.getLogger(LOGGER_GOBBLER); verifyGobblerConsoleAppender(gobblerLogger); assertThat(gobblerLogger.iteratorForAppenders()).hasSize(1); }
public static void configure(LoggerContext lc) { StatusManager sm = lc.getStatusManager(); if(sm != null) { sm.add(new InfoStatus("Setting up default configuration.", lc)); } ConsoleAppender<ILoggingEvent> ca = new ConsoleAppender<ILoggingEvent>(); ca.setContext(lc); ca.setName("console"); PatternLayoutEncoder pl = new PatternLayoutEncoder(); pl.setContext(lc); pl.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"); pl.start(); ca.setEncoder(pl); ca.start(); Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME); rootLogger.addAppender(ca); }
/** * Initializes the logger. This is called when we need to create a new * logger for the given file name. * * @param fileStr * @return a new Logger instance for the given fileStr * @throws IOException */ protected Logger initLogger(String fileStr) throws IOException { String loggerName = "NagiosWriter" + this.hashCode(); final PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern(LOG_PATTERN); encoder.start(); final FileAppender appender = new FileAppender(); appender.setContext(loggerContext); appender.setName(loggerName + "File"); appender.setAppend(true); appender.setBufferSize(new FileSize(LOG_IO_BUFFER_SIZE_BYTES)); appender.setFile(fileStr); appender.setEncoder(encoder); appender.start(); Logger logger = loggerContext.getLogger(loggerName); logger.addAppender(appender); logger.setLevel(Level.INFO); logger.setAdditive(false); return logger; }
private Logger configureLoggers(String name) { final Logger root = loggerContext.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); loggerContext.reset(); propagator.setResetJUL(true); loggerContext.addListener(propagator); root.setLevel(toLevel(level)); final Logger logger = loggerContext.getLogger(entry.getKey()); final JsonNode jsonNode = entry.getValue(); if (jsonNode.isTextual()) { logger.setLevel(Level.valueOf(jsonNode.asText())); } else if (jsonNode.isObject()) { throw new IllegalArgumentException("Wrong format of logger '" + entry.getKey() + "'", e); logger.setLevel(toLevel(configuration.getLevel())); logger.setAdditive(configuration.isAdditive());
public static void setupLogger() { ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory(); if (loggerFactory instanceof LoggerContext) { LoggerContext lc = (LoggerContext) loggerFactory; if (U.isEmpty(lc.getCopyOfPropertyMap())) { Logger root = lc.getLogger(Logger.ROOT_LOGGER_NAME); root.setLevel(Level.INFO); } } }