@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); }
@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; }
@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; }
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); } }
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), throwable, event.getThreadName(), event.getContextData().toMap() ));
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")); } }
@Override public String toSerializable(final LogEvent event) { return event.getMessage().getFormattedMessage() + Strings.LINE_SEPARATOR; }
@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() ); }
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())); }
@Test public void paramWithExceptionTest() throws Exception { logger.error("Throwing with parameters {}", "TestParam", new NullPointerException("Test Exception")); final List<LogEvent> events = app.getEvents(); assertNotNull("Log event list not returned", events); assertEquals("Incorrect number of log events", 1, events.size()); final LogEvent event = events.get(0); final Throwable thrown = event.getThrown(); assertNotNull("No throwable present in log event", thrown); final Message msg = event.getMessage(); assertEquals("Throwing with parameters {}", msg.getFormat()); assertEquals("Throwing with parameters TestParam", msg.getFormattedMessage()); assertArrayEquals(new Object[] { "TestParam", thrown }, msg.getParameters()); } }
private LogEvent subLog(LogEvent event) { return Log4jLogEvent.newBuilder() .setLevel(event.getLevel()) .setLoggerName(event.getLoggerName()) .setLoggerFqcn(event.getLoggerFqcn()) .setMessage(subAppend(event)) .setThrown(event.getThrown()) .setContextData((StringMap) event.getContextData()) .setContextStack(event.getContextStack()) .setThreadName(event.getThreadName()) .setSource(event.getSource()) .setTimeMillis(event.getTimeMillis()) .build(); }
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("thread name", "THREAD 1", event1[0].getThreadName()); 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()); assertEquals("thread name", "Thread 2", event2[0].getThreadName()); assertEquals("tid", t2.getId(), event2[0].getThreadId()); ReusableLogEventFactory.release(event1[0]); ReusableLogEventFactory.release(event2[0]);
public void log(final LogEvent event) { if (event == null) { return; } final Logger logger = context.getLogger(event.getLoggerName()); if (logger.privateConfig.filter(event.getLevel(), event.getMarker(), event.getMessage(), event.getThrown())) { logger.privateConfig.logEvent(event); } } }
@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()); }
LogEvent event = tcpTestServer.getQueue().poll(3, TimeUnit.SECONDS); assertNotNull("No event retrieved", event); assertTrue("Incorrect event", event.getMessage().getFormattedMessage().equals("This is a test message")); assertTrue("Message not delivered via TCP", tcpTestServer.getCount() > 0); assertEquals(expectedUuidStr, event.getContextData().getValue(tcKey)); event = tcpTestServer.getQueue().poll(3, TimeUnit.SECONDS); assertNotNull("No event retrieved", event); assertTrue("Incorrect event", event.getMessage().getFormattedMessage().equals("Throwing an exception")); assertTrue("Message not delivered via TCP", tcpTestServer.getCount() > 1); assertEquals(expectedUuidStr, event.getContextStack().pop()); assertNotNull(event.getThrownProxy()); assertEquals(expectedExMsg, event.getThrownProxy().getMessage());
@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()); } }
@Override public LogEntry transform(LogEvent event) { // create a new log entry LogEntry logEntry = new LogEntry(); logEntry.setLevel(event.getLevel().toString()); logEntry.setMessage(createMessage(event)); logEntry.setTimestamp(event.getTimeMillis()); return logEntry; }
@Override public void append(LogEvent event) { if (event.getLevel().equals(Level.WARN) && isExpectedThread()) { boolean skipPrinting = false; for (String knownWarn : TOLERABLE_WARNINGS) { if (event.getMessage().toString().indexOf(knownWarn) >= 0) skipPrinting = true; } if (!skipPrinting) { unknownWarning = event.getMessage().toString(); } } } }
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); } } }