final ThrowableProxy thrownProxy = event.getThrownProxy(); final String throwable; if (thrownProxy == null) {
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")); } }
assertTrue("Message not delivered via TCP", tcpTestServer.getCount() > 1); assertEquals(expectedUuidStr, event.getContextStack().pop()); assertNotNull(event.getThrownProxy()); assertEquals(expectedExMsg, event.getThrownProxy().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()); } }
assertEquals(evt.getInstant().getNanoOfMillisecond(), actual.getInstant().getNanoOfMillisecond()); assertEquals(evt.getSource(), actual.getSource()); assertEquals(evt.getThrownProxy(), actual.getThrownProxy());
/** * Gets the exception logged. Annotated with {@code @Convert(converter = ThrowableAttributeConverter.class)}. * * @return the exception logged. * @see ThrowableAttributeConverter */ @Override @Transient public ThrowableProxy getThrownProxy() { return this.getWrappedEvent().getThrownProxy(); }
private PatternSelector getSelector(LogEvent event) { if (event.getThrownProxy() != null || event.getThrown() != null) { return execptionSelector; } return markerSelector; } }
@Override public String[] getThrowableStrRep() { ThrowableProxy t = event.getThrownProxy(); return t != null ? t.getExtendedStackTraceAsString("").split("\n") : null; }
/** * Take a snapshot of the specified {@code LogEvent}. * * @param event the event to take a snapshot of * @param includeLocation if true, this method will obtain caller location information * @return snapshot of the event as a {@code Serializable} object * @see #deserialize(Serializable) * @see #serialize(Log4jLogEvent, boolean) */ public static Serializable serialize(final LogEvent event, final boolean includeLocation) { if (event instanceof Log4jLogEvent) { event.getThrownProxy(); // ensure ThrowableProxy is initialized return new LogEventProxy((Log4jLogEvent) event, includeLocation); } return new LogEventProxy(event, includeLocation); }
private String getJSONLogAsString(ObservableLogEventDeque events) { if (!events.isEmpty()) { LogEvent event = events.pollLast(); JsonObject json = new JsonObject(); json.addProperty("logLevel", event.getLevel().toString()); json.addProperty("message", event.getMessage().getFormattedMessage()); String exception = null; if (event.getThrownProxy() != null) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); event.getThrownProxy().getThrowable().printStackTrace(pw); pw.close(); exception = sw.toString(); } json.addProperty("exception", exception); json.addProperty("time", event.getTimeMillis()); return json.toString(); } return ""; }
final ThrowableProxy proxy = event.getThrownProxy(); final Throwable throwable = event.getThrown(); if (throwable != null && options.anyLines()) {
final ThrowableProxy proxy = event.getThrownProxy(); final Throwable throwable = event.getThrown(); if ((throwable != null || proxy != null) && options.anyLines()) {
final ThrowableProxy thrownProxy = event.getThrownProxy(); final String throwable; if (thrownProxy == null) {
json.put("message", event.getMessage().getFormattedMessage()); if (event.getThrownProxy() != null) { if (getExtendedStackTraceAsStringAvailable) { json.put("stacktrace", event.getThrownProxy().getExtendedStackTraceAsString()); } else if (event.getThrown() != null) { try (StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw)) {
result.setThrowable(convert(log4jEvent.getThrownProxy()));
public LogEventProxy(final LogEvent event, final boolean includeLocation) { this.loggerFQCN = event.getLoggerFqcn(); this.marker = event.getMarker(); this.level = event.getLevel(); this.loggerName = event.getLoggerName(); final Message temp = event.getMessage(); message = temp instanceof ReusableMessage ? memento((ReusableMessage) temp) : temp; this.timeMillis = event.getTimeMillis(); this.thrown = event.getThrown(); this.thrownProxy = event.getThrownProxy(); this.contextData = memento(event.getContextData()); this.contextStack = event.getContextStack(); this.source = includeLocation ? event.getSource() : null; this.threadId = event.getThreadId(); this.threadName = event.getThreadName(); this.threadPriority = event.getThreadPriority(); this.isLocationRequired = includeLocation; this.isEndOfBatch = event.isEndOfBatch(); this.nanoTime = event.getNanoTime(); }
@Override public String toSerializable(final LogEvent event) { final StringBuilder buffer = getStringBuilder(); final CSVFormat format = getFormat(); try { format.print(event.getNanoTime(), buffer, true); format.print(event.getTimeMillis(), buffer, false); format.print(event.getLevel(), buffer, false); format.print(event.getThreadId(), buffer, false); format.print(event.getThreadName(), buffer, false); format.print(event.getThreadPriority(), buffer, false); format.print(event.getMessage().getFormattedMessage(), buffer, false); format.print(event.getLoggerFqcn(), buffer, false); format.print(event.getLoggerName(), buffer, false); format.print(event.getMarker(), buffer, false); format.print(event.getThrownProxy(), buffer, false); format.print(event.getSource(), buffer, false); format.print(event.getContextData(), buffer, false); format.print(event.getContextStack(), buffer, false); format.println(buffer); return buffer.toString(); } catch (final IOException e) { StatusLogger.getLogger().error(event.toString(), e); return format.getCommentMarker() + " " + e; } }
this.thrownProxy = other.getThrownProxy(); this.source = other.getSource(); this.threadId = other.getThreadId();
this.timeMillis = event.getTimeMillis(); this.thrown = event.getThrown(); this.thrownProxy = event.getThrownProxy();