org.apache.log4j.AppenderSkeleton#org.apache.log4j.spi.LoggingEvent源码实例Demo

/**
 * 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);
}
 

@Override
public void l7dlog(Priority priority, String key, Object[] params, Throwable t) {
    if (isForcedToLog(priority)) {
        // from super.l7dlog:
        String pattern = getResourceBundleString(key);
        String msg;
        if (pattern == null)
            msg = key;
        else
            msg = java.text.MessageFormat.format(pattern, params);

        final Appender forcedAppender = getForcedAppender();

        // force the logging and modify the log message (the latter might return the original message)
        if (forcedAppender != null) {
            // only call the forced appender
            forcedAppender.doAppend(new LoggingEvent(FQCN, this, priority, modifyLogMessage(msg), t));
        } else {
            // go via the normal appenders
            forcedLog(FQCN, priority, modifyLogMessage(msg), t);
        }

    } else {
        super.l7dlog(priority, key, params, t);
    }
}
 

@Test
public void testRewrite() throws Exception {
    Logger logger = LogManager.getLogger("test");
    ThreadContext.put("key1", "This is a test");
    ThreadContext.put("hello", "world");
    logger.debug("Say hello");
    LoggerContext context = (LoggerContext) org.apache.logging.log4j.LogManager.getContext(false);
    Configuration configuration = context.getConfiguration();
    Map<String, Appender> appenders = configuration.getAppenders();
    ListAppender eventAppender = null;
    for (Map.Entry<String, Appender> entry : appenders.entrySet()) {
        if (entry.getKey().equals("events")) {
            eventAppender = (ListAppender) ((AppenderAdapter.Adapter) entry.getValue()).getAppender();
        }
    }
    assertNotNull("No Event Appender", eventAppender);
    List<LoggingEvent> events = eventAppender.getEvents();
    assertTrue("No events", events != null && events.size() > 0);
    assertNotNull("No properties in the event", events.get(0).getProperties());
    assertTrue("Key was not inserted", events.get(0).getProperties().containsKey("key2"));
    assertEquals("Key value is incorrect", "Log4j", events.get(0).getProperties().get("key2"));
}
 

public static void main(String[] args) {
   DailyMaxRollingFileAppender dmrfa = new DailyMaxRollingFileAppender();
   dmrfa.setDatePattern("'.'yyyy-MM-dd-HH-mm");
   dmrfa.setFile("prova");
   System.out.println("dmrfa.getMaxBackupIndex():" + dmrfa.getMaxBackupIndex());
   dmrfa.activateOptions();

   for(int i = 0; i < 5; ++i) {
      dmrfa.subAppend((LoggingEvent)null);

      try {
         Thread.sleep(60000L);
      } catch (InterruptedException var3) {
         ;
      }

      System.out.println("Fine attesa");
   }

}
 

@Before
public void setUp() {
  when(builder.withTimeMs(anyLong())).thenReturn(builder);
  when(builder.withLoggerName(anyString())).thenReturn(builder);
  when(builder.withLevel(anyString())).thenReturn(builder);
  when(builder.withMessageJson(anyString())).thenReturn(builder);
  when(builder.build()).thenReturn(SERIALIZED_MSG);
  loggingEvent = new LoggingEvent(
      "fcqn",
      new FakeCategory(LOGGER_NAME),
      LOG_TIME_MS,
      LOG_LEVEL,
      STRUCTURED_MSG,
      null
  );
  layout = new StructuredJsonLayout(() -> builder);
}
 

/**
 * Handles append time behavior for CompositeRollingAppender.  This checks
 * if a roll over either by date (checked first) or time (checked second)
 * is need and then appends to the file last.
*/
protected void subAppend(LoggingEvent event) {

	if (rollDate) {
		long n = System.currentTimeMillis();
		if (n >= nextCheck) {
			now.setTime(n);
			nextCheck = rc.getNextCheckMillis(now);

			rollOverTime();
		}
	}

	if (rollSize) {
		if ((fileName != null) && ((CountingQuietWriter) qw).getCount() >= maxFileSize) {
		    rollOverSize();
		}
	}

	super.subAppend(event);
}
 

