All Classes and Interfaces

Class
Description
 
An abstract implementation which delegates actual logging work to the AbstractLogger.handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable) method.
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.
Additional interface to LoggingEventBuilder and LoggingEvent.
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.
Used to annotate methods in the LoggingEventBuilder interface which return an instance of LoggingEventBuilder (usually as this).
Implemented by classes capable of configuring log4j using a URL.
Skeleton implementation of ConsoleAppender
 
 
 
 
A default implementation of LoggingEvent.
Default implementation of LoggingEventBuilder
 
 
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 Hierarchy.
ILoggerFactory instances manufacture Logger instances by name.
Implementations of this interface are used to manufacture Marker instances.
 
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.
Provides minimal default implementations for LegacyAbstractLogger.isTraceEnabled(Marker), LegacyAbstractLogger.isDebugEnabled(Marker) and other similar methods.
Defines the minimum set of levels recognized by the system, that is OFF, FATAL, ERROR, WARN, INFO, DEBUG and ALL.
SLF4J's internal representation of Level.
 
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 subclass of Logger.
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for log4j, logback and JDK 1.4 logging.
Deprecated. 
All methods in this class are reserved for internal use, for testing purposes.
A LoggerRepository is used to create and retrieve Loggers.
 
The minimal interface sufficient for the restitution of data passed by the user to the SLF4J API.
A logger capable of logging from org.slf4j.event.LoggingEvent implements this interface.
This is the main interface in slf4j's fluent API for creating logging events.
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.
Deprecated. 
Deprecated. 
 
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 a trivial implementation of ILoggerFactory which always returns the unique instance of NOPLogger.
A no-operation implementation of LoggingEventBuilder.
This adapter is an empty implementation of the MDCAdapter interface.
 
Holds normalized call parameters.
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.
 
 
 
A no-op 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
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.
Manages instances of SLF4JPlatformLogger.
This interface based on ServiceLoader paradigm.
Uses SLF4JPlarformLoggerFactory.getLogger(String) to get a logger that is adapted for System.Logger.
 
A logger implementation which logs via a delegate logger.
SubstituteLoggerFactory manages instances of SubstituteLogger.
 
 
A simple implementation of ThreadLocal backed Map containing values of type Deque.
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.