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: '<' LESS THAN operator
invalid input: '>' GREATER THAN operator
invalid input: '<'= LESS THAN EQUALS operator
invalid input: '>'= GREATER THAN EQUALS operatorJMSReceiver 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.