All Classes and Interfaces

Class
Description
An abstract Rule class that provides the PropertyChange support plumbing.
The Action interface should be implemented by any class that performs file system actions for RollingFileAppenders after the close of the active log file.
Abstract base class for implementations of Action.
Net based entities that 'work with' an Address should consider implementing this interface so that they can be treated generically.
A filter that 'and's the results of any number of contained filters together.
A Rule class implementing a logical 'and'.
A Rule class which also holds a color.
A common interface shared by log4j components.
Most log4j components derive from this class.
A group of Actions to be executed in sequence.
CompositeTriggeringPolicy determines if rolling should be triggered by evaluating the current event against a set of triggering policies.
The ConnectionSource interface provides a pluggable means of transparently obtaining JDBC Connections for log4j classes that require the use of a Connection.
 
Constants used internally throughout log4j.
Converts log data stored in a database into LoggingEvents.
The DataSourceConnectionSource is an implementation of ConnectionSource that obtains the Connection in the recommended JDBC manner based on a DataSource.
 
 
Actual retrieval of data is made by the instance of DBReceiverJob associated with DBReceiver.
Allow LoggingEvents to be reconstructed from a different format (usually XML).
This filter drops all logging events.
This is a duplicate (with minor modifications) of the log4j 1.2.15 DOMConfigurator renamed for use with earlier versions of log4j.
An EntityResolver specifically designed to return log4j.dtd which is embedded within the log4j jar file.
 
 
The DriverManagerConnectionSource is an implementation of ConnectionSource that obtains the Connection in the traditional JDBC manner based on the connection URL.
A Rule class which returns the result of performing equals against two strings.
Used to store special log4j errors which cannot be logged using internal logging.
A Rule class implementing a not null (and not empty string) check.
A filter supporting complex expressions - supports both infix and postfix expressions (infix expressions must first be converted to postfix prior to processing).
A Rule class supporting both infix and postfix expressions, accepting any rule which is supported by the RuleFactory.
Evaluate a boolean postfix expression.
Modifies the output of a pattern converter for a specified minimum and maximum width and alignment.
Most of the work of the EnhancedPatternLayout class is delegated to the ExtrasPatternParser class.
The class wraps another Map but throws exceptions on any attempt to modify the map.
File rename action.
FilterBasedTriggeringPolicy determines if rolling should be triggered by evaluating the current message against a set of filters.
When rolling over, FixedWindowRollingPolicy renames files according to a fixed window algorithm as described below.
Compresses a file using GZ compression.
The HSQLDB dialect.
A Rule class implementing inequality evaluation.
A helper class which converts infix expressions to postfix expressions Currently grouping is supported, as well as all of the Rules supported by RuleFactory Supports grouping via parens, mult-word operands using single or double quotes, and these operators: ! NOT operator != NOT EQUALS operator == EQUALS operator ~= CASE-INSENSITIVE equals operator || OR operator invalid input: '&'invalid input: '&' AND operator like REGEXP operator exists NOT NULL operator invalid input: '&lt' LESS THAN operator invalid input: '&gt' GREATER THAN operator invalid input: '&lt'= LESS THAN EQUALS operator invalid input: '&gt'= GREATER THAN EQUALS operator
 
JMSReceiver receives a remote logging event on a configured JSM topic and "posts" it to a LoggerRepository as if the event was generated locally.
BeanInfo class for the JMSReceiver.
The JNDIConnectionSource is an implementation of ConnectionSource that obtains a DataSource from a JNDI provider and uses it to obtain a Connection.
Job is a very simple interface.
A Rule class implementing equals against two levels.
A Rule class implementing inequality evaluation for Levels (log4j and util.logging) using the toInt method.
Rule returning true if event level greater than or equal to specified level.
Rule returning true if event level greater than specified level.
Rule returning true if event level less than or equal to specified level.
Rule returning true if event level less than specified level.
This is a very simple filter based on level matching.
This is a very simple filter based on level matching, which can be used to reject messages with priorities outside a certain range.
A Rule class supporting java.util.regex regular expression syntax.
A very basic appender that takes the events and stores them in to a ListModel for late retrieval.
Location information is usually specified at the appender level - all events associated with an appender either create and parse stack traces or they do not.
An implementation of ULogger on org.apache.log4j.Logger.
LogFilePatternReceiver can parse and tail log files, converting entries into LoggingEvents.
BeanInfo class for the meta-data of the LogFilePatternReceiver.
LogFileXMLReceiver will read an xml-formated log file and make the events in the log file available to the log4j framework.
Interface used to listen for Logger related events such as add/remove appender or changing levels.
This is a very simple filter based on logger name matching.
Interface used to listen for LoggerRepository related events such as startup, reset, and shutdown.
A LoggerRepository is used to create and retrieve Loggers.
This class implements LoggerRepositoryEx by wrapping an existing LoggerRepository implementation and implementing the newly added capabilities.
Proxy that implements HierarchyEventListener and delegates to LoggerEventListener.
Implementation of RendererSupportImpl if not provided by LoggerRepository.
A singleton helper utility which accepts a field name and a LoggingEvent and returns the value of that field.
This policy rewrites events where the message of the original event implementes java.util.Map.
Formats messages according to very simple rules.
The MS SQL Server dialect is untested.
Multicast-based Appender.
Multicast-based receiver.
BeanInfo class for the meta-data of the MulticastReceiver.
 
