All Classes and Interfaces
Class
Description
Implement this interface for your own strategies for outputting log
statements.
A minimal (nop) implementation of BasicConfigurator.
A simple implementation of the
Marker
interface.An almost trivial implementation of the
IMarkerFactory
interface which creates BasicMarker
instances.Basic MDC implementation, which can be used with logging systems that lack
out-of-the-box MDC support.
This class is a minimal implementation of the original
org.apache.log4j.Category
class (as found in log4j 1.2) by
delegation of all calls to a Logger
instance.Implemented by classes capable of configuring log4j using a URL.
Skeleton implementation of ConsoleAppender
Created by IntelliJ IDEA.
This class is used to record events during the initialization phase of the
underlying logging framework.
Holds the results of formatting done by
MessageFormatter
.Listen to events occurring within a
.
invalid reference
Hierarchy
ILoggerFactory
instances manufacture Logger
instances by name.Implementations of this interface are used to manufacture
Marker
instances.A wrapper over
org.apache.commons.logging.Log
in conformance with the Logger
interface.JCLLoggerFactory is an implementation of
ILoggerFactory
returning the
appropriately named JCLLoggerAdapter
instance.This class represents JCL to SLF4J conversion rules
A wrapper over
java.util.logging.Logger
in
conformity with the Logger
interface.JDK14LoggerFactory is an implementation of
ILoggerFactory
returning
the appropriately named JDK14LoggerAdapter
instance.This class represents java.util.logging (JUL) to SLF4J conversion rules
This class is a minimal implementation of the original Log4J class.
Defines the minimum set of levels recognized by the system, that is
OFF
, FATAL
, ERROR
,
WARN
, INFO
, DEBUG
and
ALL
.An optional interface helping integration with logging systems capable of
extracting location information.
A simple logging interface abstracting logging APIs.
This class is a factory that creates and maintains org.apache.log4j.Loggers
wrapping org.slf4j.Loggers.
An exception that is thrown only if a suitable
LogFactory
or
Log
instance cannot be created by the corresponding factory
methods.
Factory for creating
Log
instances, which always delegates to an
instance of SLF4JLogFactory
.
This class is a minimal implementation of the original
org.apache.log4j.Logger
class (as found in log4j 1.2)
delegating all calls to a Logger
instance.The org.slf4j.Logger interface is the main user entry point of SLF4J API.
Implement this interface to create new instances of Logger or
a sub-class of Logger.
The
LoggerFactory
is a utility class producing Loggers for
various logging APIs, most notably for log4j, logback and JDK 1.4 logging.An internal interface which helps the static
LoggerFactory
class bind with the appropriate ILoggerFactory
instance.A
LoggerRepository
is used to create and retrieve
Loggers
.This class used to output log statements from within the log4j package.
This class is a minimal implementation of the original
org.apache.log4j.LogManager
class (as found in log4j 1.2)
delegating all calls to SLF4J.Main entry point to the migrator.
Markers are named objects used to enrich log statements.
MarkerFactory is a utility class producing
Marker
instances as
appropriate for the logging system currently in use.An internal interface which helps the static
MarkerFactory
class bind with the appropriate IMarkerFactory
instance.This class serves as base for adapters or native implementations of logging systems
lacking Marker support.
This class hides and serves as a substitute for the underlying logging
system's MDC implementation.
An adapter to remove the key when done.
This interface abstracts the service offered by various MDC
implementations.
Formats messages according to very simple substitution rules.
This class represents a conversion rule It uses a Pattern and defines for
each capturing group of this Pattern a replacement text
Serves as base class for named logger implementation.
A log4j's NDC implemented in terms of SLF4J MDC primitives.
Trivial implementation of Log that throws away all messages.
A direct NOP (no operation) implementation of
Logger
.NOPLoggerFactory is an trivial implementation of
ILoggerFactory
which always returns the unique instance of
NOPLogger.This adapter is an empty implementation of the
MDCAdapter
interface.An always-empty Enumerator.
This class encapsulates the user's choice of output target.
This class is a minimal implementation of the original Log4J class.
Refrain from using this class directly, use
the
Level
class instead.An nop implementation of PropertyConfigurator.
This class is a minimal implementation of the original Log4J class.
This class runs Pattern matching with java.util.regex using Patterns defined
in concrete implementations
Simple implementation of Log that sends all enabled log messages, for all
defined loggers, to System.err.
Simple implementation of
Logger
that sends all enabled log messages,
for all defined loggers, to the console (System.err
).This class holds configuration values for
SimpleLogger
.An implementation of
ILoggerFactory
which always returns
SimpleLogger
instances.This class represents a conversion rule It uses a Pattern and defines for
each capturing group of this Pattern a replacement text
Bridge/route all JUL log records to the SLF4J API.
Implementation of
org.apache.commons.logging.Log
interface which
delegates all processing to a wrapped org.slf4j.Logger
instance.Implementation of
org.apache.commons.logging.Log
interface which
delegates all processing to a wrapped org.slf4j.Logger
instance.
Concrete subclass of
LogFactory
which always delegates to the
org.slf4j.LoggerFactory
class.The binding of
LoggerFactory
class with an actual instance of
ILoggerFactory
is performed using information returned by this class.The binding of
MarkerFactory
class with an actual instance of
IMarkerFactory
is performed using information returned by this class.This class is only a stub.
A logger implementation which logs via a delegate logger.
SubstituteLoggerFactory manages instances of
SubstituteLogger
.An internal utility class.
In order to call
SecurityManager.getClassContext()
, which is a
protected method, we add this wrapper which allows the method to be visible
inside this package.