private String getThrowableStr(LoggingEvent event) {
  ThrowableInformation throwable = event.getThrowableInformation();
  if (throwable == null) {
    return null;
  }
  StringBuilder sb = new StringBuilder();
  boolean isFirst = true;
  for (String s : throwable.getThrowableStrRep()) {
    if (isFirst) {
      isFirst = false;
    } else {
      sb.append(System.getProperty("line.separator"));
    }
    sb.append(s);
  }
  return sb.toString();
}
 

@Test
public void testLifecycleEvent() throws Exception {
    when(mockLifeCycle.getState()).thenReturn(LifecycleState.STOPPING);
    lifeCycleListener.lifecycleEvent(new LifecycleEvent(mockLifeCycle, null, null));
    sleep(2500);

    when(mockLifeCycle.getState()).thenReturn(LifecycleState.STOPPED);
    lifeCycleListener.lifecycleEvent(new LifecycleEvent(mockLifeCycle, null, null));
    sleep(2500);

    verify(mockAppender, atLeastOnce()).doAppend((LoggingEvent) captorLoggingEvent.capture());

    final int eventTotal = captorLoggingEvent.getAllValues().size();
    final LoggingEvent loggingEvent = (LoggingEvent) captorLoggingEvent.getAllValues().get(eventTotal - 1);
    assertEquals("Channel closed", loggingEvent.getMessage());
    System.out.println(captorLoggingEvent.getAllValues().size());

    // make sure that the scheduler has stopped by checking if there are extra events after the listener has processed
    // a STOPPED life cycle
    sleep(2500); // pause to let any rogue scheduler do logging if there are any...
    assertEquals(eventTotal, captorLoggingEvent.getAllValues().size());
}
 

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);
  }
 

/**
    Returns {@link Filter#NEUTRAL} is there is no string match.
  */
 public
 int decide(LoggingEvent event) {
   String msg = event.getRenderedMessage();

   if(msg == null ||  stringToMatch == null)
     return Filter.NEUTRAL;
   

   if( msg.indexOf(stringToMatch) == -1 ) {
     return Filter.NEUTRAL;
   } else { // we've got a match
     if(acceptOnMatch) {
return Filter.ACCEPT;
     } else {
return Filter.DENY;
     }
   }
 }
 

/**
 * 覆写doAppend, 去掉closed的log日志
 * @param event
 */
@Override
public synchronized void doAppend(LoggingEvent event) {
    if (closed) {
        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);
}
 

@Override
protected void append(final LoggingEvent event) {
    final StringBuilder buffer = new StringBuilder();
    buffer.append(layout.format(event));
    if(layout.ignoresThrowable()) {
        final String[] trace = event.getThrowableStrRep();
        if(trace != null) {
            buffer.append(Layout.LINE_SEP);
            for(final String t : trace) {
                buffer.append(t).append(Layout.LINE_SEP);
            }
        }
    }
    console.printf("\r%s%s%s", Ansi.ansi()
                    .saveCursorPosition()
                    .eraseLine(Ansi.Erase.ALL)
                    .fg(Ansi.Color.MAGENTA)
                    .restoreCursorPosition(),
            buffer.toString(), Ansi.ansi().reset());
}
 

/**
 * This method is called by the {@link AppenderSkeleton#doAppend}
 * method.
 *
 * <p>If the output stream exists and is writable then write a log
 * statement to the output stream. Otherwise, write a single warning
 * message to <code>System.err</code>.
 *
 * <p>The format of the output will depend on this appender's
 * layout.
 */
