@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 void format(final LogEvent event, final StringBuilder toAppendTo) { toAppendTo.append(event.getMessage().getFormat()); } }
static Stack transform(final List<LogEvent> logEvents) { final List<String> filtered = new ArrayList<>(logEvents.size()); for (LogEvent event : logEvents) { filtered.add(event.getMessage().getFormattedMessage()); } Collections.reverse(filtered); Stack<String> result = new Stack<>(); result.addAll(filtered); return result; }
@Override public String toSerializable(final LogEvent event) { return event.getMessage().getFormattedMessage() + Strings.LINE_SEPARATOR; }
@Override public void format(final LogEvent event, final StringBuilder toAppendTo) { toAppendTo.append('['); Object[] parameters = event.getMessage().getParameters(); if (parameters != null) { for (int i = 0; i < parameters.length; i++) { StringBuilders.appendValue(toAppendTo, parameters[i]); if (i != parameters.length - 1) { toAppendTo.append(','); } } } toAppendTo.append(']'); } }
@Override public void append(final LogEvent event) { // for scenarios where domain objects log from their toString method in the background thread event.getMessage().getFormattedMessage(); // may be a reusable event, make a copy, don't keep a reference to the original event logEvents.add(Log4jLogEvent.createMemento(event)); if (countDownLatch == null) { return; } // block until the test class tells us to continue try { countDownLatch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } }
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 updateTest() { final MapRewritePolicy updatePolicy = MapRewritePolicy.createPolicy("Update", rewrite); LogEvent rewritten = updatePolicy.rewrite(logEvent0); compareLogEvents(logEvent0, rewritten); assertEquals("Simple log message changed", logEvent0.getMessage(), rewritten.getMessage()); rewritten = updatePolicy.rewrite(logEvent1); compareLogEvents(logEvent1, rewritten); checkUpdated(((StringMapMessage)rewritten.getMessage()).getData()); rewritten = updatePolicy.rewrite(logEvent2); compareLogEvents(logEvent2, rewritten); checkUpdated(((StructuredDataMessage)rewritten.getMessage()).getData()); rewritten = updatePolicy.rewrite(logEvent3); compareLogEvents(logEvent3, rewritten); checkUpdated(((StringMapMessage)rewritten.getMessage()).getData()); }
@Test public void addTest() { final MapRewritePolicy addPolicy = MapRewritePolicy.createPolicy("Add", rewrite); LogEvent rewritten = addPolicy.rewrite(logEvent0); compareLogEvents(logEvent0, rewritten); assertEquals("Simple log message changed", logEvent0.getMessage(), rewritten.getMessage()); rewritten = addPolicy.rewrite(logEvent1); compareLogEvents(logEvent1, rewritten); checkAdded(((StringMapMessage)rewritten.getMessage()).getData()); rewritten = addPolicy.rewrite(logEvent2); compareLogEvents(logEvent2, rewritten); checkAdded(((StructuredDataMessage)rewritten.getMessage()).getData()); rewritten = addPolicy.rewrite(logEvent3); compareLogEvents(logEvent3, rewritten); checkAdded(((StringMapMessage)rewritten.getMessage()).getData()); }
@Test public void defaultIsAdd() { final MapRewritePolicy addPolicy = MapRewritePolicy.createPolicy(null, rewrite); LogEvent rewritten = addPolicy.rewrite(logEvent0); compareLogEvents(logEvent0, rewritten); assertEquals("Simple log message changed", logEvent0.getMessage(), rewritten.getMessage()); rewritten = addPolicy.rewrite(logEvent1); compareLogEvents(logEvent1, rewritten); checkAdded(((StringMapMessage)rewritten.getMessage()).getData()); rewritten = addPolicy.rewrite(logEvent2); compareLogEvents(logEvent2, rewritten); checkAdded(((StructuredDataMessage)rewritten.getMessage()).getData()); rewritten = addPolicy.rewrite(logEvent3); compareLogEvents(logEvent3, rewritten); checkAdded(((StringMapMessage)rewritten.getMessage()).getData()); }
@Test public void getLogger_String_MessageFactoryMismatchNull() { final Logger testLogger = testMessageFactoryMismatch(testName.getMethodName(), StringFormatterMessageFactory.INSTANCE, null); testLogger.debug("%,d", Integer.MAX_VALUE); final List<LogEvent> events = app.getEvents(); assertEventCount(events, 1); assertEquals(String.format("%,d", Integer.MAX_VALUE), events.get(0).getMessage().getFormattedMessage()); }
@Test public void getLogger_String_MessageFactoryMismatch() { final Logger testLogger = testMessageFactoryMismatch(testName.getMethodName(), StringFormatterMessageFactory.INSTANCE, ParameterizedMessageFactory.INSTANCE); testLogger.debug("%,d", Integer.MAX_VALUE); final List<LogEvent> events = app.getEvents(); assertEventCount(events, 1); assertEquals(String.format("%,d", Integer.MAX_VALUE), events.get(0).getMessage().getFormattedMessage()); }
@Test public void rewriteTest() { final StructuredDataMessage msg = new StructuredDataMessage("Test", "This is a test", "Service"); msg.put("Key1", "Value1"); msg.put("Key2", "Value2"); EventLogger.logEvent(msg); final List<LogEvent> list = app.getEvents(); assertNotNull("No events generated", list); assertTrue("Incorrect number of events. Expected 1, got " + list.size(), list.size() == 1); final LogEvent event = list.get(0); final Message m = event.getMessage(); assertTrue("Message is not a StringMapMessage: " + m.getClass(), m instanceof StructuredDataMessage); final StructuredDataMessage message = (StructuredDataMessage) m; final Map<String, String> map = message.getData(); assertNotNull("No Map", map); assertTrue("Incorrect number of map entries, expected 3 got " + map.size(), map.size() == 3); final String value = map.get("Key1"); assertEquals("Apache", value); }
@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()); } }
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")); } }
@Test public void testToImmutableNotSame() { final LogEvent logEvent = new Log4jLogEvent.Builder().setMessage(new ReusableObjectMessage()).build(); final LogEvent immutable = logEvent.toImmutable(); Assert.assertSame(logEvent, immutable); Assert.assertFalse(immutable.getMessage() instanceof ReusableMessage); }
@Test public void testAppendWithSerializedLayout() throws Exception { final Appender appender = ctx.getRequiredAppender("KafkaAppenderWithSerializedLayout"); final LogEvent logEvent = createLogEvent(); appender.append(logEvent); final List<ProducerRecord<byte[], byte[]>> history = kafka.history(); assertEquals(1, history.size()); final ProducerRecord<byte[], byte[]> item = history.get(0); assertNotNull(item); assertEquals(TOPIC_NAME, item.topic()); assertNull(item.key()); assertEquals(LOG_MESSAGE, deserializeLogEvent(item.value()).getMessage().getFormattedMessage()); }
@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()); }
@Test public void testCreateMementoRetainsParametersAndFormat() { final RingBufferLogEvent evt = new RingBufferLogEvent(); // Initialize the event with parameters evt.swapParameters(new Object[10]); final String loggerName = "logger.name"; final Marker marker = MarkerManager.getMarker("marked man"); final String fqcn = "f.q.c.n"; final Level level = Level.TRACE; ReusableMessageFactory factory = new ReusableMessageFactory(); Message message = factory.newMessage("Hello {}!", "World"); try { final Throwable t = new InternalError("not a real error"); final ContextStack contextStack = new MutableThreadContextStack(Arrays.asList("a", "b")); final String threadName = "main"; final StackTraceElement location = null; evt.setValues(null, loggerName, marker, fqcn, level, message, t, (StringMap) evt.getContextData(), contextStack, -1, threadName, -1, location, new FixedPreciseClock(12345, 678), new DummyNanoClock(1)); ((StringMap) evt.getContextData()).putValue("key", "value"); final Message actual = evt.createMemento().getMessage(); assertEquals("Hello {}!", actual.getFormat()); assertArrayEquals(new String[]{"World"}, actual.getParameters()); assertEquals("Hello World!", actual.getFormattedMessage()); } finally { ReusableMessageFactory.release(message); } }
@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); }