public MemoryHandler() 
{
        sealed = false;
        configure();
        sealed = true;
        String name = "???";
        try {
            LogManager manager = LogManager.getLogManager();
            name = manager.getProperty("java.util.logging.MemoryHandler.target");
            Class clz = ClassLoader.getSystemClassLoader().loadClass(name);
            target = (Handler) clz.newInstance();
        } catch (Exception ex) {
            throw new RuntimeException("MemoryHandler can't load handler \"" + name + "\"" , ex);
        }
        init();
}

Create a MemoryHandler and configure it based on LogManager configuration properties.

 public MemoryHandler(Handler target,
    int size,
    Level pushLevel) 
{
        if (target == null || pushLevel == null) {
            throw new NullPointerException();
        }
        if (size < = 0) {
            throw new IllegalArgumentException();
        }
        sealed = false;
        configure();
        sealed = true;
        this.target = target;
        this.pushLevel = pushLevel;
        this.size = size;
        init();
}

Create a MemoryHandler.

The MemoryHandler is configured based on LogManager properties (or their default values) except that the given pushLevel argument and buffer size argument are used.

Parameters:

target - the Handler to which to publish output.

size - the number of log records to buffer (must be greater than zero)

pushLevel - message level to push on

Throws:

IllegalArgumentException - is size is <= 0

 public  void close() throws SecurityException 
{
        target.close();
        setLevel(Level.OFF);
}

Close the Handler and free all associated resources. This will also close the target Handler.

 public  void flush() 
{
        target.flush();
}

Causes a flush on the target Handler.

Note that the current contents of the MemoryHandler buffer are not written out. That requires a "push".

 public synchronized Level getPushLevel() 
{
        return pushLevel;
}

Get the pushLevel.

 public boolean isLoggable(LogRecord record) 
{
        return super.isLoggable(record);
}

Check if this Handler would actually log a given LogRecord into its internal buffer.

This method checks if the LogRecord has an appropriate level and whether it satisfies any Filter. However it does not check whether the LogRecord would result in a "push" of the buffer contents. It will return false if the LogRecord is Null.

 public synchronized  void publish(LogRecord record) 
{
        if (!isLoggable(record)) {
            return;
        }
        int ix = (start+count)%buffer.length;
        buffer[ix] = record;
        if (count <  buffer.length) {
            count++;
        } else {
            start++;
            start %= buffer.length;
        }
        if (record.getLevel().intValue()  >= pushLevel.intValue()) {
            push();
        }
}

Store a LogRecord in an internal buffer.

If there is a Filter, its isLoggable method is called to check if the given log record is loggable. If not we return. Otherwise the given record is copied into an internal circular buffer. Then the record's level property is compared with the pushLevel. If the given level is greater than or equal to the pushLevel then push is called to write all buffered records to the target output Handler.

 public synchronized  void push() 
{
        for (int i = 0; i <  count; i++) {
            int ix = (start+i)%buffer.length;
            LogRecord record = buffer[ix];
            target.publish(record);
        }
        // Empty the buffer.
        start = 0;
        count = 0;
}

Push any buffered output to the target Handler.

The buffer is then cleared.

 public  void setPushLevel(Level newLevel) throws SecurityException 
{
        if (newLevel == null) {
            throw new NullPointerException();
        }
        LogManager manager = LogManager.getLogManager();
        checkAccess();
        pushLevel = newLevel;
}

Set the pushLevel. After a LogRecord is copied into our internal buffer, if its level is greater than or equal to the pushLevel, then push will be called.