public void append(LoggingEvent event) {

    // Reminder: the nesting of calls is:
    //
    //    doAppend()
    //      - check threshold
    //      - filter
    //      - append();
    //        - checkEntryConditions();
    //        - subAppend();

    if (!checkEntryConditions()) {
        return;
    }
    subAppend(event);
}
 

/**
 * Tests format.
 */
public void testFormat() {
  Logger logger = Logger.getLogger("org.apache.log4j.LayoutTest");
  LoggingEvent event =
    new LoggingEvent(
      "org.apache.log4j.Logger", logger, Level.INFO, "Hello, World", null);
  PatternLayout layout = (PatternLayout) createLayout();
  String result = layout.format(event);
  StringBuffer buf = new StringBuffer(100);
  buf.append('[');
  buf.append(event.getThreadName());
  buf.append("] ");
  buf.append(event.getLevel().toString());
  buf.append(' ');
  buf.append(event.getLoggerName());
  buf.append(" - ");
  buf.append(event.getMessage());
  buf.append(System.getProperty("line.separator"));
  assertEquals(buf.toString(), result);
}
 

@Override
protected void append(LoggingEvent event) {
	if (isDoLog(event.getLevel())) {
		String logString = layout.format(event);

		ILog myLog = getLog();
		if (myLog != null) {
			String loggerName = event.getLoggerName();
			int severity = mapLevel(event.getLevel());
			final Throwable throwable = event.getThrowableInformation() != null ? event.getThrowableInformation()
					.getThrowable() : null;
			IStatus status = createStatus(severity, loggerName, logString, throwable);
			getLog().log(status);
		} else {
			// nothing to do (message should be logged to stdout by default appender)
		}
	}
}
 

@Override
public void append(LoggingEvent event) {
  Level level = event.getLevel();
  String levelStr = level.toString();

  if (level == Level.INFO || "INFO".equalsIgnoreCase(levelStr)) {
    counts.incr(INFO);
  } else if (level == Level.WARN || "WARN".equalsIgnoreCase(levelStr)) {
    counts.incr(WARN);
  } else if (level == Level.ERROR || "ERROR".equalsIgnoreCase(levelStr)) {
    counts.incr(ERROR);
  } else if (level == Level.FATAL || "FATAL".equalsIgnoreCase(levelStr)) {
    counts.incr(FATAL);
  }
}
 

@Test
public void testRegionserverNoRegions() throws Exception {
  runRegionserverCanary();
  verify(mockAppender).doAppend(argThat(new ArgumentMatcher<LoggingEvent>() {
    @Override
    public boolean matches(LoggingEvent argument) {
      return argument.getRenderedMessage().contains("Regionserver not serving any regions");
    }
  }));
}
 

/**
 * Add discarded event to summary.
 *
 * @param event event, may not be null.
 */
public void add(final LoggingEvent event) {
  if (event.getLevel().toInt() > maxEvent.getLevel().toInt()) {
    maxEvent = event;
  }

  count++;
}
 

/**
 * Convert bytes to a {@link org.apache.log4j.spi.LoggingEvent}. This LoggingEvent uses logging
 * information of the {@link LoggingEventStringSerde}, which includes log
 * name, log category and log level.
 *
 * @param bytes bytes for decoding
 * @return LoggingEvent a new LoggingEvent
 */
@Override
public LoggingEvent fromBytes(byte[] bytes) {
  if (bytes == null) {
    return null;
  }
  String log;
  try {
    log = new String(bytes, ENCODING);
  } catch (UnsupportedEncodingException e) {
    throw new SamzaException("can not decode to String", e);
  }
  return new LoggingEvent(logger.getName(), logger, logger.getLevel(), log, null);
}
 

@Override
protected void append(final LoggingEvent event) {
  String _renderedMessage = event.getRenderedMessage();
  String _loggerName = event.getLoggerName();
  long _timeStamp = event.getTimeStamp();
  Level _level = event.getLevel();
  final LoggingTester.LogEntry entry = new LoggingTester.LogEntry(_renderedMessage, _loggerName, _timeStamp, _level);
  this.events.add(entry);
}
 

