void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException { stmt.setLong(TIMESTMP_INDEX, event.getTimeStamp()); stmt.setString(FORMATTED_MESSAGE_INDEX, event.getFormattedMessage()); stmt.setString(LOGGER_NAME_INDEX, event.getLoggerName()); stmt.setString(LEVEL_STRING_INDEX, event.getLevel().toString()); stmt.setString(THREAD_NAME_INDEX, event.getThreadName()); stmt.setShort(REFERENCE_FLAG_INDEX, DBHelper.computeReferenceMask(event)); }
public static LoggingEventVO build(ILoggingEvent le) { LoggingEventVO ledo = new LoggingEventVO(); ledo.loggerName = le.getLoggerName(); ledo.loggerContextVO = le.getLoggerContextVO(); ledo.threadName = le.getThreadName(); ledo.level = (le.getLevel()); ledo.message = (le.getMessage()); ledo.argumentArray = (le.getArgumentArray()); ledo.marker = le.getMarker(); ledo.mdcPropertyMap = le.getMDCPropertyMap(); ledo.timeStamp = le.getTimeStamp(); ledo.throwableProxy = ThrowableProxyVO.build(le.getThrowableProxy()); // add caller data only if it is there already // fixes http://jira.qos.ch/browse/LBCLASSIC-145 if (le.hasCallerData()) { ledo.callerDataArray = le.getCallerData(); } return ledo; }
protected void preprocess(ILoggingEvent eventObject) { eventObject.prepareForDeferredProcessing(); if (includeCallerData) eventObject.getCallerData(); }
values[i++] = loggingEvent.getMessage(); values[i++] = loggingEvent.getFormattedMessage(); values[i++] = loggingEvent.getLoggerName(); values[i++] = loggingEvent.getLoggerContextVO(); values[i++] = loggingEvent.getLevel().toInteger(); values[i++] = loggingEvent.getTimeStamp(); values[i++] = loggingEvent.getMarker(); values[i++] = loggingEvent.getMDCPropertyMap(); IThrowableProxy iThrowableProxy = loggingEvent.getThrowableProxy();
buf.append(Transform.escapeTags(event.getLoggerName())); buf.append("\"\r\n"); buf.append(" timestamp=\""); buf.append(event.getTimeStamp()); buf.append("\" level=\""); buf.append(event.getLevel()); buf.append("\" thread=\""); buf.append(Transform.escapeTags(event.getThreadName())); buf.append("\">\r\n"); buf.append(Transform.escapeTags(event.getFormattedMessage())); buf.append("</log4j:message>\r\n"); IThrowableProxy tp = event.getThrowableProxy(); if (tp != null) { StackTraceElementProxy[] stepArray = tp.getStackTraceElementProxyArray(); StackTraceElement[] callerDataArray = event.getCallerData(); if (callerDataArray != null && callerDataArray.length > 0) { StackTraceElement immediateCallerData = callerDataArray[0]; Map<String, String> propertyMap = event.getMDCPropertyMap();
/** * TODO: For better testability, consider making setDefaultUncaughtExceptionHandler pluggable or Spring configurable as an autowired list */ @Test public void testConstruction() throws InterruptedException { ListAppender<ILoggingEvent> inMemoryAppender = new ListAppender<>(); inMemoryAppender.start(); Logger logger = (Logger) LoggerFactory.getLogger("general"); try { logger.setLevel(Level.DEBUG); logger.addAppender(inMemoryAppender); // Registers the safety net new DefaultConfig(); // Trigger an exception in the background Executors.newSingleThreadExecutor().execute(new ExceptionThrower()); Thread.sleep(600); ILoggingEvent firstException = inMemoryAppender.list.get(0); assertEquals("Uncaught exception", firstException.getMessage()); IThrowableProxy cause = firstException.getThrowableProxy(); assertEquals("Unit test throwing an exception", cause.getMessage()); } finally { inMemoryAppender.stop(); logger.detachAppender(inMemoryAppender); } }
hardenedLoggingEventInputStream = new HardenedLoggingEventInputStream(new BufferedInputStream(socket.getInputStream())); } catch (Exception e) { logger.error("Could not open ObjectInputStream to " + socket, e); closed = true; remoteLogger = context.getLogger(event.getLoggerName()); if (remoteLogger.isEnabledFor(event.getLevel())) { remoteLogger.callAppenders(event);
private LogEntry logEntryFor(ILoggingEvent e) { StringBuilder payload = new StringBuilder(e.getFormattedMessage()).append('\n'); writeStack(e.getThrowableProxy(), "", payload); Level level = e.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload.toString().trim())) .setTimestamp(e.getTimeStamp()) .setSeverity(severityFor(level)); builder .addLabel(LEVEL_NAME_KEY, level.toString()) .addLabel(LEVEL_VALUE_KEY, String.valueOf(level.toInt())); if (loggingEnhancers != null) { for (LoggingEnhancer enhancer : loggingEnhancers) { enhancer.enhanceLogEntry(builder); } } if (loggingEventEnhancers != null) { for (LoggingEventEnhancer enhancer : loggingEventEnhancers) { enhancer.enhanceLogEntry(builder, e); } } return builder.build(); }
@Test public void testWithEnabledLevel() throws Exception { logger.setLevel(Level.DEBUG); client.run(); client.close(); ILoggingEvent rcvdEvent = appender.getLastEvent(); assertEquals(event.getLoggerName(), rcvdEvent.getLoggerName()); assertEquals(event.getLevel(), rcvdEvent.getLevel()); assertEquals(event.getMessage(), rcvdEvent.getMessage()); }
@Override protected Map<String, Object> toJsonMap(ILoggingEvent event) { final MapBuilder mapBuilder = new MapBuilder(timestampFormatter, customFieldNames, additionalFields, includes.size()) .addTimestamp("timestamp", isIncluded(EventAttribute.TIMESTAMP), event.getTimeStamp()) .add("level", isIncluded(EventAttribute.LEVEL), () -> String.valueOf(event.getLevel())) .add("thread", isIncluded(EventAttribute.THREAD_NAME), event::getThreadName) .add("logger", isIncluded(EventAttribute.LOGGER_NAME), event::getLoggerName) .add("message", isIncluded(EventAttribute.MESSAGE), event::getFormattedMessage) .add("context", isIncluded(EventAttribute.CONTEXT_NAME), () -> event.getLoggerContextVO().getName()) .add("version", jsonProtocolVersion != null, jsonProtocolVersion) .add("exception", isIncluded(EventAttribute.EXCEPTION) && event.getThrowableProxy() != null, () -> throwableProxyConverter.convert(event)); final boolean includeMdc = isIncluded(EventAttribute.MDC); if (flattenMdc) { filterMdc(event.getMDCPropertyMap()).forEach((k,v) -> mapBuilder.add(k, includeMdc, v)); } else { mapBuilder.addMap("mdc", includeMdc, () -> filterMdc(event.getMDCPropertyMap())); } final boolean includeCallerData = isIncluded(EventAttribute.CALLER_DATA); final StackTraceElement[] callerData = event.getCallerData(); if (includeCallerData && callerData.length >= 1) { final StackTraceElement stackTraceElement = callerData[0]; mapBuilder.add("caller_class_name", includeCallerData, stackTraceElement.getClassName()); mapBuilder.add("caller_method_name", includeCallerData, stackTraceElement.getMethodName()); mapBuilder.add("caller_file_name", includeCallerData, stackTraceElement.getFileName()); mapBuilder.addNumber("caller_line_number", includeCallerData, stackTraceElement.getLineNumber()); } return mapBuilder.build(); }
@Override protected void append(ILoggingEvent event) { if (event.getThrowableProxy() == null) { target.log(event.getFormattedMessage(), translate(event.getLevel())); } else { ExtendedThrowableProxyConverter throwableConverter = new ExtendedThrowableProxyConverter(); throwableConverter.start(); target.log(event.getFormattedMessage() + "\n" + throwableConverter.convert(event), translate(event.getLevel())); throwableConverter.stop(); } }
@Test public void testBulkNoRequest() { elasticsearchClient.sendBulk(os -> os.write(("").getBytes("UTF-8"))); assertThat(testAppender.list).hasSize(1); final ILoggingEvent event = testAppender.list.get(0); assertThat(event.getLevel().toString()).isEqualTo("WARN"); assertThat(event.getMessage()).startsWith("Error(s) while sending a _bulk request to elasticsearch: {}"); }
private void checkForEquality(ILoggingEvent original, ILoggingEvent afterSerialization) { assertEquals(original.getLevel(), afterSerialization.getLevel()); assertEquals(original.getFormattedMessage(), afterSerialization .getFormattedMessage()); assertEquals(original.getMessage(), afterSerialization.getMessage()); System.out.println(); ThrowableProxyVO witness = ThrowableProxyVO.build(original .getThrowableProxy()); assertEquals(witness, afterSerialization.getThrowableProxy()); }
public String doLayout(ILoggingEvent event) { StringBuilder buf = new StringBuilder(); startNewTableIfLimitReached(buf); boolean odd = true; if (((counter++) & 1) == 0) { odd = false; } String level = event.getLevel().toString().toLowerCase(); buf.append(LINE_SEPARATOR); buf.append("<tr class=\""); buf.append(level); if (odd) { buf.append(" odd\">"); } else { buf.append(" even\">"); } buf.append(LINE_SEPARATOR); Converter<ILoggingEvent> c = head; while (c != null) { appendEventToBuffer(buf, c, event); c = c.getNext(); } buf.append("</tr>"); buf.append(LINE_SEPARATOR); if (event.getThrowableProxy() != null) { throwableRenderer.render(buf, event); } return buf.toString(); }
@Override public synchronized FilterReply decide(ILoggingEvent event) { return visibleLoggers.contains(event.getLoggerName()) && event.getLevel().isGreaterOrEqual(Level.INFO) || event.getLevel().isGreaterOrEqual(Level.ERROR) ? FilterReply.NEUTRAL : FilterReply.DENY; }
private void dispatchEvents(LoggerContext lc) { ObjectInputStream ois = null; try { socket.setSoTimeout(acceptConnectionTimeout); ois = new HardenedLoggingEventInputStream(socket.getInputStream()); socket.setSoTimeout(0); addInfo(receiverId + "connection established"); while (true) { ILoggingEvent event = (ILoggingEvent) ois.readObject(); Logger remoteLogger = lc.getLogger(event.getLoggerName()); if (remoteLogger.isEnabledFor(event.getLevel())) { remoteLogger.callAppenders(event); } } } catch (EOFException ex) { addInfo(receiverId + "end-of-stream detected"); } catch (IOException ex) { addInfo(receiverId + "connection failed: " + ex); } catch (ClassNotFoundException ex) { addInfo(receiverId + "unknown event class: " + ex); } finally { CloseUtil.closeQuietly(ois); CloseUtil.closeQuietly(socket); socket = null; addInfo(receiverId + "connection closed"); } }
@Override public FilterReply decide(ILoggingEvent event) { if (!isStarted()) { return FilterReply.NEUTRAL; } if (event.getLevel().isGreaterOrEqual(level)) { return FilterReply.NEUTRAL; } else { return FilterReply.DENY; } }
private ILoggingEvent log(List<ILoggingEvent> events) { final Integer value = ThreadLocalRandom.current().nextInt(); testLogger.trace("{}", value); assertThat(events).hasSize(1); final ILoggingEvent event = events.remove(0); assertThat(event.getLevel()).isEqualTo(Level.TRACE); assertThat(event.getFormattedMessage()).isEqualTo(value.toString()); assertThat(event.getArgumentArray()).containsExactly(value); return event; }
public synchronized boolean contains(Level level, String message) { for (ILoggingEvent event : appender.getRawEvents()) { if (event.getLevel().equals(level) && event.getFormattedMessage().contains(message)) { return true; } } return false; }