@Override public Result filter(LogEvent event) { boolean excludeMatches = (loggingMode == OperationLog.LoggingLevel.VERBOSE); String logLevel = event.getContextMap().get(LogUtils.OPERATIONLOG_LEVEL_KEY); logLevel = logLevel == null ? "" : logLevel; OperationLog.LoggingLevel currentLoggingMode = OperationLog.getLoggingLevel(logLevel); // If logging is disabled, deny everything. if (currentLoggingMode == OperationLog.LoggingLevel.NONE) { return Result.DENY; } // Look at the current session's setting // and set the pattern and excludeMatches accordingly. if (currentLoggingMode != loggingMode) { loggingMode = currentLoggingMode; excludeMatches = (loggingMode == OperationLog.LoggingLevel.VERBOSE); setCurrentNamePattern(loggingMode); } boolean isMatch = namePattern.matcher(event.getLoggerName()).matches(); if (excludeMatches == isMatch) { // Deny if this is black-list filter (excludeMatches = true) and it // matched or if this is whitelist filter and it didn't match return Result.DENY; } return Result.NEUTRAL; }
@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; }
messages.add(InternalLogMessage.create( event.getMessage().getFormattedMessage(), event.getLoggerName(), eventLevel.toString(), marker == null ? null : marker.toString(),
@Test public void testEvent() { final org.apache.logging.log4j.Logger logger = context.getLogger("org.apache.test.LogEventFactory"); logger.error("error message"); final List<LogEvent> events = app.getEvents(); assertNotNull("No events", events); assertEquals("Incorrect number of events. Expected 1, actual " + events.size(), 1, events.size()); final LogEvent event = events.get(0); assertEquals("TestLogEventFactory wasn't used", "Test", event.getLoggerName()); }
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")); } }
assertNotNull(event2[0]); 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("tid", t1.getId(), event1[0].getThreadId()); assertEquals("logger", "b", event2[0].getLoggerName()); assertEquals("level", Level.INFO, event2[0].getLevel()); assertEquals("msg", new SimpleMessage("xyz"), event2[0].getMessage());
@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()); }
@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()); } }
@Override public void append(LogEvent event) { expectations .add(new Expectation(event.getLevel().toString(), event.getLoggerName(), event.getMessage().getFormattedMessage())); }
assertSame(Level.FATAL, e2.getLevel()); assertSame(fqcn, e2.getLoggerFqcn()); assertSame(name, e2.getLoggerName()); assertSame(marker, e2.getMarker()); assertSame(message, e2.getMessage());
assertEquals(evt.getLoggerName(), actual.getLoggerName()); assertEquals(evt.getMarker(), actual.getMarker()); assertEquals(evt.getLoggerFqcn(), actual.getLoggerFqcn());
public AbstractEventExpectation(String name, String logger, Level level, String message) { this.name = name; this.logger = getLoggerName(logger); this.level = level; this.message = message; this.saw = false; }
assertSame(Level.FATAL, event2.getLevel()); assertSame(fqcn, event2.getLoggerFqcn()); assertSame(name, event2.getLoggerName()); assertSame(marker, event2.getMarker()); assertSame(message, event2.getMessage());
@Override public Result filter(LogEvent event) { return filter(event.getLoggerName()); }
@Override public void append(final LogEvent event) { if (event.getLoggerName() != null && event.getLoggerName().startsWith("org.apache.kafka")) { LOGGER.warn("Recursive logging from [{}] for appender [{}].", event.getLoggerName(), getName()); } else { try { tryAppend(event); } catch (final Exception e) { error("Unable to write to Kafka in appender [" + getName() + "]", event, e); } } }
@Override public boolean accept(LogEvent event) { if (logLevel != null && !logLevel.equals(event.getLevel())) { return false; } return loggerName == null || loggerName.equals(event.getLoggerName()); } }
@Override public void match(LogEvent event) { if (event.getLevel().equals(level) && event.getLoggerName().equals(logger)) { if (Pattern.matches(pattern, event.getMessage().getFormattedMessage())) { saw = true; } } }
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 doAppend(@NotNull final LogEvent event, @NotNull final ChronicleLogWriter writer) { writer.write( toChronicleLogLevel(event.getLevel()), event.getTimeMillis(), event.getThreadName(), event.getLoggerName(), event.getMessage().getFormattedMessage(), event.getThrown() ); }