new DateTime(event.getTimeMillis(), DateTimeZone.UTC), throwable, event.getThreadName(), event.getContextData().toMap() ));
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); } }
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")); } }
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("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]);
@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(1234567890L, e2.getNanoTime()); assertSame(threadName, e2.getThreadName()); assertSame(exception, e2.getThrown()); assertEquals(987654321L, e2.getTimeMillis());
assertEquals(evt.getContextData(), actual.getContextData()); assertEquals(evt.getContextStack(), actual.getContextStack()); assertEquals(evt.getThreadName(), actual.getThreadName()); assertEquals(evt.getTimeMillis(), actual.getTimeMillis()); assertEquals(evt.getInstant().getNanoOfMillisecond(), actual.getInstant().getNanoOfMillisecond());
@Override public String getThreadName() { return event.getThreadName(); }
/** * {@inheritDoc} */ @Override public void format(final LogEvent event, final StringBuilder toAppendTo) { toAppendTo.append(event.getThreadName()); } }
assertEquals(1234567890L, event2.getNanoTime()); assertSame(stackTraceElement, event2.getSource()); assertSame(threadName, event2.getThreadName()); assertSame(exception, event2.getThrown()); assertEquals(987654321L, event2.getTimeMillis());
public String lookup(LogEvent event, String key) { String testName = cache.computeIfAbsent(event.getThreadName(), threadName -> { Matcher matcher = pattern.matcher(event.getThreadName()); return matcher.find() ? matcher.group(1) : null; }); return testName; } }
@Override public void append(LogEvent event) { if (webCLIThread.equals(event.getThreadName())) { logEvents.add(event); } }
private void populateLazilyInitializedFields(final LogEvent event) { event.getSource(); event.getThreadName(); }
@Override public Result filter(final LogEvent event) { return filter(event.getLevel(), event.getThreadName()); }
/** * Gets the thread name. Annotated with {@code @Basic}. * * @return the thread name. */ @Override @Basic public String getThreadName() { return this.getWrappedEvent().getThreadName(); }
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() ); }
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(); }
@Override public void append(final LogEvent event) { LogStatement statement = new LogStatement(); statement.setLevel(LoggerLevel.fromLevel(event.getLevel())); statement.setLoggerName(event.getLoggerName()); Message msg = event.getMessage(); statement.setMessage((msg instanceof ReusableMessage ? ((ReusableMessage) msg).memento() : msg).getFormattedMessage()); statement.setTimeMillis(event.getTimeMillis()); if (event.getThrown() != null) { statement.setStackTrace(ExceptionUtils2.getFullStackTrace(event.getThrown())); } statement.setThreadId(event.getThreadId()); statement.setThreadName(event.getThreadName()); statement.setThreadPriority(event.getThreadPriority()); this.statements.add(statement); }