Refine search
final Level logLevel = Level.toLevel(level, Level.ALL); final MemoryAppender memoryAppender = (MemoryAppender) appender; final List<InternalLogMessage> messages = new ArrayList<>(limit); for (LogEvent event : memoryAppender.getLogMessages(limit)) { final Level eventLevel = event.getLevel(); if (!eventLevel.isMoreSpecificThan(logLevel)) { continue; final ThrowableProxy thrownProxy = event.getThrownProxy(); final String throwable; if (thrownProxy == null) { final Marker marker = event.getMarker(); messages.add(InternalLogMessage.create( event.getMessage().getFormattedMessage(), event.getLoggerName(), eventLevel.toString(), marker == null ? null : marker.toString(), new DateTime(event.getTimeMillis(), DateTimeZone.UTC),
private void sendAlertMessage(final LogEvent event) { AlertMessaging alertMessaging = alertMessagingRef.get(); if (alertMessaging == null || listeners.isEmpty()) { LOGGER.trace("Skipping alert messaging for {} because listeners is empty.", event); return; } AlertLevel alertLevel = AlertLevelConverter.fromLevel(event.getLevel()); Date date = new Date(event.getTimeMillis()); String threadName = event.getThreadName(); String formattedMessage = event.getMessage().getFormattedMessage(); String stackTrace = getStackTrace(event); for (AlertListener listener : listeners) { if (event.getLevel().intLevel() > listener.getLevel().intLevel()) { break; } LOGGER.trace("Sending alert message for {} to {}.", event, listener.getMember()); alertMessaging.sendAlert(listener.getMember(), alertLevel, date, threadName, formattedMessage, stackTrace); } }
@Override public Result filter(LogEvent event) { if (event.getLevel().equals(Level.INFO) && "SessionState".equals(event.getLoggerName())) { if (event.getMessage().getFormattedMessage().startsWith("PREHOOK:") || event.getMessage().getFormattedMessage().startsWith("POSTHOOK:") || event.getMessage().getFormattedMessage().startsWith("unix_timestamp(void)") || event.getMessage().getFormattedMessage().startsWith("Warning: ") ) { return Result.ACCEPT; } } return Result.DENY; }
protected LineFilterResult acceptsLogEntry(Level logLevel, LocalDateTime logTimestamp) { if (logTimestamp == null || logLevel == null) { throw new IllegalArgumentException(); } LineFilterResult result; if (endDate != null && logTimestamp.isAfter(endDate)) { result = LineFilterResult.REMAINDER_OF_FILE_REJECTED; } else if (startDate != null && logTimestamp.isBefore(startDate)) { result = LineFilterResult.LINE_REJECTED; } else { if (thisLevelOnly) { result = logLevel.intLevel() == thisLogLevel.intLevel() ? LineFilterResult.LINE_ACCEPTED : LineFilterResult.LINE_REJECTED; } else { result = logLevel.isMoreSpecificThan(thisLogLevel) ? LineFilterResult.LINE_ACCEPTED : LineFilterResult.LINE_REJECTED; } } resultOfPreviousLine = result; return result; }
/** * Removes a StatusListener. * * @param listener The StatusListener to remove. */ public void removeListener(final StatusListener listener) { closeSilently(listener); listenersLock.writeLock().lock(); try { listeners.remove(listener); int lowest = Level.toLevel(DEFAULT_STATUS_LEVEL, Level.WARN).intLevel(); for (final StatusListener statusListener : listeners) { final int level = statusListener.getStatusLevel().intLevel(); if (lowest < level) { lowest = level; } } listenersLevel = lowest; } finally { listenersLock.writeLock().unlock(); } }
@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 static AsyncQueueFullPolicy createDiscardingAsyncQueueFullPolicy() { final PropertiesUtil util = PropertiesUtil.getProperties(); final String level = util.getStringProperty(PROPERTY_NAME_DISCARDING_THRESHOLD_LEVEL, Level.INFO.name()); final Level thresholdLevel = Level.toLevel(level, Level.INFO); LOGGER.debug("Creating custom DiscardingAsyncQueueFullPolicy(discardThreshold:{})", thresholdLevel); return new DiscardingAsyncQueueFullPolicy(thresholdLevel); } }
@Override public void setLevel(Level level) { this.level = level; org.apache.logging.log4j.Level l = org.apache.logging.log4j.Level.toLevel(level.getName(), org.apache.logging.log4j.Level.ERROR); logger.setLevel(l); logger.getContext().getConfiguration().getLoggerConfig(this.logger.getName()).setLevel(l); }
public void setLoggerLevel(LoggerContext logContext, String loggerName, String newLevelStr) { Level newLevel = Level.getLevel(newLevelStr); Configuration configuration = logContext.getConfiguration(); LoggerConfig loggerConfig = configuration.getLoggerConfig(loggerName); if (loggerConfig.getName().equalsIgnoreCase(loggerName)) { LOG.info("Setting {} log level to: {}", loggerConfig, newLevel); loggerConfig.setLevel(newLevel); } else { // create a new config. Make it additive (true) s.t. inherit parents appenders LoggerConfig newLoggerConfig = new LoggerConfig(loggerName, newLevel, true); LOG.info("Adding config for: {} with level: {}", newLoggerConfig, newLevel); configuration.addLogger(loggerName, newLoggerConfig); } } }
@Test public void testLevelLogging() { org.apache.logging.log4j.Logger logger = context.getLogger("org.apache.logging.log4j.test1"); logger.log(ExtendedLevels.DETAIL, "Detail message"); logger.log(Level.DEBUG, "Debug message"); List<LogEvent> events = list1.getEvents(); assertNotNull("No events", events); assertThat(events, hasSize(1)); LogEvent event = events.get(0); assertEquals("Expected level DETAIL, got" + event.getLevel(), "DETAIL", event.getLevel().name()); logger = context.getLogger("org.apache.logging.log4j.test2"); logger.log(ExtendedLevels.NOTE, "Note message"); logger.log(Level.INFO, "Info message"); events = list2.getEvents(); assertNotNull("No events", events); assertThat(events, hasSize(1)); event = events.get(0); assertEquals("Expected level NOTE, got" + event.getLevel(), "NOTE", event.getLevel().name()); } }
public ShortenedLogEvent(final LogEvent logEvent) { level = logEvent.getLevel().name(); loggerName = logEvent.getLoggerName(); threadName = logEvent.getThreadName(); timeStamp = logEvent.getTimeMillis(); message = logEvent.getMessage().getFormattedMessage(); }
@Override public void append(LogEvent event) { expectations .add(new Expectation(event.getLevel().toString(), event.getLoggerName(), event.getMessage().getFormattedMessage())); }
public static void setLevel(String level) { LoggerContext ctx = (LoggerContext) LogManager.getContext(false); Configuration config = ctx.getConfiguration(); LoggerConfig loggerConfig = config.getLoggerConfig(LogManager.ROOT_LOGGER_NAME); loggerConfig.setLevel(Level.valueOf(level)); ctx.updateLoggers(); // This causes all Loggers to refetch information from their LoggerConfig. }
sb.append(getThreadName()); sb.append(SPACE); sb.append(level.toString()); sb.append(SPACE); sb.append(msg.getFormattedMessage()); final Object[] params = msg.getParameters(); Throwable t; if (throwable == null && params != null && params[params.length - 1] instanceof Throwable) {
/** * Checks the level, if acceptable calls * {@link String#format(String, Object...)} at the appropriate level * * @param logger * @param string * @param debug * @param obj */ public static void format(Logger logger, String string, Level debug, Object... obj) { final Level l = logger.getLevel(); if (debug.isMoreSpecificThan(l)) { logger.log(debug, String.format(string, obj)); } } }
@Before public void before() { context = getDefaultContext(); testAppender = new TestAppender(TEST_APPENDER, null, null); context.getConfiguration().addAppender(testAppender); LoggerConfig loggerConfig = AsyncLoggerConfig.createLogger("false", LEVEL.name(), CATEGORY, "true", new AppenderRef[] {AppenderRef.createAppenderRef(TEST_APPENDER, null, null)}, null, context.getConfiguration(), null); loggerConfig.addAppender(testAppender, null, null); context.getConfiguration().addLogger(CATEGORY, loggerConfig); context.getConfiguration().start(); context.updateLoggers(); }
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 logMessage(final String fqcn, final Level level, final Marker marker, final Message data, final Throwable t) { assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel)); if (marker == null) { if (currentEvent.markerName != null) { fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage()); } else { assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data, data.getClass().isAssignableFrom(currentEvent.data.getClass())); assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " + data.getFormattedMessage(), currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage()));
public void append(LogEvent event) { Level level = event.getLevel(); if (level.equals(Level.INFO)) { counts.incr(INFO); } else if (level.equals(Level.WARN)) { counts.incr(WARN); } else if (level.equals(Level.ERROR)) { counts.incr(ERROR); } else if (level.equals(Level.FATAL)) { counts.incr(FATAL); } } }