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 void format(LogEvent event, StringBuilder buffer) { if (event.getThrown() != null) { buffer.append(this.options.getSeparator()); this.delegate.format(event, buffer); buffer.append(this.options.getSeparator()); } }
@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 format(LogEvent event, StringBuilder buffer) { if (event.getThrown() != null) { buffer.append(this.options.getSeparator()); super.format(event, buffer); buffer.append(this.options.getSeparator()); } }
@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); }
/** * {@inheritDoc} */ @Override public void append(final LogEvent event) { final Throwable throwable = event.getThrown(); final String message = getLayout().toSerializable(event).toString(); LoggingHandler.addErrorLogToCounter(message, throwable); } }
assertEquals(evt.getLevel(), actual.getLevel()); assertEquals(evt.getMessage(), actual.getMessage()); assertEquals(evt.getThrown(), actual.getThrown()); assertEquals(evt.getContextMap(), actual.getContextMap()); assertEquals(evt.getContextData(), actual.getContextData());
@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()); } }
@Override public void append(final LogEvent event) { final String serialized = ((AbstractStringLayout) getLayout()).toSerializable(event); if (logThrowables) { servletContext.log(serialized, event.getThrown()); } else { servletContext.log(serialized); } }
assertSame(exception, e2.getThrown()); assertEquals(987654321L, e2.getTimeMillis());
@Override public Throwable getThrowable() { return logEvent.getThrown(); }
@Override public Throwable getThrowable() { return logEvent.getThrown(); }
assertSame(stackTraceElement, event2.getSource()); assertSame(threadName, event2.getThreadName()); assertSame(exception, event2.getThrown()); assertEquals(987654321L, event2.getTimeMillis());
@Override public Exception getException() { Exception exception = null; if (isException()) { Throwable throwable = this.logEvent.getThrown(); exception = throwable instanceof Exception ? (Exception) throwable : new Exception(throwable); } return exception; }
private void createStackTraceEvent(final JSONObject logstashEvent, final LogEvent loggingEvent) { if (loggingEvent.getThrown().getStackTrace() != null) { final String[] options = { "full" }; final ThrowablePatternConverter converter = ThrowablePatternConverter.newInstance(options); final StringBuilder sb = new StringBuilder(); converter.format(loggingEvent, sb); final String stackTrace = sb.toString(); logstashEvent.put(LayoutFields.STACK_TRACE, stackTrace); } } }
@Override protected boolean matchesSafely(LogEvent event) { return exceptionMatcher.matches(event.getThrown()); }
@Override public void append(LogEvent event) { final LevelTag level = LevelTag.get(event.getLevel()); registry.counter(numMessages[level.ordinal()]).increment(); if (!ignoreExceptions() && event.getThrown() != null) { final String file = (event.getSource() == null) ? "unknown" : event.getSource().getFileName(); Id stackTraceId = numStackTraces[level.ordinal()] .withTag("exception", event.getThrown().getClass().getSimpleName()) .withTag("file", file); registry.counter(stackTraceId).increment(); } } }
@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() ); }