All Classes and Interfaces
Class
Description
An abstract implementation which delegates actual logging work to the
AbstractLogger.handleNormalizedLoggingCall(Level, Marker, String, Object[], Throwable) method.
All recognized options in the string passed to the java agent.
Entry point for slf4j-ext when used as a Java agent.
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.An enum of supported time units.
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.Helper methods for Javassist functionality.
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.Instances of this class store the key value pair passed to a
logger via
the LoggingEventBuilder.addKeyValue(String, Object) method of the fluent API.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 a level.
An optional interface helping integration with logging systems capable of
extracting location information.
A logger specialized in localized logging.
This class is essentially a wrapper around an
LoggerFactory producing
LocLogger instances.A simple logging interface abstracting logging APIs.
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, e.g.All methods in this class are reserved for internal use, for testing purposes.
A
LoggerRepository is used to create and retrieve
Loggers.A helper class wrapping an
Logger instance preserving
location information if the wrapped instance supports it.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 central 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.
LogTransformer does the work of analyzing each class, and if appropriate add
log statements to each method to allow logging entry/exit.
Builder provides a flexible way of configuring some of many options on the
parent class instead of providing many constructors.
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.
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.
This class assists in the creation and removal (aka closing) of
MDC entries.Formats messages according to very simple substitution rules.
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.As the name indicates, this {#link SLF4JServiceProvider} implementation git sdiscards all events.
Holds normalized call parameters.
An always-empty Enumerator.
This class is a minimal implementation of the original Log4J class.
Refrain from using this class directly, use
the
Level class instead.A poor man's profiler to measure the time elapsed performing some lengthy
task.
A minimalist registry of profilers.
A no-op implementation of PropertyConfigurator.
A wrapper over
org.apache.log4j.Logger
conforming to the Logger interface.Log4jLoggerFactory is an implementation of
ILoggerFactory returning
the appropriate named Reload4jLoggerAdapter instance.An internally used class for reporting internal messages generated by SLF4J itself during initialization.
This class is a minimal implementation of the original Log4J class.
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.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.This interface based on
ServiceLoader paradigm.A very basic
TimeInstrument which can be started and stopped
once and only once.A logger implementation which logs via a delegate logger.
SubstituteLoggerFactory manages instances of
SubstituteLogger.An implementation of
LoggingEvent used to store logging events generated during logging backend
initialization.A simple implementation of ThreadLocal backed Map containing values of type
Deque.
An internal utility class.
A utility that provides standard mechanisms for logging certain kinds of
activities.
This class is essentially a wrapper around an
LoggerFactory producing XLogger instances.