public Map<String, Level> getLoggerLevels() { Configuration loggerConfig = ((LoggerContext) LogManager.getContext(false)).getConfiguration(); Map<String, Level> logLevelMap = new HashMap<>(); for (Map.Entry<String, LoggerConfig> entry : loggerConfig.getLoggers().entrySet()) { logLevelMap.put(entry.getKey(), entry.getValue().getLevel()); } return logLevelMap; }
private boolean hasDebugOrLower(final Configuration config) { for (LoggerConfig loggerConfig : config.getLoggers().values()) { boolean isDebugOrLower = loggerConfig.getLevel().isLessSpecificThan(Level.DEBUG); if (isDebugOrLower) { return true; } } return false; }
@VisibleForTesting protected Level getLoggerLevel(final String loggerName) { final LoggerContext loggerContext = (LoggerContext) LogManager.getContext(false); final Configuration configuration = loggerContext.getConfiguration(); final LoggerConfig loggerConfig = configuration.getLoggerConfig(loggerName); return loggerConfig.getLevel(); }
private LoggerConfiguration convertLoggerConfiguration(LoggerConfig loggerConfig) { if (loggerConfig == null) { return null; } LogLevel level = LEVELS.convertNativeToSystem(loggerConfig.getLevel()); String name = loggerConfig.getName(); if (!StringUtils.hasLength(name) || LogManager.ROOT_LOGGER_NAME.equals(name)) { name = ROOT_LOGGER_NAME; } return new LoggerConfiguration(name, level, level); }
@GET @Timed @ApiOperation(value = "List all loggers and their current levels") @Produces(MediaType.APPLICATION_JSON) public LoggersSummary loggers() { final Collection<LoggerConfig> loggerConfigs = getLoggerConfigs(); final Map<String, SingleLoggerSummary> loggers = Maps.newHashMapWithExpectedSize(loggerConfigs.size()); for (LoggerConfig config : loggerConfigs) { if (!isPermitted(RestPermissions.LOGGERS_READ, config.getName())) { continue; } final Level level = config.getLevel(); loggers.put(config.getName(), SingleLoggerSummary.create(level.toString().toLowerCase(Locale.ENGLISH), level.intLevel())); } return LoggersSummary.create(loggers); }
private void listLoggers(final HttpServletResponse response) throws IOException { PrintWriter writer = null; try { writer = response.getWriter(); ConfLoggers confLoggers = new ConfLoggers(); Collection<LoggerConfig> loggerConfigs = conf.getLoggers().values(); loggerConfigs.forEach(lc -> confLoggers.getLoggers().add(new ConfLogger(lc.getName(), lc.getLevel().toString()))); ObjectMapper objectMapper = new ObjectMapper(); objectMapper.writerWithDefaultPrettyPrinter().writeValue(writer, confLoggers); } catch (IOException e) { LOG.error("Caught an exception while processing Log4j2 configuration request", e); response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); return; } finally { if (writer != null) { writer.close(); } } response.setStatus(HttpServletResponse.SC_OK); } }
@Override public void evaluate() throws Throwable { final CompositeConfiguration config = (CompositeConfiguration) lcr.getConfiguration(); //Test for Root log level override assertEquals("Expected Root logger log level to be WARN", Level.WARN, config.getRootLogger().getLevel()); //Test for cat2 level override final LoggerConfig cat2 = config.getLogger("cat2"); assertEquals("Expected cat2 log level to be INFO", Level.INFO, cat2.getLevel()); //Test for cat2 additivity override assertTrue("Expected cat2 additivity to be true", cat2.isAdditive()); //Regression //Check level on cat3 (not present in root config) assertEquals("Expected cat3 log level to be ERROR", Level.ERROR, config.getLogger("cat3").getLevel()); //Check level on cat1 (not present in overriden config) assertEquals("Expected cat1 log level to be DEBUG", Level.DEBUG, config.getLogger("cat1").getLevel()); } };
@Test public void testBadStatus() throws Exception { ctx = Configurator.initialize("Test1", "bad/log4j-status.xml"); LogManager.getLogger("org.apache.test.TestConfigurator"); final Configuration config = ctx.getConfiguration(); assertNotNull("No configuration", config); assertEquals("Unexpected Configuration", "XMLConfigTest", config.getName()); final LoggerConfig root = config.getLoggerConfig(""); assertNotNull("No Root Logger", root); assertTrue("Expected error level, was " + root.getLevel(), Level.ERROR == root.getLevel()); }
@Test public void testInheritParentDefaultLevel() throws IOException { Configuration configuration = loadConfiguration(prefix + "default-level.xml"); try { assertEquals(Level.ERROR, configuration.getLoggerConfig("com.foo").getLevel()); } finally { configuration.stop(); } }
@Test public void testInheritParentLevel() throws IOException { Configuration configuration = loadConfiguration(prefix + "inherit-level.xml"); try { assertEquals(Level.TRACE, configuration.getLoggerConfig("com.foo").getLevel()); } finally { configuration.stop(); } }
assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2); final LoggerConfig rootLoggerConfig = loggers.get(""); assertEquals(Level.ERROR, rootLoggerConfig.getLevel()); assertFalse(rootLoggerConfig.isIncludeLocation()); final LoggerConfig loggerConfig = loggers.get("org.apache.logging.log4j"); assertEquals(Level.DEBUG, loggerConfig.getLevel()); assertTrue(loggerConfig.isIncludeLocation()); final Filter filter = config.getFilter();
@Test public void testLevelInheritence() throws Exception { final Configuration config = context.getConfiguration(); final LoggerConfig loggerConfig = config.getLoggerConfig("org.apache.logging.log4j.core.LoggerTest"); assertNotNull(loggerConfig); assertEquals(loggerConfig.getName(), "org.apache.logging.log4j.core.LoggerTest"); assertEquals(loggerConfig.getLevel(), Level.DEBUG); final Logger localLogger = context.getLogger("org.apache.logging.log4j.core.LoggerTest"); assertTrue("Incorrect level - expected DEBUG, actual " + localLogger.getLevel(), localLogger.getLevel() == Level.DEBUG); }
assertEquals(Level.ERROR, root.getLevel());
@Before public void before() { currentClassLoader = Thread.currentThread().getContextClassLoader(); when(loggerContext.getConfiguration().getLoggerConfig(anyString()).getLevel()).thenReturn(Level.INFO); logger = new DispatchingLogger(originalLogger, currentClassLoader.hashCode(), loggerContext, contextSelector, messageFactory) { @Override public String getName() { return LOGGER_NAME; } }; }
public PrivateConfig(final PrivateConfig pc, final LoggerConfig lc) { this.config = pc.config; this.loggerConfig = lc; this.loggerConfigLevel = lc.getLevel(); this.intLevel = this.loggerConfigLevel.intLevel(); this.logger = pc.logger; }
/** Override the logging level of a given logger, return the previous level */ public static Level setLevel(Logger log, Level level) { LoggerContext ctx = (LoggerContext)LogManager.getContext(false); Configuration conf = ctx.getConfiguration(); LoggerConfig lconf = conf.getLoggerConfig(log.getName()); Level oldLevel = lconf.getLevel(); lconf.setLevel(level); ctx.updateLoggers(conf); return oldLevel; }
/** Override the logging level of a given logger, return the previous level */ private Level setLevel(String loggerName, Level level) { LoggerContext ctx = (LoggerContext)LogManager.getContext(false); Configuration conf = ctx.getConfiguration(); LoggerConfig lconf = conf.getLoggerConfig(loggerName); Level oldLevel = lconf.getLevel(); lconf.setLevel(level); ctx.updateLoggers(conf); return oldLevel; }
public void addToLogger(String loggerName, Level level) { LoggerConfig loggerConfig = LOGGER_CONTEXT_CONFIGURATION.getLoggerConfig(loggerName); // Make sure the logger accepts messages at the given level if (level.isLessSpecificThan(loggerConfig.getLevel())) { loggerConfig.setLevel(level); } loggerConfig.addAppender(this, level, null); LOGGER_CONTEXT.updateLoggers(); }