/** Is this <code>event</code> the e-mail triggering event? <p>This method returns <code>true</code>, if the event level has ERROR level or higher. Otherwise it returns <code>false</code>. */ public boolean isTriggeringEvent(LoggingEvent event) { return event.getLevel().isGreaterOrEqual(Level.ERROR); } }
/** * {@inheritDoc} */ public void format(final LoggingEvent event, final StringBuffer output) { output.append(event.getLevel().toString()); }
/** Returns the log statement in a format consisting of the <code>level</code>, followed by " - " and then the <code>message</code>. For example, <pre> INFO - "A message" </pre> <p>The <code>category</code> parameter is ignored. <p> @return A byte array in SimpleLayout format. */ public String format(LoggingEvent event) { sbuf.setLength(0); sbuf.append(event.getLevel().toString()); sbuf.append(" - "); sbuf.append(event.getRenderedMessage()); sbuf.append(LINE_SEP); return sbuf.toString(); }
if(this.levelToMatch.equals(event.getLevel())) { matchOccured = true;
/** * Create event with summary information. * * @return new event. */ public LoggingEvent createEvent() { String msg = MessageFormat.format( "Discarded {0} messages due to full event buffer including: {1}", new Object[] { new Integer(count), maxEvent.getMessage() }); return new LoggingEvent( "org.apache.log4j.AsyncAppender.DONT_REPORT_LOCATION", Logger.getLogger(maxEvent.getLoggerName()), maxEvent.getLevel(), msg, null); } }
/** Return the decision of this filter. */ public int decide(LoggingEvent event) { if(this.levelMin != null) { if (event.getLevel().isGreaterOrEqual(levelMin) == false) { // level of event is less than minimum return Filter.DENY; } } if(this.levelMax != null) { if (event.getLevel().toInt() > levelMax.toInt()) { // level of event is greater than maximum // Alas, there is no Level.isGreater method. and using // a combo of isGreaterOrEqual && !Equal seems worse than // checking the int values of the level objects.. return Filter.DENY; } } if (acceptOnMatch) { // this filter set up to bypass later filters and always return // accept if level in range return Filter.ACCEPT; } else { // event is ok for this filter; allow later filters to have a look.. return Filter.NEUTRAL; } }
buf.append("] "); buf.append(event.getLevel().toString()); buf.append(' ');
public void append(LoggingEvent event) { StringBuffer sbuf = new StringBuffer(); sbuf.append(layout.format(event)); if(layout.ignoresThrowable()) { String[] s = event.getThrowableStrRep(); if (s != null) { int len = s.length; for(int i = 0; i < len; i++) { sbuf.append(s[i]); } } } // Normalize the log message level into the supported categories int nt_category = event.getLevel().toInt(); // Anything above FATAL or below DEBUG is labeled as INFO. //if (nt_category > FATAL || nt_category < DEBUG) { // nt_category = INFO; //} reportEvent(_handle, sbuf.toString(), nt_category); }
/** * {@inheritDoc} */ public LoggingEvent rewrite(final LoggingEvent source) { if (!properties.isEmpty()) { Map rewriteProps = new HashMap(source.getProperties()); for(Iterator iter = properties.entrySet().iterator(); iter.hasNext(); ) { Map.Entry entry = (Map.Entry) iter.next(); if (!rewriteProps.containsKey(entry.getKey())) { rewriteProps.put(entry.getKey(), entry.getValue()); } } return new LoggingEvent( source.getFQNOfLoggerClass(), source.getLogger() != null ? source.getLogger(): Logger.getLogger(source.getLoggerName()), source.getTimeStamp(), source.getLevel(), source.getMessage(), source.getThreadName(), source.getThrowableInformation(), source.getNDC(), source.getLocationInformation(), rewriteProps); } return source; }
public String convert(LoggingEvent event) { switch(type) { case RELATIVE_TIME_CONVERTER: return (Long.toString(event.timeStamp - LoggingEvent.getStartTime())); case THREAD_CONVERTER: return event.getThreadName(); case LEVEL_CONVERTER: return event.getLevel().toString(); case NDC_CONVERTER: return event.getNDC(); case MESSAGE_CONVERTER: { return event.getRenderedMessage(); } default: return null; } } }
private void assertLogOccurred( Level level, String message ) { ArrayList<LoggingEvent> events = getLoggingEvents(); assertThat( events, hasSize( 1 ) ); LoggingEvent event = events.get( 0 ); assertThat( event.getLoggerName(), is( getClass().getName() ) ); assertThat( event.getLevel(), is( level ) ); assertThat( event.getMessage(), is( message ) ); }
@Override public String format(LoggingEvent event) { java.util.logging.Level level = convertLevel(event.getLevel()); LogRecord logRecord = new LogRecord(level, event.getMessage().toString()); logRecord.setLoggerName(event.getLoggerName()); logRecord.setMillis(event.getTimeStamp()); logRecord.setSourceClassName(event.getLoggerName()); logRecord.setSourceMethodName(event.getLocationInformation().getMethodName()); logRecord.setThreadID((int) Thread.currentThread().getId()); return logger.format(logRecord); }
/** * Append a log event at the appropriate JUL level, depending on the log4j level. */ @Override protected void append(LoggingEvent loggingEvent) { java.util.logging.Logger logger = java.util.logging.Logger.getLogger(loggingEvent.getLoggerName()); if (logger == null) { LogLog.warn(format("Cannot obtain JUL %s. Verify that this appender is used while an appropriate LogManager is active.", loggingEvent.getLoggerName())); return; } Level level = loggingEvent.getLevel(); java.util.logging.Level julLevel = convertLog4jLevel(level); LogRecord record = new LogRecord(julLevel, loggingEvent.getRenderedMessage()); record.setMillis(loggingEvent.getTimeStamp()); LocationInfo location = loggingEvent.getLocationInformation(); if (location != null) { record.setSourceClassName(location.getClassName()); record.setSourceMethodName(location.getMethodName()); } logger.log(record); }
private Log parseLog(LoggingEvent event) { Log log = new Log(); log.setLogName(event.getLogger().getName()); log.setLogLevel(event.getLevel()); log.setLogThread(event.getThreadName()); log.setLogMessage(event.getMessage().toString()); return log; }
private Log parseLog(LoggingEvent event) { Log log = new Log(); log.setLogName(event.getLogger().getName()); log.setLogLevel(event.getLevel()); log.setLogThread(event.getThreadName()); log.setLogMessage(event.getMessage().toString()); return log; }
/** * This method performs threshold checks and invokes filters before * delegating actual logging to the subclasses specific {@link * AppenderSkeleton#append} method. * */ public synchronized void doAppend(LoggingEvent event) { if(closed) { LogLog.error("Attempted to append to closed appender named ["+name+"]."); return; } if(!isAsSevereAsThreshold(event.getLevel())) { return; } Filter f = this.headFilter; FILTER_LOOP: while(f != null) { switch(f.decide(event)) { case Filter.DENY: return; case Filter.ACCEPT: break FILTER_LOOP; case Filter.NEUTRAL: f = f.getNext(); } } this.append(event); }
@Test public void testAddToFailedServersLogging() { Throwable nullException = new NullPointerException(); FailedServers fs = new FailedServers(new Configuration()); addr = new InetSocketAddress(TEST_PORT); fs.addToFailedServers(addr, nullException); Mockito.verify(mockAppender).doAppend((LoggingEvent) captorLoggingEvent.capture()); LoggingEvent loggingEvent = (LoggingEvent) captorLoggingEvent.getValue(); assertThat(loggingEvent.getLevel(), is(Level.DEBUG)); assertEquals("Added failed server with address " + addr.toString() + " to list caused by " + nullException.toString(), loggingEvent.getRenderedMessage()); }
/** * Creates a new <code>EventDetails</code> instance. * * @param aEvent a <code>LoggingEvent</code> value */ EventDetails(LoggingEvent aEvent) { this(aEvent.timeStamp, aEvent.getLevel(), aEvent.getLoggerName(), aEvent.getNDC(), aEvent.getThreadName(), aEvent.getRenderedMessage(), aEvent.getThrowableStrRep(), (aEvent.getLocationInformation() == null) ? null : aEvent.getLocationInformation().fullInfo); }