| |
|
| java.lang.Object
 java.util.logging.Handler
java.util.logging.MemoryHandler
| MemoryHandler | | public class MemoryHandler extends Handler (Code) | | Handler that buffers requests in a circular buffer in memory.
Normally this Handler simply stores incoming LogRecords
into its memory buffer and discards earlier records. This buffering
is very cheap and avoids formatting costs. On certain trigger
conditions, the MemoryHandler will push out its current buffer
contents to a target Handler, which will typically publish
them to the outside world.
There are three main models for triggering a push of the buffer:
-
An incoming LogRecord has a type that is greater than
a pre-defined level, the pushLevel.
-
An external class calls the push method explicitly.
-
A subclass overrides the log method and scans each incoming
LogRecord and calls push if a record matches some
desired criteria.
Configuration:
By default each MemoryHandler is initialized using the following
LogManager configuration properties. If properties are not defined
(or have invalid values) then the specified default values are used.
If no default value is defined then a RuntimeException is thrown.
- java.util.logging.MemoryHandler.level
specifies the level for the Handler
(defaults to Level.ALL).
- java.util.logging.MemoryHandler.filter
specifies the name of a Filter class to use
(defaults to no Filter).
- java.util.logging.MemoryHandler.size
defines the buffer size (defaults to 1000).
- java.util.logging.MemoryHandler.push
defines the pushLevel (defaults to level.SEVERE).
- java.util.logging.MemoryHandler.target
specifies the name of the target Handler class.
(no default).
version:
1.32, 05/05/07
since:
1.4 |
| Constructor Summary | |
| public | MemoryHandler()
Create a MemoryHandler and configure it based on
LogManager configuration properties. | | public | MemoryHandler(Handler target, int size, Level pushLevel)
Create a MemoryHandler. |
| Method Summary | |
| public void | close()
Close the Handler and free all associated resources. | | public void | flush()
Causes a flush on the target Handler.
Note that the current contents of the MemoryHandler
buffer are not written out. | | public synchronized Level | getPushLevel()
Get the pushLevel. | | public boolean | isLoggable(LogRecord 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. | | public synchronized void | publish(LogRecord record)
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. | | public synchronized void | push()
Push any buffered output to the target Handler. | | public void | setPushLevel(Level newLevel)
Set the pushLevel. |
| startcount | | int startcount(Code) | | |
| MemoryHandler | | public MemoryHandler()(Code) | | Create a MemoryHandler and configure it based on
LogManager configuration properties.
|
| MemoryHandler | | public MemoryHandler(Handler target, int size, Level pushLevel)(Code) | | 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.
Parameters:
size - the number of log records to buffer (must be greater than zero)
Parameters:
pushLevel - message level to push on
throws:
IllegalArgumentException - is size is <= 0 |
| close | | public void close() throws SecurityException(Code) | | Close the Handler and free all associated resources.
This will also close the target Handler.
exception:
SecurityException - if a security manager exists and ifthe caller does not have LoggingPermission("control"). |
| flush | | public void flush()(Code) | | Causes a flush on the target Handler.
Note that the current contents of the MemoryHandler
buffer are not written out. That requires a "push".
|
| getPushLevel | | public synchronized Level getPushLevel()(Code) | | Get the pushLevel.
the value of the pushLevel |
| isLoggable | | public boolean isLoggable(LogRecord record)(Code) | | 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.
Parameters:
record - a LogRecord true if the LogRecord would be logged. |
| publish | | public synchronized void publish(LogRecord record)(Code) | | 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.
Parameters:
record - description of the log event. A null record issilently ignored and is not published |
| push | | public synchronized void push()(Code) | | Push any buffered output to the target Handler.
The buffer is then cleared.
|
| setPushLevel | | public void setPushLevel(Level newLevel) throws SecurityException(Code) | | 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.
Parameters:
newLevel - the new value of the pushLevel
exception:
SecurityException - if a security manager exists and ifthe caller does not have LoggingPermission("control"). |
|
|
|