@Override public void format(LogEvent event, StringBuilder toAppendTo) { StringBuilder buf = new StringBuilder(); for (PatternFormatter formatter : this.formatters) { formatter.format(event, buf); } if (buf.length() > 0) { AnsiElement element = this.styling; if (element == null) { // Assume highlighting element = LEVELS.get(event.getLevel().intLevel()); element = (element != null) ? element : AnsiColor.GREEN; } appendAnsiString(toAppendTo, buf.toString(), element); } }
@Override public void append(final LogEvent event) { LOGGER.trace("Handling append of {} in {}.", event, this); if (isPaused()) { LOGGER.trace("Skipping append of {} because {} is paused.", event, this); return; } if (!hasAlertLevel(event.getLevel())) { LOGGER.trace("Skipping append of {} because level is {}.", event, event.getLevel()); return; } if (AlertingAction.isThreadAlerting()) { // If already appending then don't send to avoid infinite recursion LOGGER.trace("Skipping append of {} because {} is alerting.", event, Thread.currentThread()); return; } AlertingAction.execute(() -> doAppend(event)); }
public static List<String> findLogMessagesContaining(Level level, String substring) { return EVENTS.stream() .filter(event -> event.getLevel() == level) .map(LogEvent::getMessage) .map(Message::getFormattedMessage) .filter(msg -> msg.contains(substring)) .collect(Collectors.toList()); }
@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; }
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); } } }
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); } } }
final List<InternalLogMessage> messages = new ArrayList<>(limit); for (LogEvent event : memoryAppender.getLogMessages(limit)) { final Level eventLevel = event.getLevel(); if (!eventLevel.isMoreSpecificThan(logLevel)) { continue;
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); } }
@Test public void testLog() { final Logger logger = context.getLogger(); final List<LogEvent> events = listAppender.getEvents(); assertThat(events, hasSize(0)); logger.debug("Hello, {}", "World"); assertThat(events, hasSize(1)); logger.log(warnLevel, "Hello DIAG"); assertThat(events, hasSize(2)); assertEquals(events.get(1).getLevel(), warnLevel); } }
@Test public void testLog() { final Logger logger = context.getLogger(); final List<LogEvent> events = listAppender.getEvents(); assertThat(events, hasSize(0)); logger.debug("Hello, {}", "World"); assertThat(events, hasSize(1)); logger.log(diagLevel, "Hello DIAG"); assertThat(events, hasSize(2)); assertEquals(events.get(1).getLevel(), diagLevel); } }
@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()); } }
protected void assertLogEvent(final LogEvent logEvent) { assertThat(logEvent, is(notNullValue())); assertThat(logEvent.getInstant().getEpochMillisecond(), equalTo(1493121664118L)); assertThat(logEvent.getThreadName(), equalTo("main")); assertThat(logEvent.getThreadId(), equalTo(1L)); assertThat(logEvent.getThreadPriority(), equalTo(5)); assertThat(logEvent.getLevel(), equalTo(Level.INFO)); assertThat(logEvent.getLoggerName(), equalTo("HelloWorld")); assertThat(logEvent.getMarker().getName(), equalTo("child")); assertThat(logEvent.getMarker().getParents()[0].getName(), equalTo("parent")); assertThat(logEvent.getMarker().getParents()[0].getParents()[0].getName(), equalTo("grandparent")); assertThat(logEvent.getMessage().getFormattedMessage(), equalTo("Hello, world!")); assertThat(logEvent.getThrown(), is(nullValue())); assertThat(logEvent.getThrownProxy().getMessage(), equalTo("error message")); assertThat(logEvent.getThrownProxy().getName(), equalTo("java.lang.RuntimeException")); assertThat(logEvent.getThrownProxy().getExtendedStackTrace()[0].getClassName(), equalTo("logtest.Main")); assertThat(logEvent.getLoggerFqcn(), equalTo("org.apache.logging.log4j.spi.AbstractLogger")); assertThat(logEvent.getContextStack().asList(), equalTo(Arrays.asList("one", "two"))); assertThat((String) logEvent.getContextData().getValue("foo"), equalTo("FOO")); assertThat((String) logEvent.getContextData().getValue("bar"), equalTo("BAR")); assertThat(logEvent.getSource().getClassName(), equalTo("logtest.Main")); } }
assertNotSame(event1[0], event2[0]); assertEquals("logger", "a", event1[0].getLoggerName()); assertEquals("level", Level.DEBUG, event1[0].getLevel()); assertEquals("msg", new SimpleMessage("abc"), event1[0].getMessage()); assertEquals("thread name", "THREAD 1", event1[0].getThreadName()); assertEquals("level", Level.INFO, event2[0].getLevel()); assertEquals("msg", new SimpleMessage("xyz"), event2[0].getMessage()); assertEquals("thread name", "Thread 2", event2[0].getThreadName());
@Test public void testCreateEventOverwritesFields() throws Exception { final ReusableLogEventFactory factory = new ReusableLogEventFactory(); final LogEvent event1 = callCreateEvent(factory, "a", Level.DEBUG, new SimpleMessage("abc"), null); assertEquals("logger", "a", event1.getLoggerName()); assertEquals("level", Level.DEBUG, event1.getLevel()); assertEquals("msg", new SimpleMessage("abc"), event1.getMessage()); ReusableLogEventFactory.release(event1); final LogEvent event2 = callCreateEvent(factory, "b", Level.INFO, new SimpleMessage("xyz"), null); assertSame(event1, event2); assertEquals("logger", "b", event1.getLoggerName()); assertEquals("level", Level.INFO, event1.getLevel()); assertEquals("msg", new SimpleMessage("xyz"), event1.getMessage()); assertEquals("logger", "b", event2.getLoggerName()); assertEquals("level", Level.INFO, event2.getLevel()); assertEquals("msg", new SimpleMessage("xyz"), event2.getMessage()); }
rewrite); LogEvent rewritten = updatePolicy.rewrite(logEvent); Assert.assertEquals(Level.DEBUG, rewritten.getLevel()); logEvent = Log4jLogEvent.newBuilder().setLoggerName(loggerNameRewrite) .setLoggerFqcn("LoggerNameLevelRewritePolicyTest.testUpdate()").setLevel(Level.WARN) .setTimeMillis(1).build(); rewritten = updatePolicy.rewrite(logEvent); Assert.assertEquals(Level.INFO, rewritten.getLevel()); final String loggerNameReadOnly = "com.nochange"; logEvent = Log4jLogEvent.newBuilder().setLoggerName(loggerNameReadOnly) .setTimeMillis(1).build(); rewritten = updatePolicy.rewrite(logEvent); Assert.assertEquals(Level.INFO, rewritten.getLevel()); logEvent = Log4jLogEvent.newBuilder().setLoggerName(loggerNameReadOnly) .setLoggerFqcn("LoggerNameLevelRewritePolicyTest.testUpdate()").setLevel(Level.WARN) .setTimeMillis(1).build(); rewritten = updatePolicy.rewrite(logEvent); Assert.assertEquals(Level.WARN, rewritten.getLevel());
@SuppressWarnings("deprecation") static void assertEqualLogEvents(final LogEvent expected, final LogEvent actual, final boolean includeSource, final boolean includeContext, final boolean includeStacktrace) { assertEquals(expected.getClass(), actual.getClass()); assertEquals(includeContext ? expected.getContextData() : ContextDataFactory.createContextData(), actual.getContextData()); assertEquals(includeContext ? expected.getContextMap() : Collections.EMPTY_MAP, actual.getContextMap()); assertEquals(expected.getContextStack(), actual.getContextStack()); assertEquals(expected.getLevel(), actual.getLevel()); assertEquals(expected.getLoggerName(), actual.getLoggerName()); assertEquals(expected.getLoggerFqcn(), actual.getLoggerFqcn()); assertEquals(expected.getMarker(), actual.getMarker()); assertEquals(expected.getMessage(), actual.getMessage()); assertEquals(expected.getTimeMillis(), actual.getTimeMillis()); assertEquals(includeSource ? expected.getSource() : null, actual.getSource()); assertEquals(expected.getThreadName(), actual.getThreadName()); assertNotNull("original should have an exception", expected.getThrown()); assertNull("exception should not be serialized", actual.getThrown()); if (includeStacktrace) { // TODO should compare the rest of the ThrowableProxy assertEquals(expected.getThrownProxy(), actual.getThrownProxy()); } assertEquals(expected.isEndOfBatch(), actual.isEndOfBatch()); assertEquals(expected.isIncludeLocation(), actual.isIncludeLocation()); // original: non-null thrown & null thrownProxy // deserialized: null thrown & non-null thrownProxy assertNotEquals(expected.hashCode(), actual.hashCode()); assertNotEquals(expected, actual); }
@SuppressWarnings("deprecation") private void compareLogEvents(final LogEvent orig, final LogEvent changed) { // Ensure that everything but the Mapped Data is still the same assertEquals("LoggerName changed", orig.getLoggerName(), changed.getLoggerName()); assertEquals("Marker changed", orig.getMarker(), changed.getMarker()); assertEquals("FQCN changed", orig.getLoggerFqcn(), changed.getLoggerFqcn()); assertEquals("Level changed", orig.getLevel(), changed.getLevel()); assertArrayEquals("Throwable changed", orig.getThrown() == null ? null : orig.getThrownProxy().getExtendedStackTrace(), changed.getThrown() == null ? null : changed.getThrownProxy().getExtendedStackTrace() ); assertEquals("ContextMap changed", orig.getContextMap(), changed.getContextMap()); assertEquals("ContextData changed", orig.getContextData(), changed.getContextData()); assertEquals("ContextStack changed", orig.getContextStack(), changed.getContextStack()); assertEquals("ThreadName changed", orig.getThreadName(), changed.getThreadName()); assertEquals("Source changed", orig.getSource(), changed.getSource()); assertEquals("Millis changed", orig.getTimeMillis(), changed.getTimeMillis()); } }
assertEquals(true, e2.isEndOfBatch()); assertEquals(true, e2.isIncludeLocation()); assertSame(Level.FATAL, e2.getLevel()); assertSame(fqcn, e2.getLoggerFqcn()); assertSame(name, e2.getLoggerName());
assertEquals(evt.getMarker(), actual.getMarker()); assertEquals(evt.getLoggerFqcn(), actual.getLoggerFqcn()); assertEquals(evt.getLevel(), actual.getLevel()); assertEquals(evt.getMessage(), actual.getMessage()); assertEquals(evt.getThrown(), actual.getThrown());