@Override
protected void append( LoggingEvent event ) {
  try {
    if( fetchLocationInfo ) {
      event.getLocationInformation();
    }
    queue.enqueue( event );
  } catch ( IOException e ) {
    throw new RuntimeException( e );
  }
}
 

/**
 * getRule with "level" and "info".
 */
@Test public void test3() {
    Stack<Object> stack = new Stack<>();
    stack.push("level");
    stack.push("info");
    Rule rule = NotEqualsRule.getRule(stack);
    AssertJUnit.assertEquals(0, stack.size());
    LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
            Logger.getRootLogger(), System.currentTimeMillis(), Level.WARN,
            "Hello, World", null);
    AssertJUnit.assertTrue(rule.evaluate(Log4jUtil.translateLog4j(event), null));
}
 

public
void actionPerformed(ActionEvent e) {
  counter++;
  LoggingEvent event = new LoggingEvent("x", dummy, Level.DEBUG, 
			  "Message "+counter, null);    
  appenderTable.doAppend(event);
}
 

@Override
protected void append (LoggingEvent e) {
	Level	l = e.getLevel ();
	int lvl = -1;

	if (l == Level.DEBUG) {
		lvl = DEBUG;
	} else if (l == Level.INFO) {
		lvl = INFO;
	} else if (l == Level.WARN) {
		lvl = WARNING;
	} else if (l == Level.ERROR) {
		lvl = ERROR;
	} else if (l == Level.FATAL) {
		lvl = FATAL;
	}
	if (lvl != -1) {
		String loggerName = e.getLoggerName ();
		boolean match = (loggerName == null) || (pattern == null) || (pattern.length == 0);

		if (! match) {
			for (int n = 0; n < pattern.length; ++n) {
				if (loggerName != null && loggerName.startsWith (pattern[n])) {
					match = true;
					break;
				}
			}
		}
		if (match) {
			log.out (lvl, id, e.getRenderedMessage ());
		}
	}
}
 

public int countExceptionsWithMessage(final String text) {
  int count = 0;
  for (LoggingEvent e: getLog()) {
    ThrowableInformation t = e.getThrowableInformation();
    if (t != null) {
      String m = t.getThrowable().getMessage();
      if (m.contains(text)) {
        count++;
      }
    }
  }
  return count;
}
 

/**
 * This method called by {@link AppenderSkeleton#doAppend}method does most of the real appending work. Adds the event to a buffer and checks if the event triggers a
 * message to be sent.
 */
@Override
public void append(final LoggingEvent event) {

    // check pre-conditions
    if (!checkEntryConditions()) {
        return;
    }

    cb.add(event);
    if (evaluator.isTriggeringEvent(event)) {
        sendBuffer();
    }
}
 

@Override
protected void append(LoggingEvent event) {
	events.add(event);
	obs.setChanged();
	try {
		obs.notifyObservers(event.getMessage());
	} catch (Exception e) {
		// do nothing
	}
}
 

@Override
public void append(LoggingEvent event) {
    if (event == null) return;
    String line = this.layout.format(event);
    if (line != null) this.lines.add(line);
    if (event.getThrowableInformation() != null) {
        for (String t: event.getThrowableStrRep()) if (t != null)  this.lines.add(t + "\n");
    }
    if (this.a.incrementAndGet() % 100 == 0) {
        clean(this.maxlines);
        this.a.set(0);
    }
}
 

public void append(LoggingEvent event) {
    super.append(event);
    if (available == true) {
        Log temp = parseLog(event);
        logList.add(temp);
    }
}
 

@Override
public String format(LoggingEvent event) {
	if (event.getLevel() == Level.INFO) {
		sbuf.setLength(0);
		sbuf.append(event.getRenderedMessage());
		sbuf.append(LINE_SEP);
		return sbuf.toString();
	} else {
		return "";
	}
}