All Classes and Interfaces
Class
Description
Formats a
Date in the format "HH:mm:ss,SSS" for example,
"15:49:37,459".Implement this interface for your own strategies for outputting log
statements.
Interface for attaching appenders to objects.
A straightforward implementation of the
AppenderAttachable interface.Abstract superclass of the other appenders in the package.
The AsyncAppender lets users log events asynchronously.
Render
org.xml.sax.Attributes objects.Use this class to quickly configure the package.
BoundedFIFO serves as the bounded first-in-first-out buffer
heavily used by the AsyncAppender.The class implements the pre log4j 1.3
org.apache.log4j.helpers.PatternConverter contract by delegating to the log4j
1.3 pattern implementation.
The class implements the pre log4j 1.3
org.apache.log4j.helpers.PatternConverter contract by delegating to the log4j
1.3 pattern implementation.
CachedDateFormat optimizes the performance of a wrapped DateFormat.
This class has been deprecated and replaced by the
Logger subclass.Formats the class name of the site of the logging request.
Implemented by classes capable of configuring log4j using a URL.
ConsoleAppender appends log events to
System.out or
System.err using a layout specified by the user.Counts the number of bytes written.
A GC-free lock-free thread-safe implementation of the
List interface
for use cases where iterations over the list vastly out-number modifications
on the list.CyclicBuffer is used by other appenders to hold
LoggingEvents for immediate or differed display.DailyRollingFileAppender extends
FileAppender so that the underlying
file is rolled over at a user chosen frequency.This abstract layout takes care of all the date related options and
formatting work.
Convert and format the event's date in a StringBuffer.
Formats a
Date in the format "dd MMM yyyy HH:mm:ss,SSS" for example,
"06 Nov 1994 15:49:37,459".Default implementation of ThrowableRenderer using Throwable.printStackTrace.
This filter drops all logging events.
Use this class to initialize the log4j environment using a DOM tree.
This class is an enhanced version of org.apache.log4j.PatternLayout which was
originally developed as part of the abandoned log4j 1.3 effort and has been
available in the extras companion.
Enhanced implementation of ThrowableRenderer.
This interface defines commonly encoutered error codes.
Appenders may delegate their error handling to
ErrorHandlers.This appender listens on a socket on the port specified by the Port
property for a "RollOver" message.
The
FallbackErrorHandler implements the ErrorHandler interface
such that a secondary appender may be specified.FileAppender appends log events to a file.
Formats an date by delegating to DatePatternConverter.
Return the event's line location information in a StringBuffer.
Check every now and then that a certain file has not changed.
Users should extend this class to implement customized logging event
filtering.
FormattingInfo instances contain the information obtained when parsing
formatting modifiers in conversion modifiers.
Modifies the output of a pattern converter for a specified minimum and
maximum width and alignment.
Format the event's line location information.
HardenedObjectInputStream restricts the set of classes that can be
deserialized to a set of explicitly whitelisted classes.
This class is specialized in retrieving loggers by name and also maintaining
the logger hierarchy.
Listen to events occuring within a
Hierarchy.This layout outputs events in a HTML table.
Formats an integer.
Formats a
Date in the format "yyyy-MM-dd HH:mm:ss,SSS" for example
"1999-11-27 15:49:37,459".The JDBCAppender provides for sending log events to a database.
A simple appender that publishes events to a JMS Topic.
A simple application that consumes logging events sent by a
JMSAppender.Extend this abstract class to create your own log layout format.
Defines the minimum set of levels recognized by the system, that is
OFF, FATAL, ERROR, WARN,
INFO, DEBUG and ALL.This is a very simple filter based on level matching.
Return the event's level in a StringBuffer.
This is a very simple filter based on level matching, which can be used to
reject messages with priorities outside a certain range.
Return the event's line location information in a StringBuffer.
Formats a line separator.
Formats a string literal.
Load resources (or images) from various sources.
The internal representation of caller location information.
An
EntityResolver specifically designed to return
log4j.dtd which is embedded within the log4j jar file.This class is a copy of o.a.l.spi.LoggingEvent from log4j 1.2.15 which has
been renamed to keep the same overall class name length to allow a
serialization written with a prior instance of o.a.l.spi.LoggingEvent to be
deserialized with this class just by mangling the class name in the byte
stream.
This is the central class in the log4j package.
Implement this interface to create new instances of Logger or a sub-class of
Logger.
Formats a logger name.
A
LoggerRepository is used to create and retrieve
Loggers.The internal representation of logging events.
LoggingEventPatternConverter is a base class for pattern converters that can
format information from instances of LoggingEvent.
This class used to output log statements from within the log4j package.
Use the
LogManager class to retreive Logger instances or
to operate on the current LoggerRepository.This class provides parameterized logging services using the pattern syntax
of java.text.MessageFormat.
This class provides parameterized logging services using the SLF4J pattern
syntax.
This is a base class for LogMF and LogSF parameterized logging classes.
The main application.
This policy rewrites events where the message of the original event
implementes java.util.Map.
The MDC class is similar to the
NDC class except that it is based on
a map instead of a stack.Return the event's rendered message in a StringBuffer.
Render
javax.jms.Message objects.Return the event's line location information in a StringBuffer.
NameAbbreviator generates abbreviated logger and class names.
Base class for other pattern converters which can return only parts of their
name.
The NDC class implements nested diagnostic contexts as defined by Neil
Harrison in the article "Patterns for Logging Diagnostic Messages" part of
the book "Pattern Languages of Program Design 3" edited by Martin et
al.
Return the event's NDC in a StringBuffer.
No-operation implementation of Logger used by NOPLoggerRepository.
No-operation implementation of LoggerRepository which is used when
LogManager.repositorySelector is erroneously nulled during class reloading.
A NullAppender merely exists, it never outputs a message to any device.
An always-empty Enumerator.
Implement this interface in order to render objects as strings.
The
OnlyOnceErrorHandler implements log4j's default error
handling policy which consists of emitting a message for the first error in
an appender and ignoring all following errors.A convenience class to convert property values to specific types.
A string based interface to configure package components.
PatternConverter is an abtract class that provides the formatting
functionality that derived classes need.
PatternConverter is an abstract class that provides the formatting
functionality that derived classes need.
A flexible layout configurable with pattern string.
Most of the work of the
PatternLayout class is
delegated to the PatternParser class.Most of the work of the
EnhancedPatternLayout class
is delegated to the PatternParser class.Refrain from using this class directly, use the
Level class instead.Able to handle the contents of the LoggingEvent's Property bundle and either
output the entire contents of the properties in a similar format to the
java.util.Hashtable.toString(), or to output the value of a specific key
within the property bundle when this pattern converter has the option set.
Allows the configuration of log4j from an external file.
Used for inferring configuration information for a log4j's component.
Prints the configuration of the log4j default hierarchy (which needs to be
auto-initialized) as a propoperties file on a
PrintWriter.This policy rewrites events by adding a user-specified list of properties to
the event.
General purpose Object property setter.
Thrown when an error is encountered whilst attempting to set a property using
the
PropertySetter utility class.QuietWriter does not throw exceptions when things go wrong.
This policy rewrites events by evaluating any JavaBean properties on the
message object and adding them to the event properties.
Formats a
Date by printing the number of milliseconds elapsed since
construction of the format.Return the relative time in milliseconds since loading of the LoggingEvent
class.
Map class objects to an
ObjectRenderer.The
LogManager uses one (and only one)
RepositorySelector implementation to select the
LoggerRepository for a particular application context.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.
A simple application to send roll over messages to a potentially remote
ExternallyRolledFileAppender.RollingFileAppender extends FileAppender to backup the log files when they
reach a certain size.
Deprecated.
RootLogger sits at the top of the logger hierachy.
Formats the event sequence number.
SimpleLayout consists of the level of the log statement, followed by " - "
and then the log message itself.
A simple
SocketNode based server.Send an e-mail when a specific logging event occurs, typically on errors or
fatal errors.
Sends
LoggingEvent objects to a remote a log server, usually a
SocketNode.Sends
LoggingEvent objects to a set of remote log servers, usually a
SocketNodes.Read
LoggingEvent objects sent from a remote client using Sockets
(TCP).A
SocketNode based server that uses a different hierarchy for each
client.This is a very simple filter based on string matching.
Use SyslogAppender to send log messages to a remote syslog daemon.
SyslogQuietWriter extends QuietWriter by prepending the syslog level code
before each printed String.
SyslogWriter is a wrapper around the java.net.DatagramSocket class so that it
behaves like a java.io.Writer.
The TelnetAppender is a log4j appender that specializes in writing to a
read-only socket.
Render
ThreadGroup objects in a format similar to the information
output by the ThreadGroup.list() method.ThreadLocalMap extends InheritableThreadLocal to
bequeath a copy of the hashtable of the MDC of the parent thread.Formats the event thread name.
ThrowableInformation is log4j's internal representation of throwables.
Outputs the ThrowableInformation portion of the LoggingEvent.
Implemented by classes that render instances of java.lang.Throwable
(exceptions and errors) into a string representation.
Implemented by logger repositories that support configurable rendering of
Throwables.
Utility class for transforming strings.
Implementions of this interface allow certain appenders to decide when to
perform an appender specific action.
TTCC layout format consists of time, thread, category and nested diagnostic
context information, hence the name.
When implemented by an object configured by DOMConfigurator, the handle
method will be called when an unrecognized child element is encountered.
An extension of the Level class that provides support for java.util.logging
Levels.
WriterAppender appends log events to a
Writer or an
OutputStream depending on the user's choice.The output of the XMLLayout consists of a series of log4j:event elements as
defined in the log4j.dtd.
RootLogger.