The parent of all the Network based interfaces.
A no operation (NOP) implementation of ULogger.
A Rule class implementing not equals against two strings.
A Rule class implementing not equals against two levels.
A Rule class implementing logical not.
The Oracle dialect.
A Rule class implementing logical or.
A Rule class implementing case-insensitive partial-text matches against two strings.
Instances of this interface can be paused, and resumed.
Defines the required interface for all Plugin objects.
All Plugin events are encapsulated in this class, which simply contains the source Plugin, but may in future include more information.
PluginListeners are notified when plugins are started or stopped by the PluginRegistry.
This is a registry for Plugin instances.
A convienent abstract class for plugin subclasses that implements the basic methods of the Plugin interface.
Net based entities that 'work with' a Port should consider implementing this interface so that they can be treated generically.
 
This policy rewrites events by adding a user-specified list of properties to the event.
Defines the base class for Receiver plugins.
This policy rewrites events by evaluating any JavaBean properties on the message object and adding them to the event properties.
This appender forwards a logging request to another appender after possibly rewriting the logging event.
This interface is implemented to provide a rewrite strategy for RewriteAppender.
RollingFileAppender extends FileAppender to backup the log files depending on RollingPolicy and TriggeringPolicy.
Wrapper for OutputStream that will report all write operations back to this class for file length calculations.
 
A RollingPolicy specifies the actions taken on a logging file rollover.
Implements methods common to most, it not all, rolling policies.
Description of actions needed to complete rollover.
Description of actions needed to complete rollover.
A Rule evaluates to true of false given a LoggingEvent object, and can notify listeners when the underlying implementation of this Rule has it's criteria changed by using the standard PropertyChangeListener infrastructure.
A Factory class which, given a string representation of the rule, and a context stack, will return a Rule ready for evaluation against events.
A simple but still useful implementation of a Scheduler (in memory only).
Represents an entry in job scheduler.
A simple implementation that logs messages of level INFO or higher on the console (System.out).
SizeBasedTriggeringPolicy looks at size of the file being currently written to.
SocketHubReceiver receives a remote logging event on a configured socket and "posts" it to a LoggerRepository as if the event was generated locally.
Read LoggingEvent objects sent from a remote client using Sockets (TCP).
Interface used to listen for SocketNode related events.
SocketReceiver receives a remote logging event on a configured socket and "posts" it to a LoggerRepository as if the event was generated locally.
Socket detail.
This class is equivalent to org.apache.log4j.varia.SoundAppender except for a package change to aid in use with OSGi.
Plays a sound clip created using Applet.newAudioClip when an event is received.
 
This is a very simple filter based on string matching.
The Sybase dialect.
An interface that defines the required methods for supporting the setting and getting of a level threshold.
TimeBasedRollingPolicy is both easy to configure and quite powerful.
Filters events that fall within a specified time period in each day.
A Rule class implementing equality evaluation for timestamps.
A Rule class implementing inequality evaluation for timestamps.
A TriggeringPolicy controls the conditions under which rollover occurs.
Sends log information as a UDP datagrams.
Receive LoggingEvents encoded with an XMLLayout, convert the XML data to a LoggingEvent and post the LoggingEvent.
A proxy for org.slf4j.ULogger.
 
An EntityResolver specifically designed to return an empty InputSource for logger.dtd.
This class is identical to org.apache.log4j.helpers.UtilLoggingLevel except for a package change to aid in use with OSGi.
An extension of the Level class that provides support for java.util.logging Levels.
Decodes JDK 1.4's java.util.logging package events delivered via XML (using the logger.dtd).
Decodes Logging Events in XML formated into elements that are used by Chainsaw.
Read LoggingEvent objects sent from a remote client using XML over Sockets (TCP).
XMLSocketReceiver receives a remote logging event via XML on a configured socket and "posts" it to a LoggerRepository as if the event were generated locally.
This class is identical to org.apache.log4j.xml.XSLTLayout except for a change in package to aid in use with OSGi.
XSLTLayout transforms each event as a document using a specified or default XSLT transform.
Compresses a file using Zip compression.