All Classes (Apache Log4j 2 2.17.1 API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class	Description
AbstractAction	Abstract base class for implementations of Action.
AbstractAppender	Abstract base class for Appenders.
AbstractAppender.Builder<B extends AbstractAppender.Builder<B>>	Subclasses can extend this abstract Builder.
AbstractBuilder	Base class for Log4j 1 component builders.
AbstractConfiguration	The base Configuration.
AbstractConfigurationAwareLookup	StrLookup that is ConfigurationAware.
AbstractFileAppender<M extends OutputStreamManager>	Abstract File Appender.
AbstractFileAppender.Builder<B extends AbstractFileAppender.Builder<B>>	Builds FileAppender instances.
AbstractFilter	Users should extend this class to implement filters.
AbstractFilter.AbstractFilterBuilder<B extends AbstractFilter.AbstractFilterBuilder<B>>
AbstractFilterable	Enhances a Class by allowing it to contain Filters.
AbstractFilterable.Builder<B extends AbstractFilterable.Builder<B>>	Subclasses can extend this abstract Builder.
AbstractKeyStoreConfiguration	Configuration of the KeyStore
AbstractLayout<T extends Serializable>	Abstract base class for Layouts.
AbstractLayout.Builder<B extends AbstractLayout.Builder<B>>	Subclasses can extend this abstract Builder.
AbstractLifeCycle	A life cycle to be extended.
AbstractLogEvent	An abstract log event implementation with default values for all methods.
AbstractLogger	Base implementation of a Logger.
AbstractLoggerAdapter<L>	Provides an abstract base class to use for implementing LoggerAdapter.
AbstractLookup	A default lookup for others to extend.
AbstractManager	Abstract base class used to register managers.
AbstractMessageFactory	Provides an abstract superclass for `MessageFactory2` implementations with default implementations (and for `MessageFactory` by extension).
AbstractOutputStreamAppender<M extends OutputStreamManager>	Appends log events as bytes to a byte output stream.
AbstractOutputStreamAppender.Builder<B extends AbstractOutputStreamAppender.Builder<B>>	Subclasses can extend this abstract Builder.
AbstractPathAction	Abstract action for processing files that are accepted by the specified PathFilters.
AbstractPatternConverter	AbstractPatternConverter is an abstract class that provides the formatting functionality that derived classes need.
AbstractPluginVisitor<A extends Annotation>	Base class for PluginVisitor implementations.
AbstractRolloverStrategy
AbstractScript	Container for the language and body of a script.
AbstractSocketManager	Abstract base class for managing sockets.
AbstractStringLayout	Abstract base class for Layouts that result in a String.
AbstractStringLayout.Builder<B extends AbstractStringLayout.Builder<B>>
AbstractStringLayout.Serializer
AbstractStringLayout.Serializer2	Variation of `AbstractStringLayout.Serializer` that avoids allocating temporary objects.
AbstractStyleNameConverter	Style pattern converter.
AbstractStyleNameConverter.Black	Black style pattern converter.
AbstractStyleNameConverter.Blue	Blue style pattern converter.
AbstractStyleNameConverter.Cyan	Cyan style pattern converter.
AbstractStyleNameConverter.Green	Green style pattern converter.
AbstractStyleNameConverter.Magenta	Magenta style pattern converter.
AbstractStyleNameConverter.Red	Red style pattern converter.
AbstractStyleNameConverter.White	White style pattern converter.
AbstractStyleNameConverter.Yellow	Yellow style pattern converter.
AbstractTriggeringPolicy	Abstract convenience class for triggering policies that extend `AbstractLifeCycle` and implement `TriggeringPolicy`.
AbstractWatcher	Watcher for configuration files.
AbstractWatcher.ReconfigurationRunnable	Helper class for triggering a reconfiguration in a background thread.
AbstractWriterAppender<M extends WriterManager>	Appends log events as strings to a writer.
Action	The Action interface should be implemented by any class that performs file system actions for RollingFileAppenders after the close of the active log file.
Activator	OSGi BundleActivator.
Advertiser
AnsiEscape	Converts text into ANSI escape sequences.
Appender	Implement this interface for your own strategies for outputting log statements.
Appender	Appends `LogEvent`s.
AppenderAdapter	Binds a Log4j 1.x Appender to Log4j 2.
AppenderAdmin	Implementation of the `AppenderAdminMBean` interface.
AppenderAdminMBean	The MBean interface for monitoring and managing an `Appender`.
AppenderAttachable	Interface for attaching appenders to objects.
AppenderAttachableImpl	Allows Classes to attach Appenders.
AppenderBuilder	Define an Appender Builder.
AppenderComponentBuilder	Builder for constructing Appender Components.
AppenderControl	Wraps an `Appender` with details an appender implementation shouldn't need to know about.
AppenderControlArraySet	Data structure with similar semantics to CopyOnWriteArraySet, but giving direct access to the underlying array.
AppenderLoggingException	Thrown from an appender when a log event could not be written.
AppenderRef	An Appender reference.
AppenderRefComponentBuilder	Assembler for constructing AppenderRef Components.
AppenderSet	A deferred plugin for appenders.
AppenderSet.Builder
AppenderSkeleton	The base class for Appenders in Log4j 1.
AppenderSkeleton.NoOpErrorHandler
AppendersPlugin	An Appender container.
AppenderWrapper	Holds a Log4j 2 Appender in an empty Log4j 1 Appender so it can be extracted when constructing the configuration.
Arbiter	Interface used to check for portions of the configuration that may be optionally included.
ArrayBlockingQueueFactory<E>	Factory for creating instances of `ArrayBlockingQueue`.
ArrayPatternConverter	`PatternConverter`s implement this interface to accept an array of objects when formatting.
ArrayUtils	Copied from Apache Commons Lang (including the `@since` tags.)
Assert	Utility class providing common validation logic.
AsyncAppender	Appends to one or more Appenders asynchronously.
AsyncAppender.Builder<B extends AsyncAppender.Builder<B>>
AsyncAppenderAdmin	Implementation of the `AsyncAppenderAdminMBean` interface.
AsyncAppenderAdminMBean	The MBean interface for monitoring and managing an `AsyncAppender`.
AsyncAppenderBuilder	Build an Asynch Appender
AsynchronouslyFormattable	Annotation that signals to asynchronous logging components that messages of this type can safely be passed to a background thread without calling `Message.getFormattedMessage()` first.
AsyncLogger	AsyncLogger is a logger designed for high throughput and low latency logging.
AsyncLoggerConfig	Asynchronous Logger object that is created via configuration and can be combined with synchronous loggers.
AsyncLoggerConfig.RootLogger	An asynchronous root Logger.
AsyncLoggerConfigDefaultExceptionHandler	Default disruptor exception handler for errors that occur in the AsyncLogger background thread.
AsyncLoggerConfigDelegate	Encapsulates the mechanism used to log asynchronously.
AsyncLoggerConfigDisruptor	Helper class decoupling the `AsyncLoggerConfig` class from the LMAX Disruptor library.
AsyncLoggerConfigDisruptor.Log4jEventWrapper	RingBuffer events contain all information necessary to perform the work in a separate thread.
AsyncLoggerContext	`LoggerContext` that creates `AsyncLogger` objects.
AsyncLoggerContextSelector	`ContextSelector` that manages `AsyncLoggerContext` instances.
AsyncLoggerDefaultExceptionHandler	Default disruptor exception handler for errors that occur in the AsyncLogger background thread.
AsyncQueueFullMessageUtil	Consider this class private.
AsyncQueueFullPolicy	Policy for deciding whether to discard the event, enqueue it or log the event on the current thread when the queue is full.
AsyncQueueFullPolicyFactory	Creates `AsyncQueueFullPolicy` instances based on user-specified system properties.
AuthorizationProvider	Interface to be implemented to add an Authorization header to an HTTP request.
AwaitCompletionReliabilityStrategy	ReliabilityStrategy that counts the number of threads that have started to log an event but have not completed yet, and waits for these threads to finish before allowing the appenders to be stopped.
AwaitUnconditionallyReliabilityStrategy	Reliability strategy that sleeps unconditionally for some time before allowing a Configuration to be stopped.
Base64Converter
Base64Util	Base64 encodes Strings.
BasicAsyncLoggerContextSelector	Returns either this Thread's context or the default `AsyncLoggerContext`.
BasicAuthorizationProvider	Provides the Basic Authorization header to a request.
BasicCommandLineArguments
BasicConfigurator	Provided for compatibility with Log4j 1.x.
BasicContextSelector	Returns either this Thread's context or the default LoggerContext.
BiConsumer<K,V>	An operation that accepts two input arguments and returns no result.
BlockingQueueFactory<E>	Factory for creating instances of `BlockingQueue`.
BooleanHolder	Deprecated. Use `AtomicReference`.
Booleans	Boolean helpers.
Builder<T>	A type of builder that can be used to configure and create a instances using a Java DSL instead of through a configuration file.
BuilderManager
BuiltConfiguration	This is the general version of the Configuration created by the Builder.
BundleContextSelector	ContextSelector for OSGi bundles.
BurstFilter	The `BurstFilter` is a logging filter that regulates logging traffic.
BurstFilter.Builder
ByteBufferDestination	ByteBufferDestination is the destination that `Encoder`s write binary data to.
ByteBufferDestinationHelper	Helper class for ByteBufferDestination implementors.
CachedClock	Implementation of the `Clock` interface that tracks the time in a private long field that is updated by a background thread once every millisecond.
Cancellable	Interface to cancel a Runnable callback.
CaseConverterResolver	Converts the case of string values.
CaseConverterResolverFactory	`CaseConverterResolver` factory.
Category	Implementation of the Category class for compatibility, despite it having been deprecated a long, long time ago.
CategoryUtil	Provide access to Log4j Core Logger methods.
Chars	Consider this class private.
ClassArbiter	Conditional that determines if the specified class is present.
ClassArbiter.Builder
ClassLoaderContextSelector	This ContextSelector chooses a LoggerContext based upon the ClassLoader of the caller.
ClassNamePatternConverter	Formats the class name of the site of the logging request.
CleanableThreadContextMap	Extension service provider interface to implement additional custom MDC behavior for `ThreadContext`.
Clock	Provides the time stamp used in log events.
ClockFactory	Factory for `Clock` objects.
CloseableThreadContext	Adds entries to the `stack or map` and them removes them when the object is closed, e.g.
CloseableThreadContext.Instance
Closer	Closes resources.
CloseShieldOutputStream	A delegating OutputStream that does not close its delegate.
CloseShieldWriter
CoarseCachedClock	This Clock implementation is similar to CachedClock.
CommandLine	CommandLine interpreter that uses reflection to initialize an annotated domain object with values obtained from the command line arguments.
CommandLine.Command	Annotate your class with `@Command` when you want more control over the format of the generated help message.
CommandLine.DefaultExceptionHandler	Default exception handler that prints the exception message to the specified `PrintStream`, followed by the usage message for the command or subcommand whose input was invalid.
CommandLine.DuplicateOptionAnnotationsException	Exception indicating that multiple fields have been annotated with the same Option name.
CommandLine.ExecutionException	Exception indicating a problem while invoking a command or subcommand.
CommandLine.Help	A collection of methods and inner classes that provide fine-grained control over the contents and layout of the usage help message to display to end users when help is requested or invalid input values were specified.
CommandLine.Help.Ansi	Provides methods and inner classes to support using ANSI escape codes in usage help messages.
CommandLine.Help.Ansi.IStyle	Defines the interface for an ANSI escape sequence.
CommandLine.Help.Ansi.Style	A set of pre-defined ANSI escape code styles and colors, and a set of convenience methods for parsing text with embedded markup style names, as well as convenience methods for converting styles to strings with embedded escape codes.
CommandLine.Help.ColorScheme	All usage help message are generated with a color scheme that assigns certain styles and colors to common parts of a usage message: the command name, options, positional parameters and option parameters.
CommandLine.Help.Column	Columns define the width, indent (leading number of spaces in a column before the value) and Overflow policy of a column in a TextTable.
CommandLine.Help.Column.Overflow	Policy for handling text that is longer than the column width: span multiple columns, wrap to the next row, or simply truncate the portion that doesn't fit.
CommandLine.Help.IOptionRenderer	When customizing online help for `Option` details, a custom `IOptionRenderer` can be used to create textual representation of an Option in a tabular format: one or more rows, each containing one or more columns.
CommandLine.Help.IParameterRenderer	When customizing online help for `Parameters` details, a custom `IParameterRenderer` can be used to create textual representation of a Parameters field in a tabular format: one or more rows, each containing one or more columns.
CommandLine.Help.IParamLabelRenderer	When customizing online usage help for an option parameter or a positional parameter, a custom `IParamLabelRenderer` can be used to render the parameter name or label to a String.
CommandLine.Help.Layout	Use a Layout to format usage help text for options and parameters in tabular format.
CommandLine.Help.TextTable	Responsible for spacing out `CommandLine.Help.Ansi.Text` values according to the `CommandLine.Help.Column` definitions the table was created with.
CommandLine.Help.TextTable.Cell	Helper class to index positions in a `Help.TextTable`.
CommandLine.IExceptionHandler	Represents a function that can handle a `ParameterException` that occurred while parsing the command line arguments.
CommandLine.InitializationException	Exception indicating a problem during `CommandLine` initialization.
CommandLine.IParseResultHandler	Represents a function that can process a List of `CommandLine` objects resulting from successfully parsing the command line arguments.
CommandLine.ITypeConverter<K>	When parsing command line arguments and initializing fields annotated with `@Option` or `@Parameters`, String values can be converted to any type for which a `ITypeConverter` is registered.
CommandLine.MaxValuesforFieldExceededException	Exception indicating that more values were specified for an option or parameter than its `arity` allows.
CommandLine.MissingParameterException	Exception indicating that a required parameter was not specified.
CommandLine.MissingTypeConverterException	Exception indicating that an annotated field had a type for which no `CommandLine.ITypeConverter` was registered.
CommandLine.Option	Annotate fields in your class with `@Option` and picocli will initialize these fields when matching arguments are specified on the command line.
CommandLine.OverwrittenOptionException	Exception indicating that an option for a single-value option field has been specified multiple times on the command line.
CommandLine.ParameterException	Exception indicating something went wrong while parsing command line options.
CommandLine.ParameterIndexGapException	Exception indicating that there was a gap in the indices of the fields annotated with `CommandLine.Parameters`.
CommandLine.Parameters	Fields annotated with `@Parameters` will be initialized with positional parameters.
CommandLine.PicocliException	Base class of all exceptions thrown by `picocli.CommandLine`.
CommandLine.Range	Describes the number of parameters required and accepted by an option or a positional parameter.
CommandLine.RunAll	Command line parse result handler that prints help if requested, and otherwise executes the top-level command and all subcommands as `Runnable` or `Callable`.
CommandLine.RunFirst	Command line parse result handler that prints help if requested, and otherwise executes the top-level `Runnable` or `Callable` command.
CommandLine.RunLast	Command line parse result handler that prints help if requested, and otherwise executes the most specific `Runnable` or `Callable` subcommand.
CommandLine.TypeConversionException	Exception thrown by `CommandLine.ITypeConverter` implementations to indicate a String could not be converted.
CommandLine.UnmatchedArgumentException	Exception indicating that a command line argument could not be mapped to any of the fields annotated with `CommandLine.Option` or `CommandLine.Parameters`.
CommonsCompressAction	Compresses a file using bzip2 compression.
Component	Container for building Configurations.
ComponentBuilder<T extends ComponentBuilder<T>>	Builds arbitrary components and is the base type for the provided components.
CompositeAction	A group of Actions to be executed in sequence.
CompositeConfiguration	A Composite Configuration.
CompositeFilter	Composes and invokes one or more filters.
CompositeFilterComponentBuilder	Wraps multiple Filter Component builders.
CompositeTriggeringPolicy	Triggering policy that wraps other triggering policies.
Configuration	Interface that must be implemented to create a configuration.
ConfigurationAware	Indicates that a class requests the current Configuration to be injected.
ConfigurationBuilder<T extends Configuration>	Interface for building logging configurations.
ConfigurationBuilderFactory	Provides methods to create ConfigurationBuilders.
ConfigurationException	This exception is thrown when an error occurs reading from, parsing, using, or initializing the Log4j 2 configuration.
ConfigurationFactory	Factory class for parsed `Configuration` objects from a configuration file.
ConfigurationFactoryData	Factory Data that carries a configuration.
ConfigurationFileWatcher	Watcher for configuration files.
ConfigurationListener	Interface used to allow components to be notified when the configuration changes.
ConfigurationScheduler
ConfigurationSource	Represents the source for the logging configuration.
ConfigurationStrSubstitutor	`RuntimeStrSubstitutor` is a `StrSubstitutor` which only supports recursive evaluation of lookups.
Configurator	Log4j 1.x Configurator interface.
Configurator	Initializes and configure the Logging system.
ConsoleAppender	Console-appender.
ConsoleAppender	Appends log events to `System.out` or `System.err` using a layout specified by the user.
ConsoleAppender.Builder<B extends ConsoleAppender.Builder<B>>	Builds ConsoleAppender instances.
ConsoleAppender.Target	Enumeration of console destinations.
ConsoleAppenderBuilder	Build a Console Appender
Constants	Log4j Constants.
Constants	Log4j API Constants.
Constraint	Meta annotation to mark an annotation as a validation constraint.
ConstraintValidator<A extends Annotation>	Interface that `Constraint` annotations must implement to perform validation logic.
ConstraintValidators	Utility class to locate an appropriate `ConstraintValidator` implementation for an annotation.
Container	Definition of a Docker Container
ContextAnchor	Anchor for the ThreadContext.
ContextDataFactory	Factory for creating the StringMap instances used to initialize LogEvents' context data.
ContextDataInjector	Responsible for initializing the context data of LogEvents.
ContextDataInjectorFactory	Factory for ContextDataInjectors.
ContextDataProvider	Source of context data to be added to each log event.
ContextMapLookup	Looks up keys from the context.
ContextSelector	Interface used to locate a LoggerContext.
ContextSelectorAdmin	Implementation of the `ContextSelectorAdminMBean` interface.
ContextSelectorAdminMBean	The MBean interface for monitoring and managing the `ContextSelector`.
ContextUtil	Implements LoggerContext methods specific to log4j-core.
ConverterKeys	Identifies the keys that are associated with a PatternConverter.
CopyOnWrite	Marker interface indicating that the implementing class is a copy-on-write data structure.
Core
CoreContextSelectors
CounterResolver	Resolves a number from an internal counter.
CounterResolverFactory	`CounterResolver` factory.
CountingNoOpAppender	No-Operation Appender that counts events.
CronExpression	Provides a parser and evaluator for unix-like cron expressions.
CronScheduledFuture<V>
CronTriggeringPolicy	Rolls a file over based on a cron schedule.
CustomLevelComponentBuilder	Assembler for constructing CustomLevel Components.
CustomLevelConfig	Descriptor of a custom Level object that is created via configuration.
CustomLevels	Container for CustomLevelConfig objects.
CustomLoggerGenerator	Wrapper around `Generate.CustomLogger`.
CyclicBuffer<T>	A bounded buffer containing elements of type T.
DailyRollingFileAppenderBuilder	Build a Daily Rolling File Appender
DatagramOutputStream	OutputStream for UDP connections.
DatagramSocketManager	Socket Manager for UDP connections.
DateLookup	Formats the current date or the date in the LogEvent.
DateParser	DateParser is the "missing" interface for the parsing methods of `DateFormat`.
DatePatternConverter	Converts and formats the event's date in a StringBuilder.
DatePrinter	DatePrinter is the "missing" interface for the format methods of `DateFormat`.
DateTypeConverter	Utility methods for Date classes.
DefaultAdvertiser	The default advertiser does not do anything.
DefaultArbiter	Default Condition for a Select Condition.
DefaultArbiter.Builder
DefaultAsyncQueueFullPolicy	Default router: enqueue the event for asynchronous logging in the background thread, unless the current thread is the background thread and the queue is full (enqueueing would cause a deadlock).
DefaultConfiguration	The default configuration writes all output to the Console using the default logging level.
DefaultConfigurationBuilder<T extends BuiltConfiguration>
DefaultErrorHandler	The default `ErrorHandler` implementation falling back to `StatusLogger`.
DefaultFlowMessageFactory	Default factory for flow messages.
DefaultLogBuilder	Collects data for a log event and then logs it.
DefaultLogEventFactory	Always creates new LogEvent instances.
DefaultLoggerContextAccessor	Default implementation using the Core LoggerContext.
DefaultMergeStrategy	The default merge strategy for composite configurations.
DefaultReliabilityStrategy	Reliability strategy that assumes reconfigurations will never take place.
DefaultRolloverStrategy	When rolling over, `DefaultRolloverStrategy` renames files according to an algorithm as described below.
DefaultRolloverStrategy.Builder	Builds DefaultRolloverStrategy instances.
DefaultShutdownCallbackRegistry	ShutdownRegistrationStrategy that simply uses `Runtime.addShutdownHook(Thread)`.
DefaultThreadContextMap	The actual ThreadContext Map.
DefaultThreadContextStack	A copy-on-write thread-safe variant of `org.apache.logging.log4j.spi.ThreadContextStack` in which all mutative operations (add, pop, and so on) are implemented by making a fresh copy of the underlying list.
DeleteAction	Rollover or scheduled action for deleting old log files that are accepted by the specified PathFilters.
DeletingVisitor	FileVisitor that deletes files that are accepted by all PathFilters.
DenyAllFilter	This filter causes all logging events to be dropped.
DenyAllFilter.Builder
DenyAllFilterBuilder	Build a Pattern Layout
DirectFileRolloverStrategy	Created by rgoers on 1/12/17.
DirectWriteRolloverStrategy	When rolling over, `DirectWriteRolloverStrategy` writes directly to the file as resolved by the file pattern.
DirectWriteRolloverStrategy.Builder	Builds DirectWriteRolloverStrategy instances.
DiscardingAsyncQueueFullPolicy	Discarding router extends the DefaultAsyncQueueFullPolicy by first verifying if the queue is fuller than the specified threshold ratio; if this is the case, log events more specific than the specified threshold level are dropped.
DockerLookup	Lookups up keys for for a Docker container.
DOMConfigurator
DummyNanoClock	Implementation of the `NanoClock` interface that always returns a fixed value.
DummyRecycler<V>
DummyRecyclerFactory
Duration	Simplified implementation of the ISO-8601 Durations standard.
DynamicThresholdFilter	Compares against a log level that is associated with a context value.
Encoder<T>	Objects implementing the `Encoder` interface know how to convert an object to some binary representation and write the result to a `ByteBuffer`, ideally without creating temporary objects.
EncodingPatternConverter	Converter that encodes the output from a pattern using a specified format.
EndOfBatchPatternConverter	Formats the EndOfBatch.
EndOfBatchResolver	`endOfBatch` indicator resolver.
EndOfBatchResolverFactory	`EndOfBatchResolver` factory.
EnglishEnums	Consider this class private.
EntryMessage	Entry flow messages
EnumConverter<E extends Enum<E>>	Converts a `String` into a `Enum`.
EnvironmentLookup	Looks up keys from environment variables.
EnvironmentPropertySource	PropertySource implementation that uses environment variables as a source.
EqualsBaseReplacementConverter	Equals pattern converter.
EqualsIgnoreCaseReplacementConverter	Equals ignore case pattern converter.
EqualsReplacementConverter	Equals pattern converter.
ErrorCode	This interface defines commonly encoutered error codes.
ErrorHandler	Appenders may delegate their error handling to `ErrorHandlers`.
ErrorHandler	Appenders may delegate their error handling to `ErrorHandlers`.
ErrorHandlerAdapter	Makes a Log4j 1 ErrorHandler usable by a Log4j 2 Appender.
EventAdditionalFieldInterceptor	Interceptor to add `additional fields` after event template read.
EventLogger	Logs "Events" that are represented as `StructuredDataMessage`.
EventLookup	Looks up values from the log event.
EventResolver	`TemplateResolver` specialized for `LogEvent`s.
EventResolverContext	`TemplateResolverContext` specialized for `LogEvent`s.
EventResolverContext.Builder
EventResolverFactories	Utility class for `EventResolverFactory`.
EventResolverFactory	`TemplateResolverFactory` specialized for `LogEvent`s.
EventResolverInterceptor	`TemplateResolverInterceptor` specialized for `LogEvent`s.
EventResolverInterceptors	Utility class for `EventResolverInterceptor`.
EventResolverStringSubstitutor	`TemplateResolverStringSubstitutor` specialized for `LogEvent`s.
EventRootObjectKeyInterceptor	Interceptor to add a root object key to the event template.
EventRoute	Enumeration over the different destinations where a log event can be sent.
ExceptionResolver	Exception resolver.
ExceptionResolverFactory	`ExceptionResolver` factory.
ExceptionRootCauseResolver	Exception root cause resolver.
ExceptionRootCauseResolverFactory	`ExceptionRootCauseResolver` factory.
ExcludeChecker	Excludes the listed keys.
ExecutorServices
ExitMessage	Exit flow messages
ExtendedClassInfo	Class and package data used with a `StackTraceElement` in a `ExtendedStackTraceElement`.
ExtendedLogger	Extends the `Logger` interface with methods that facilitate implementing or extending `Logger`s.
ExtendedLoggerGenerator	Wrapper around `Generate.ExtendedLogger`.
ExtendedLoggerWrapper	Wrapper class that exposes the protected AbstractLogger methods to support wrapped loggers.
ExtendedStackTraceElement	Wraps and extends the concept of the JRE's final class `StackTraceElement` by adding more location information.
ExtendedThreadInfoFactory	Factory to create extended thread information.
ExtendedThrowablePatternConverter	Outputs the Throwable portion of the LoggingEvent as a full stack trace unless this converter's option is 'short', where it just outputs the first line of the trace, or if the number of lines to print is explicitly specified.
ExtensionLanguageMapping
Facility	The facility codes used by the Syslog system.
FailoverAppender	The FailoverAppender will capture exceptions in an Appender and then route the event to a different appender.
FailoversPlugin	The array of failover Appenders.
FastDateFormat	FastDateFormat is a fast and thread-safe version of `SimpleDateFormat`.
FastDateParser	FastDateParser is a fast and thread-safe version of `SimpleDateFormat`.
FastDatePrinter	FastDatePrinter is a fast and thread-safe version of `SimpleDateFormat`.
FileAppender	File Appender.
FileAppender.Builder<B extends FileAppender.Builder<B>>	Builds FileAppender instances.
FileAppenderBuilder	Build a File Appender
FileDatePatternConverter	Formats a date by delegating to `DatePatternConverter`.
FileExtension	Enumerates over supported file extensions for compression.
FileLocationPatternConverter	Returns the event's line location information in a StringBuilder.
FileManager	Manages actual File I/O for File Appenders.
FileRenameAction	File rename action.
FileSize	FileSize utility class.
FileUtils	File utilities.
FileWatcher	Watches for changes in a `File` and performs an action when the file is modified.
Filter
Filter	Interface that must be implemented to allow custom event filtering.
Filter.Result	The result that can returned from a filter method call.
Filterable	Interface implemented by Classes that allow filtering to occur.
FilterableComponentBuilder<T extends ComponentBuilder<T>>	Component builder that can add Filters.
FilterAdapter	Binds a Log4j 1.x Filter with Log4j 2.
FilterBuilder	Define a Filter Builder.
FilterComponentBuilder	Assembler for constructing Filter Components.
FilteredObjectInputStream	Extends `ObjectInputStream` to only allow some built-in Log4j classes and caller-specified classes to be deserialized.
FilterWrapper	This acts as a container for Log4j 2 Filters to be attached to Log4j 1 components.
FixedDateFormat	Custom time formatter that trades flexibility for performance.
FixedDateFormat.FixedFormat	Enumeration over the supported date/time format patterns.
FixedDateFormat.FixedTimeZoneFormat	Fixed time zone formats.
FixedPreciseClock	Implementation of the `PreciseClock` interface that always returns a fixed time value.
FlowMessage	Flow messages
FlowMessageFactory	Creates flow messages.
Format	The basic methods for performing date formatting.
FormattedMessage	Handles messages that contain a format String.
FormattedMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
FormattingInfo	Modifies the output of a pattern converter for a specified minimum and maximum width and alignment.
FullLocationPatternConverter	Format the event's line location information.
Generate	Generates source code for custom or extended logger wrappers.
Generate.CustomLogger	Generates source code for custom logger wrappers that only provide convenience methods for the specified custom levels, not for the standard built-in levels.
Generate.ExtendedLogger	Generates source code for extended logger wrappers that provide convenience methods for the specified custom levels, and by extending `org.apache.logging.log4j.spi.ExtendedLoggerWrapper`, inherit the convenience methods for the built-in levels provided by the `Logger` interface.
GzCompressAction	Compresses a file using GZ compression.
HexConverter	Converts Strings to hex.
HierarchyEventListener	Listen to events occurring within a Hierarchy.
HighlightConverter	Highlight pattern converter.
Holder<V>	Deprecated. Use `AtomicReference`.
HostConfig
HtmlLayout	Outputs events as rows in an HTML table on an HTML page.
HtmlLayout.Builder
HtmlLayout.FontSize	Possible font sizes
HtmlLayoutBuilder	Build a Pattern Layout
HtmlTextRenderer	TODO Renders an input as HTML output.
HttpAppender	Sends log events over HTTP.
HttpAppender.Builder<B extends HttpAppender.Builder<B>>	Builds HttpAppender instances.
HttpManager
HttpURLConnectionManager
HttpWatcher
IdlePurgePolicy	Policy is purging appenders that were not in use specified time in minutes
IfAccumulatedFileCount	PathCondition that accepts paths after some count threshold is exceeded during the file tree walk.
IfAccumulatedFileSize	PathCondition that accepts paths after the accumulated file size threshold is exceeded during the file tree walk.
IfAll	Composite `PathCondition` that only accepts objects that are accepted by all component conditions.
IfAny	Composite `PathCondition` that accepts objects that are accepted by any component conditions.
IfFileName	PathCondition that accepts files for deletion if their relative path matches either a glob pattern or a regular expression.
IfLastModified	PathCondition that accepts paths that are older than the specified duration.
IfNot	Wrapper `PathCondition` that accepts objects that are rejected by the wrapped component filter.
IncludeChecker	Includes only the listed keys.
IndexedReadOnlyStringMap	An extension of `ReadOnlyStringMap` that imposes a total ordering on its keys.
IndexedStringMap	An extension of `StringMap` that imposes a total ordering on its keys.
Instant	Models a point in time, suitable for event timestamps.
InstantFormatter	A composite `Instant` formatter trying to employ either `FixedDateFormat`, `FastDateFormat`, or `DateTimeFormatter` in the given order due to performance reasons.
InstantFormatter.Builder
IntegerPatternConverter	Formats an integer.
Integers	Helps deal with integers.
InternalAsyncUtil	Helper class providing some async logging-related functionality.
Interpolator	Proxies all the other `StrLookup`s.
IOUtils	Copied from Apache Commons IO revision 1686747.
IPAMConfig
JAnsiTextRenderer	Renders an input as ANSI escaped output.
JavaLookup	Looks up keys related to Java: Java version, JRE version, VM version, and so on.
JCToolsBlockingQueueFactory<E>	Factory for creating instances of BlockingQueues backed by JCTools `MpscArrayQueue`.
JCToolsBlockingQueueFactory.WaitStrategy
JdkMapAdapterStringMap	Provides a read-only `StringMap` view of a `Map<String, String>`.
JmxRuntimeInputArgumentsLookup	Maps JVM input arguments (but not main arguments) using JMX to acquire JVM arguments.
JndiCloser	Helper class for closing JNDI resources.
JndiContextSelector	This class can be used to define a custom logger repository.
JndiLookup	Looks up keys from JNDI resources.
JndiManager	Manages a JNDI `DirContext`.
JsonConfiguration	Creates a Node hierarchy from a JSON file.
JsonConfigurationFactory
JsonReader	A simple JSON parser mapping tokens to basic Java types.
JsonTemplateLayout
JsonTemplateLayout.Builder
JsonTemplateLayout.EventTemplateAdditionalField
JsonTemplateLayout.EventTemplateAdditionalField.Builder
JsonTemplateLayout.EventTemplateAdditionalField.Format
JsonTemplateLayoutDefaults
JsonUtils	This class is borrowed from Jackson.
JsonWriter	A simple JSON writer with support for common Java data types.
JsonWriter.Builder
KeyStoreConfiguration	Configuration of the KeyStore
KeyStoreConfigurationException
KeyValuePair	Key/Value pair configuration item.
KeyValuePair.Builder
KeyValuePairComponentBuilder	Assembler for constructing KeyValuePair Components.
LambdaUtil	Utility class for lambda support.
LaxHostnameVerifier	An HostnameVerifier which accepts everything.
Layout
Layout<T extends Serializable>	Lays out a LogEvent in different formats.
LayoutAdapter	Class Description goes here.
LayoutBuilder	Define a Layout Builder.
LayoutComponentBuilder	Assembler for constructing Layout Components.
LayoutWrapper	Bridge between the Log4j 1 Layout and a Log4j 2 Layout.
Level	Defines the minimum set of levels recognized by the system, that is `OFF`, `FATAL`, `ERROR`, `WARN`, `INFO`, `DEBUG` and `ALL`.
Level	Levels used for identifying the severity of an event.
LevelMatchFilter	This filter returns the onMatch result if the logging level in the event matches the specified logging level exactly.
LevelMatchFilter.Builder
LevelMatchFilterBuilder	Build a Level match failter.
LevelPatternConverter	Returns the event's level in a StringBuilder.
LevelPatternSelector	Selects the pattern to use based on the Level in the LogEvent.
LevelPatternSelector.Builder	Custom MarkerPatternSelector builder.
LevelRangeFilter	This filter returns the `onMatch` result if the level in the `LogEvent` is in the range of the configured min and max levels, otherwise it returns `onMismatch` value .
LevelRangeFilterBuilder	Build a Level match failter.
LevelResolver	`Level` resolver.
LevelResolverFactory	`LevelResolver` factory.
LifeCycle	All proper Java frameworks implement some sort of object life cycle.
LifeCycle.State	Status of a life cycle like a `LoggerContext`.
LifeCycle2	Extends the LifeCycle interface.
LineLocationPatternConverter	Returns the event's line location information in a StringBuilder.
LineSeparatorPatternConverter	Formats a line separator.
LinkedTransferQueueFactory<E>	Factory for creating instances of `LinkedTransferQueue`.
ListChecker	Class Description goes here.
ListChecker.NoopChecker	Does nothing.
LiteralPatternConverter	Formats a string literal.
Loader	Load resources (or images) from various sources.
LoaderUtil	Consider this class private. Utility class for ClassLoaders.
LocalizedMessage	Provides some level of compatibility with Log4j 1.x and convenience but is not the recommended way to Localize messages.
LocalizedMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
LocationAware	Classes that use location information should implement this interface.
LocationAwareLogEventFactory
LocationAwareLogger	Logger that accepts the location of the caller.
LocationAwareReliabilityStrategy	Interface to ensure delivery of log events to the appropriate Appenders while including location information.
LocationInfo	The internal representation of caller location information.
LockingReliabilityStrategy	ReliabilityStrategy that uses read/write locks to prevent the LoggerConfig from stopping while it is in use.
LockingStringBuilderEncoder	Encoder for StringBuilders that locks on the ByteBufferDestination.
Log4j1Configuration	Class Description goes here.
Log4j1ConfigurationConverter	Tool for converting a Log4j 1.x properties configuration file to Log4j 2.x XML configuration file.
Log4j1ConfigurationConverter.CommandLineArguments
Log4j1ConfigurationFactory	Experimental ConfigurationFactory for Log4j 1.2 properties configuration files.
Log4j1ConfigurationParser	Experimental parser for Log4j 1.2 properties configuration files.
Log4j1MdcPatternConverter	Able to handle the contents of the LogEvent's MDC and either output the entire contents of the properties, or to output the value of a specific key within the property bundle when this pattern converter has the option set.
Log4j1NdcPatternConverter	Returns the event's NDC in a StringBuilder.
Log4j1XmlLayout	Port of XMLLayout in Log4j 1.x.
Log4jContextFactory	Factory to locate a ContextSelector and then load a LoggerContext.
Log4jEntityResolver	An `EntityResolver` specifically designed to return `log4j.dtd` which is embedded within the log4j jar file.
Log4jLog
Log4jLogEvent	Implementation of a LogEvent.
Log4jLogEvent.Builder	LogEvent Builder helper class.
Log4jLogger	SLF4J logger implementation that uses Log4j.
Log4jLoggerFactory	Log4j implementation of SLF4J ILoggerFactory interface.
Log4jLookup	Lookup properties of Log4j
Log4jMarker	Log4j/SLF4J `Marker` type bridge.
Log4jMarkerFactory	Log4j/SLF4J bridge to create SLF4J Markers based on name or based on existing SLF4J Markers.
Log4jMDCAdapter
Log4jProvider	Binding for the Log4j API.
Log4jServletContainerInitializer	In a Servlet 3.0 or newer environment, this initializer is responsible for starting up Log4j logging before anything else happens in application initialization.
Log4jServletContextListener	In environments older than Servlet 3.0, this initializer is responsible for starting up Log4j logging before anything else happens in application initialization.
Log4jServletFilter	This is responsible for the following: Clearing the logger context when the application has finished starting up. Setting the logger context before processing a request and clearing it after processing a request. Setting the logger context when the application is starting to shut down. This filter is a once-per-request filter.
Log4jShutdownOnContextDestroyedListener
Log4jThread	Prefixes thread names with `"Log4j2-"`.
Log4jThreadFactory	Creates `Log4jThread`s.
Log4jWebSupport	Specifies an interface for setting and clearing a thread-bound `LoggerContext` in a Java EE web application.
LogAdapter	Commons Logging adapter registry.
LogBuilder	Interface for constructing log events before logging them.
LogEvent	Provides contextual information about a logged message.
LogEventAdapter	Converts a Log4j 2 LogEvent into the components needed by a Log4j 1.x LoggingEvent.
LogEventFactory
LogEventListener	Base class for server classes that listen to `LogEvent`s.
LogEventPatternConverter	LoggingEventPatternConverter is a base class for pattern converters that can format information from instances of LoggingEvent.
LogEventWrapper	Exposes a Log4j 1 logging event as a Log4j 2 LogEvent.
LogFactoryImpl	Log4j binding for Commons Logging.
LoggableComponentBuilder<T extends ComponentBuilder<T>>	Common component builder for Logger and RootLogger elements.
Logger
Logger	The core implementation of the `Logger` interface.
Logger	This is the central interface in the log4j package.
Logger.LoggerProxy	Serialization proxy class for Logger.
LoggerAdapter<L>	A basic registry for `LoggerContext` objects and their associated external Logger classes.
LoggerComponentBuilder	Assembler for constructing Logger Components.
LoggerConfig	Logger object that is created via configuration.
LoggerConfig.LoggerConfigPredicate
LoggerConfig.RootLogger	The root Logger.
LoggerConfigAdmin	Implementation of the `LoggerConfigAdminMBean` interface.
LoggerConfigAdminMBean	The MBean interface for monitoring and managing a `LoggerConfig`.
LoggerContext	The LoggerContext is the anchor for the logging system.
LoggerContext	Anchor point for logging implementations.
LoggerContextAccessor	Provides access to a Core Logger Context.
LoggerContextAdmin	Implementation of the `LoggerContextAdminMBean` interface.
LoggerContextAdminMBean	The MBean interface for monitoring and managing a `LoggerContext`.
LoggerContextFactory	Implemented by factories that create `LoggerContext` objects.
LoggerContextKey	Deprecated. with no replacement - no longer used
LoggerContextShutdownAware	Interface allowing interested classes to know when a LoggerContext has shutdown - if the LoggerContext implementation provides a way to register listeners.
LoggerContextShutdownEnabled	LoggerContexts implementing this are able register LoggerContextShutdownAware classes.
LoggerFactory	Implement this interface to create new instances of Logger or a sub-class of Logger.
LoggerFields	A LoggerFields container.
LoggerFqcnPatternConverter	Formats the Logger FQCN.
LoggerNameAwareMessage	Message that is interested in the name of the Logger.
LoggerNameLevelRewritePolicy	Rewrites log event levels for a given logger name.
LoggerPatternConverter	Formats a logger name.
LoggerRegistry<T extends ExtendedLogger>	Convenience class to be used by `LoggerContext` implementations.
LoggerRegistry.ConcurrentMapFactory<T extends ExtendedLogger>	Generates ConcurrentHashMaps for use by the registry to store the Loggers.
LoggerRegistry.MapFactory<T extends ExtendedLogger>	Interface to control the data structure used by the registry to store the Loggers.
LoggerRegistry.WeakMapFactory<T extends ExtendedLogger>	Generates WeakHashMaps for use by the registry to store the Loggers.
LoggerRepository	A `LoggerRepository` is used to create and retrieve `Loggers`.
LoggerResolver	Logger resolver.
LoggerResolverFactory	`LoggerResolver` factory.
Loggers
LoggersPlugin	Container of Logger objects.
LoggingEvent	No-op version of Log4j 1.2 LoggingEvent.
LoggingException	Exception thrown when an error occurs while logging.
LogManager
LogManager	The anchor point for the Log4j logging system.
LogManagerStatus	Keeps track of LogManager initialization status;
LowerLookup	Converts values to lower case.
MainMapLookup	A map-based lookup for main arguments.
MainMapResolver	An index-based resolver for the `main()` method arguments.
MainMapResolverFactory	`MainMapResolver` factory.
ManagerFactory<M,T>	Creates Manager objects.
MapAccessor
MapFilter	A Filter that operates on a Map.
MapLookup	A map-based lookup.
MapMessage<M extends MapMessage<M,V>,V>	Represents a Message that consists of a Map.
MapMessage.MapFormat	When set as the format specifier causes the Map to be formatted as XML.
MapPatternConverter	Able to handle the contents of the LogEvent's MapMessage 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 Map.
MapResolver	`MapMessage` resolver.
MapResolverFactory	`MapResolver` factory.
MapRewritePolicy	This policy rewrites events where the message of the original event implements java.util.Map.
MapRewritePolicy	This policy modifies events by replacing or possibly adding keys and values to the MapMessage.
MapRewritePolicy.Mode	An enumeration to identify whether keys not in the MapMessage should be added or whether only existing keys should be updated.
Marker	Markers are objects that are used to add easily filterable information to log messages.
MarkerFilter	This filter returns the onMatch result if the marker in the LogEvent is the same as or has the configured marker as a parent.
MarkerLookup	Looks-up markers.
MarkerManager	Applications create Markers by using the Marker Manager.
MarkerManager.Log4jMarker	Consider this class private, it is only public to satisfy Jackson for XML and JSON IO.
MarkerPatternConverter	Returns events' full marker string in a StringBuilder.
MarkerPatternSelector	Selects the pattern to use based on the Marker in the LogEvent.
MarkerPatternSelector.Builder	Custom MarkerPatternSelector builder.
MarkerResolver	A `Marker` resolver.
MarkerResolverFactory	`MarkerResolver` factory.
MarkerSimpleNamePatternConverter	Appends an event's maker name to a StringBuilder.
MaxLengthConverter	Max length pattern converter.
MDC	This class behaves just like Log4j's MDC would - and so can cause issues with the redeployment of web applications if the Objects stored in the threads Map cannot be garbage collected.
MDCContextMap	Bind the ThreadContextMap to the SLF4J MDC.
MdcPatternConverter	Able to handle the contents of the LogEvent's MDC 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.
MementoMessage	Consider this class private. `MementoMessage` is intended to be used when we need to make an immutable copy of a `Message` without forgetting the original `Message.getFormat()` and `Message.getParameters()` values.
MemoryMappedFileAppender	Memory Mapped File Appender.
MemoryMappedFileAppender.Builder<B extends MemoryMappedFileAppender.Builder<B>>	Builds RandomAccessFileAppender instances.
MemoryMappedFileManager	Extends OutputStreamManager but instead of using a buffered output stream, this class maps a region of a file into memory and writes to this memory region.
MergeStrategy	Merges two configurations together
Message	An interface for various Message implementations that can be logged.
MessageCollectionMessage<T>	A Message that is a collection of Messages.
MessageFactory	Creates messages.
MessageFactory2	Creates messages.
MessageFactory2Adapter	Adapts a legacy MessageFactory to the new MessageFactory2 interface.
MessageFormatMessage	Handles messages that consist of a format string conforming to java.text.MessageFormat.
MessageFormatMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
MessageLayout	Formats a `LogEvent` in its `Message` form.
MessageParameterResolver	`Message` parameter (i.e., `Message.getParameters()`) resolver.
MessageParameterResolverFactory	`MessageParameterResolver` factory.
MessagePatternConverter	Returns the event's rendered message in a StringBuilder.
MessageResolver	`Message` resolver.
MessageResolverFactory
MessageSupplier	Classes implementing this interface know how to supply `Message`s.
MethodLocationPatternConverter	Returns the event's line location information in a StringBuilder.
MimeMessageBuilder	Builder for `MimeMessage` instances.
Mount
MulticastDnsAdvertiser	Advertise an entity via ZeroConf/MulticastDNS and the JmDNS library.
MultiformatMessage	A Message that can render itself in more than one way.
MultiFormatStringBuilderFormattable	A Message that can render itself in more than one way.
MutableInstant	An instantaneous point on the time line, used for high-precision log event timestamps.
MutableLogEvent	Mutable implementation of the `LogEvent` interface.
MutableThreadContextStack	TODO
NameAbbreviator	NameAbbreviator generates abbreviated logger and class names.
NamedContextSelector	ContextSelectors that have a name.
NamePatternConverter	Abstract base class for other pattern converters which can return only parts of their name.
NameUtil
NanoClock	Provides the high-resolution time stamp used in log events.
NanoTimePatternConverter	Converts and formats the event's nanoTime in a StringBuilder.
NDC
NdcPatternConverter	Returns the event's NDC in a StringBuilder.
NetUtils	Networking-related convenience methods.
Network
NetworkSettings
Node	A Configuration node.
NoMarkerFilter	This filter returns the onMatch result if there is no marker in the LogEvent.
NoMarkerFilter.Builder
NoOpThreadContextMap	`ThreadContextMap` implementation used when either of system properties `disableThreadContextMap` or .
NoOpTriggeringPolicy
NotANumber
NullAppender	An Appender that ignores log events.
NullAppenderBuilder	Build a Null Appender
NullConfiguration	This configuration defaults to no logging.
NullEnumeration	An always-empty Enumerator.
NullOutputStream	Writes all data to the famous /dev/null.
ObjectArrayIterator<E>	An `Iterator` over an array of objects.
ObjectArrayMessage	Handles messages that contain an Object[].
ObjectMessage	Handles messages that contain an Object.
ObjectRenderer	Converts objects to Strings.
ObjectThreadContextMap	Extension service provider interface to allow putting Object values in the `ThreadContext`.
OnStartupTriggeringPolicy	Triggers a rollover on every restart, but only if the file size is greater than zero.
OptionConverter	A convenience class to convert property values to specific types.
OptionConverter	A convenience class to convert property values to specific types.
OptionHandler	Log4j 1 Interface for dealing with configuration.
Order	Identifies the relative ordering of a `ConfigurationFactory` plugin.
OrderComparator	Comparator for classes annotated with `Order`.
OutputStreamAppender	Appends log events to a given output stream using a layout.
OutputStreamAppender.Builder<B extends OutputStreamAppender.Builder<B>>	Builds OutputStreamAppender instances.
OutputStreamManager	Manages an OutputStream so that it can be shared by multiple Appenders and will allow appenders to reconfigure without requiring a new stream.
ParameterConsumer<S>	An operation that accepts two input arguments and returns no result.
ParameterizedMessage	Handles messages that consist of a format string containing '{}' to represent each replaceable token, and the parameters.
ParameterizedMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
ParameterizedNoReferenceMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
ParameterVisitable	Allows message parameters to be iterated over without any allocation or memory copies.
PasswordDecryptor	Decrypt passwords.
PasswordProvider	PasswordProvider implementations are able to produce a password from somewhere.
PathCondition	Filter that accepts or rejects a candidate `Path` for deletion.
PathSortByModificationTime	`PathSorter` that sorts path by their LastModified attribute.
PathSorter	Defines the interface of classes that can sort Paths.
PathWithAttributes	Tuple of a `Path` and `BasicFileAttributes`, used for sorting.
PatternConverter	Interface that all PatternConverters must implement.
PatternFormatter
PatternLayout
PatternLayout	A flexible layout configurable with pattern string.
PatternLayout.Builder	Custom PatternLayout builder.
PatternLayout.SerializerBuilder
PatternLayoutBuilder	Build a Pattern Layout
PatternMatch	PatternMatch configuration item.
PatternMatch.Builder
PatternParser	Most of the work of the `PatternLayout` class is delegated to the PatternParser class.
PatternProcessor	Parses the rollover pattern.
PatternResolver	Resolver delegating to `PatternLayout`.
PatternResolverFactory	`PatternResolver` factory.
Patterns	Pattern strings used throughout Log4j.
PatternSelector	Allows different patterns to be used with the PatternLayout based on some selection criteria.
PerformanceSensitive	Indicates that a particular annotated construct was written with certain performance constraints in mind that should be considered when modifying or testing.
PlainTextRenderer	Renders input unchanged.
Plugin	Annotation that identifies a Class as a Plugin.
PluginAliases	Identifies a list of aliases for a `Plugin`, `PluginAttribute`, or `PluginBuilderAttribute`.
PluginAttribute	Identifies a Plugin Attribute and its default value.
PluginAttributeVisitor	PluginVisitor implementation for `PluginAttribute`.
PluginBuilder	Builder class to instantiate and configure a Plugin object using a PluginFactory method or PluginBuilderFactory builder class.
PluginBuilderAttribute	Marks a field as a Plugin Attribute.
PluginBuilderAttributeVisitor	PluginVisitor for PluginBuilderAttribute.
PluginBuilderFactory	Marks a method as a factory for custom Plugin builders.
PluginCache
PluginConfiguration	Identifies a parameter or field as a Configuration.
PluginConfigurationVisitor	PluginVisitor implementation for `PluginConfiguration`.
PluginElement	Identifies a parameter as a Plugin and corresponds with an XML element (or equivalent) in configuration files.
PluginElementVisitor	PluginVisitor implementation for `PluginElement`.
PluginEntry	Memento object for storing a plugin entry to a cache file.
PluginFactory	Identifies a Method as the factory to create the plugin.
PluginManager	Loads and manages all the plugins.
PluginNode	Identifies a Plugin configuration Node.
PluginNodeVisitor	PluginVisitor implementation for `PluginNode`.
PluginProcessor	Annotation processor for pre-scanning Log4j 2 plugins.
PluginRegistry	Registry singleton for PluginType maps partitioned by source type and then by category names.
PluginRegistry.PluginTest	A Test that checks to see if each class is annotated with the 'Plugin' annotation.
PluginType<T>	Plugin Descriptor.
PluginUtil	`Plugin` utilities.
PluginValue	Identifies a parameter as a value.
PluginValueVisitor	PluginVisitor implementation for `PluginValue`.
PluginVisitor<A extends Annotation>	Visitor strategy for parsing data from a `Node`, doing any relevant type conversion, and returning a parsed value for that variable.
PluginVisitors	Utility class to locate an appropriate `PluginVisitor` implementation for an annotation.
PluginVisitorStrategy	Meta-annotation to denote the class name to use that implements `PluginVisitor` for the annotated annotation.
PortDefinition
PosixViewAttributeAction	File posix attribute view action.
PosixViewAttributeAction.Builder	Builder for the posix view attribute action.
PreciseClock	Extension of the `Clock` interface that is able to provide more accurate time information than milliseconds since the epoch.
Priority	Refrain from using this class directly, use the `Level` class instead.
Priority	The Priority used in the Syslog system.
ProcessIdPatternConverter
ProcessIdUtil
PropertiesConfiguration	Construct a configuration based on Log4j 1 properties.
PropertiesConfiguration	Configuration created from a properties file.
PropertiesConfigurationBuilder	Helper builder for parsing properties files into a PropertiesConfiguration.
PropertiesConfigurationFactory	Configures Log4j from a log4j 1 format properties file.
PropertiesConfigurationFactory	Creates a PropertiesConfiguration from a properties file.
PropertiesLookup	A lookup designed for `Properties` defined in the configuration.
PropertiesPlugin	Handles properties defined in the configuration.
PropertiesPropertySource	PropertySource backed by a `Properties` instance.
PropertiesRewritePolicy	This policy modifies events by replacing or possibly adding keys and values to the MapMessage.
PropertiesUtil	Consider this class private.
Property	Represents a key/value pair in the configuration.
PropertyComponentBuilder	Assembler for constructing Property Components.
PropertyConfigurator	A configurator for properties.
PropertyFilePropertySource	PropertySource backed by a properties file.
PropertyRewritePolicy	This policy rewrites events by adding a user-specified list of properties to the event.
PropertySetter	General purpose Object property setter.
PropertySetterException	Thrown when an error is encountered whilst attempting to set a property using the `PropertySetter` utility class.
PropertySource	A source for global configuration properties.
PropertySource.Comparator	Comparator for ordering PropertySource instances by priority.
PropertySource.Util	Utility methods useful for PropertySource implementations.
Protocol	Enumerates the supported protocols.
Provider	Model class for a Log4j 2 provider.
ProviderUtil	Consider this class private. Utility class for Log4j `Provider`s.
PurgePolicy	Policy for purging routed appenders
QueueingRecycler<V>
QueueingRecyclerFactory
QuietWriter	QuietWriter does not throw exceptions when things go wrong.
RandomAccessFileAppender	File Appender.
RandomAccessFileAppender.Builder<B extends RandomAccessFileAppender.Builder<B>>	Builds RandomAccessFileAppender instances.
RandomAccessFileManager	Extends OutputStreamManager but instead of using a buffered output stream, this class uses a `ByteBuffer` and a `RandomAccessFile` to do the I/O.
ReadOnlyStringMap	A read-only collection of String keys mapped to values of arbitrary type.
ReadOnlyThreadContextMap	Read-only view of the data structure that implements MDC behavior for `ThreadContext`.
Reconfigurable	Implemented by Configurations that can be reconfigured at runtime.
Recycler<V>
RecyclerFactories
RecyclerFactory
RecyclerFactoryConverter	The default string (i.e., recycler factory spec) to `RecyclerFactory` type converter.
ReflectionUtil	Utility class for performing common reflective operations.
RegexFilter	This filter returns the onMatch result if the message matches the regular expression.
RegexReplacement	Replace tokens in the LogEvent message.
RegexReplacementConverter	Replacement pattern converter.
RelativeTimePatternConverter	Returns the relative time in milliseconds since JVM Startup.
ReliabilityStrategy	Interface for objects that know how to ensure delivery of log events to the appropriate appenders, even during and after the configuration has been modified while the system is actively used.
ReliabilityStrategyFactory	Factory for ReliabilityStrategies.
RenderedMessage	Implements object rendering for Log4j 1.x compatibility.
RendererSupport	Interface that indicates the Renderer Map is available.
RepeatPatternConverter	Equals pattern converter.
RepositorySelector	The `LogManager` uses one (and only one) `RepositorySelector` implementation to select the `LoggerRepository` for a particular application context.
Required	Marks a plugin builder field or plugin factory parameter as required.
RequiredValidator	Validator that checks an object for emptiness.
ResolverUtil	ResolverUtil is used to locate classes that are available in the/a class path and meet arbitrary conditions.
ResolverUtil.Test	A simple interface that specifies how to test classes to determine if they are to be included in the results produced by the ResolverUtil.
ResourceBundleLookup	Looks up keys from resource bundles.
ReusableLogEventFactory	Garbage-free LogEventFactory that reuses a single mutable log event.
ReusableMessage	Messages implementing this interface are reused between logging calls.
ReusableMessageFactory	Implementation of the `MessageFactory` interface that avoids allocating temporary objects where possible.
ReusableObjectMessage	Mutable Message wrapper around an Object message.
ReusableParameterizedMessage	Reusable parameterized message.
ReusableSimpleMessage	Mutable Message wrapper around a String message.
RewriteAppender	This Appender allows the logging event to be manipulated before it is processed by other Appenders.
RewriteAppenderBuilder	Build an Asynch Appender
RewritePolicy	This interface is implemented to provide a rewrite strategy for RewriteAppender.
RewritePolicy	Interface to be implemented by components that support modifications to the LogEvent.
RewritePolicyAdapter	Binds a Log4j 1.x RewritePolicy to Log4j 2.
RewritePolicyBuilder	Define a RewritePolicy Builder.
RewritePolicyWrapper	Binds a Log4j 2 RewritePolicy to Log4j 1.
Rfc1349TrafficClass	Enumerates the RFC 1349 TOS field.
Rfc5424Layout	Formats a log event in accordance with RFC 5424.
RingBufferAdmin	Instruments an LMAX Disruptor ring buffer.
RingBufferAdminMBean	The MBean interface for monitoring and managing an LMAX Disruptor ring buffer.
RingBufferLogEvent	When the Disruptor is started, the RingBuffer is populated with event objects.
RingBufferLogEventHandler	This event handler gets passed messages from the RingBuffer as they become available.
RingBufferLogEventTranslator	This class is responsible for writing elements that make up a log event into the ringbuffer `RingBufferLogEvent`.
RollingFileAppender	An appender that writes to files and can roll over at intervals.
RollingFileAppender.Builder<B extends RollingFileAppender.Builder<B>>	Builds FileAppender instances.
RollingFileAppenderBuilder	Build a File Appender
RollingFileManager	The Rolling File Manager.
RollingRandomAccessFileAppender	An appender that writes to random access files and can roll over at intervals.
RollingRandomAccessFileAppender.Builder<B extends RollingRandomAccessFileAppender.Builder<B>>
RollingRandomAccessFileManager	Extends RollingFileManager but instead of using a buffered output stream, this class uses a `ByteBuffer` and a `RandomAccessFile` to do the I/O.
RolloverDescription	Description of actions needed to complete rollover.
RolloverDescriptionImpl	Description of actions needed to complete rollover.
RolloverFrequency	Enumeration of rollover frequency values.
RolloverListener	Implementations of this interface that are registered with the RollingFileManager will be notified before and after a rollover occurs.
RolloverStrategy	A `RollingPolicy` specifies the actions taken on a logging file rollover.
RootLoggerComponentBuilder	Assembler for constructing the root Logger Components.
RootThrowablePatternConverter	Outputs the Throwable portion of the LoggingEvent as a full stack trace unless this converter's option is 'short', where it just outputs the first line of the trace, or if the number of lines to print is explicitly specified.
Route	A Route to an appender.
Routes	Contains the individual Route elements.
Routes.Builder
RoutingAppender	This Appender "routes" between various Appenders, some of which can be references to Appenders defined earlier in the configuration while others can be dynamically created within this Appender as required.
RoutingAppender.Builder<B extends RoutingAppender.Builder<B>>
RuntimeStrSubstitutor	`RuntimeStrSubstitutor` is a `StrSubstitutor` which only supports evaluation of top-level lookups.
Scheduled	Annotation that identifies a Class as requiring a Scheduled thread.
Script	Container for the language and body of a script.
ScriptAppenderSelector
ScriptAppenderSelector.Builder	Builds an appender.
ScriptArbiter	Condition that evaluates a script.
ScriptArbiter.Builder
ScriptComponentBuilder	Assembler for constructing Layout Components.
ScriptCondition	A condition of the `DeleteAction` where a user-provided script selects the files to delete from a provided list.
ScriptFile	Container for the language and body of a script file along with the file location.
ScriptFileComponentBuilder	Assembler for constructing ScriptFile Components.
ScriptFilter	Returns the onMatch result if the script returns True and returns the onMismatch value otherwise.
ScriptManager	Manages the scripts use by the Configuration.
ScriptPatternSelector	Selects the pattern to use based on the result of executing a Script.
ScriptPatternSelector.Builder	Custom ScriptPatternSelector builder.
ScriptRef	Contains a reference to a script defined elsewhere in the configuration.
ScriptsPlugin	A container of Scripts.
SecretKeyProvider	Factory class to provide a `SecretKey` instance.
SelectArbiter	Class Description goes here.
SelectArbiter.Builder
SequenceNumberPatternConverter	Formats the event sequence number.
SerializedLayout	Deprecated. Java Serialization has inherent security weaknesses, see https://www.owasp.org/index.php/Deserialization_of_untrusted_data .
Server	Creates MBeans to instrument various classes in the log4j class hierarchy.
ServletAppender	Logs using the ServletContext's log method
ServletAppender.Builder<B extends ServletAppender.Builder<B>>
ServletRequestThreadContext
Severity	Severity values used by the Syslog system.
ShutdownCallbackRegistry	Registry used for Runnable shutdown callback instances.
SimpleLayout	Simple-layout.
SimpleLayoutBuilder	Build a Pattern Layout
SimpleLogger	This is the default logger that is used when no suitable logging implementation is available.
SimpleLoggerContext
SimpleLoggerContextFactory
SimpleMessage	The simplest possible implementation of Message.
SimpleMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
SizeBasedTriggeringPolicy
SLF4JLogger
SLF4JLoggerContext
SLF4JLoggerContextFactory
SLF4JLoggingException	Exception thrown when the SLF4J adapter encounters a problem.
SLF4JProvider	Bind the Log4j API to SLF4J.
SmtpAppender	Send an e-mail when a specific logging event occurs, typically on errors or fatal errors.
SmtpAppender.Builder
SmtpManager	Manager for sending SMTP events.
SocketAddress	Plugin to hold a hostname and port (socket address).
SocketAddress.Builder
SocketAppender	An Appender that delivers events over socket connections.
SocketAppender.AbstractBuilder<B extends SocketAppender.AbstractBuilder<B>>	Subclasses can extend this abstract Builder.
SocketAppender.Builder	Builds a SocketAppender.
SocketOptions	Holds all socket options settable via `Socket` methods.
SocketPerformancePreferences	Holds all socket options settable via `Socket.setPerformancePreferences(int, int, int)`.
SortedArrayStringMap	Consider this class private. Array-based implementation of the `ReadOnlyStringMap` interface.
SortingVisitor	FileVisitor that sorts files.
Source	Represents the source for the logging configuration.
SourceResolver	Resolver for the `StackTraceElement` returned by `LogEvent.getSource()`.
SourceResolverFactory	`SourceResolver` factory.
SslConfiguration	SSL Configuration
SslConfigurationDefaults
SslConfigurationException
SslConfigurationFactory	Creates an SSL configuration from Log4j properties.
SslSocketManager
StackLocator	Consider this class private. Provides various methods to determine the caller class.
StackLocatorUtil	Consider this class private. Provides various methods to determine the caller class.
StandardLevel	Standard Logging Levels as an enumeration for use internally.
StaticLoggerBinder	SLF4J LoggerFactoryBinder implementation using Log4j.
StaticMarkerBinder	SLF4J MarkerFactoryBinder implementation using Log4j.
StaticMDCBinder
StatusConfiguration	Configuration for setting up `StatusConsoleListener` instances.
StatusConfiguration.Verbosity	Specifies how verbose the StatusLogger should be.
StatusConsoleListener	StatusListener that writes to the Console.
StatusData	The Status data.
StatusListener	Interface that allows implementers to be notified of events in the logging system.
StatusLogger	Records events that occur in the logging system.
StatusLoggerAdmin	Implementation of the `StatusLoggerAdminMBean` interface.
StatusLoggerAdminMBean	The MBean interface for monitoring and managing the `StatusLogger`.
StoreConfiguration<T>
StoreConfigurationException
StringBuilderEncoder	Encoder for StringBuilders that uses ThreadLocals to avoid locking as much as possible.
StringBuilderFormattable	Objects that implement this interface can be converted to text, ideally without allocating temporary objects.
StringBuilders	Consider this class private.
StringBuilderWriter	`Writer` implementation that outputs to a `StringBuilder`.
StringEncoder	Encodes Strings to bytes.
StringFormattedMessage	Handles messages that consist of a format string conforming to `Formatter`.
StringFormatterMessageFactory	Creates `FormattedMessage` instances for `MessageFactory2` methods (and `MessageFactory` by extension.)
StringLayout	Instantiates the @{link Layout} type for String-based layouts.
StringMap	Exposes methods to add and remove key-value pairs to and from `ReadOnlyStringMap`.
StringMapMessage	A `StringMapMessage` typed to `String`-only values.
StringMatchFilter	This filter returns the onMatch result if the logging level in the event matches the specified logging level exactly.
StringMatchFilter.Builder
StringMatchFilterBuilder	Build a String match filter.
StringParameterParser
StringParameterParser.DoubleQuotedStringValue
StringParameterParser.NullValue
StringParameterParser.StringValue
StringParameterParser.Value
StringParameterParser.Values
Strings	Consider this class private.
StrLookup	Lookup a String key to a String value.
StrMatcher	A matcher class that can be queried to determine if a character array portion matches.
StrSubstitutor	Substitutes variables within a string by values.
StructuredDataCollectionMessage	A collection of StructuredDataMessages.
StructuredDataFilter	Filter based on data in a StructuredDataMessage.
StructuredDataId	The StructuredData identifier.
StructuredDataLookup	Looks up keys from `StructuredDataMessage` log messages.
StructuredDataMessage	Represents a Message that conforms to an RFC 5424 StructuredData element along with the syslog message.
StructuredDataMessage.Format	Supported formats.
StyleConverter	Style pattern converter.
Supplier<T>	Consider this class private. Classes implementing this interface know how to supply a value.
SyslogAppender	The Syslog Appender.
SyslogAppender.Builder<B extends SyslogAppender.Builder<B>>
SyslogAppenderBuilder	Build a File Appender
SyslogLayout	Formats a log event as a BSD Log record.
SyslogLayout.Builder<B extends SyslogLayout.Builder<B>>	Builds a SyslogLayout.
SystemClock	Implementation of the `Clock` interface that returns the system time.
SystemMillisClock	Implementation of the `Clock` interface that returns the system time in millisecond granularity.
SystemNanoClock	Implementation of the `NanoClock` interface that returns the system nano time.
SystemPropertiesLookup	Looks up keys from system properties.
SystemPropertiesPropertySource	PropertySource backed by the current system properties.
SystemPropertyArbiter	Condition that determines if the specified property is set.
SystemPropertyArbiter.Builder
TcpSocketManager	Manager of TCP Socket connections.
TcpSocketManager.HostResolver
TcpSocketManager.TcpSocketManagerFactory<M extends TcpSocketManager,T extends org.apache.logging.log4j.core.net.TcpSocketManager.FactoryData>	Factory to create a TcpSocketManager.
TemplateResolver<V>
TemplateResolverConfig	Accessor to the resolver configuration JSON object read from the template.
TemplateResolverFactories	Utility class for `TemplateResolverFactory`.
TemplateResolverFactory<V,C extends org.apache.logging.log4j.layout.template.json.resolver.TemplateResolverContext<V,C>>	`TemplateResolver` factory.
TemplateResolverInterceptor<V,C extends org.apache.logging.log4j.layout.template.json.resolver.TemplateResolverContext<V,C>>	Main `TemplateResolver` compilation interception interface.
TemplateResolverInterceptors	Utility class for `TemplateResolverInterceptor`.
TemplateResolvers	Main class for compiling `TemplateResolver`s from a template.
TemplateResolverStringSubstitutor<V>	A contextual `StrSubstitutor` abstraction.
Terminable	Interface to be implemented by LoggerContext's that provide a shutdown method.
TextEncoderHelper	Helper class to encode text to binary data without allocating temporary objects.
TextRenderer	Renders an input to an output.
ThreadContext	The ThreadContext allows applications to store information either in a Map or a Stack.
ThreadContext.ContextStack	The ThreadContext Stack interface.
ThreadContextDataInjector	`ThreadContextDataInjector` contains a number of strategies for copying key-value pairs from the various `ThreadContext` map implementations into a `StringMap`.
ThreadContextDataInjector.ForCopyOnWriteThreadContextMap	The `ContextDataInjector` used when the ThreadContextMap implementation is a copy-on-write StringMap-based data structure.
ThreadContextDataInjector.ForDefaultThreadContextMap	Default `ContextDataInjector` for the legacy `Map<String, String>`-based ThreadContext (which is also the ThreadContext implementation used for web applications).
ThreadContextDataInjector.ForGarbageFreeThreadContextMap	The `ContextDataInjector` used when the ThreadContextMap implementation is a garbage-free StringMap-based data structure.
ThreadContextDataProvider	ContextDataProvider for ThreadContext data.
ThreadContextDataResolver	Mapped Diagnostic Context (MDC), aka.
ThreadContextDataResolverFactory	`ThreadContextDataResolver` factory.
ThreadContextMap	Service provider interface to implement custom MDC behavior for `ThreadContext`.
ThreadContextMap2	Extension service provider interface to implement additional custom MDC behavior for `ThreadContext`.
ThreadContextMapFactory	Creates the ThreadContextMap instance used by the ThreadContext.
ThreadContextMapFilter	Filter based on a value in the Thread Context Map (MDC).
ThreadContextStack	Service provider interface to implement custom NDC behavior for `ThreadContext`.
ThreadContextStackResolver	Nested Diagnostic Context (NDC), aka.
ThreadContextStackResolverFactory	`ThreadContextStackResolver` factory.
ThreadDumpMessage	Captures information about all running Threads.
ThreadDumpMessage.ThreadInfoFactory	Factory to create Thread information.
ThreadGroupRenderer
ThreadIdPatternConverter	Formats the event thread ID.
ThreadInformation	Interface used to print basic or extended thread information.
ThreadLocalRecycler<V>
ThreadLocalRecyclerFactory
ThreadNameCachingStrategy	Strategy for deciding whether thread name should be cached or not.
ThreadNamePatternConverter	Formats the event thread name.
ThreadPriorityPatternConverter	Formats the event thread priority.
ThreadResolver	Thread resolver.
ThreadResolverFactory	`ThreadResolver` factory.
ThresholdFilter	This filter returns the onMatch result if the level in the LogEvent is the same or more specific than the configured level and the onMismatch value otherwise.
ThrowableFormatOptions	Contains options which control how a `Throwable` pattern is formatted.
ThrowableInformation	Class Description goes here.
ThrowablePatternConverter	Outputs the Throwable portion of the LoggingEvent as a full stack trace unless this converter's option is 'short', where it just outputs the first line of the trace, or if the number of lines to print is explicitly specified.
ThrowableProxy	Wraps a Throwable to add packaging information about each stack trace element.
Throwables	Helps with Throwable objects.
TimeBasedTriggeringPolicy	Rolls a file over based on time.
TimeBasedTriggeringPolicy.Builder
TimeFilter	Filters events that fall within a specified time period in each day.
Timer	Primarily used in unit tests, but can be used to track elapsed time for a request or portion of any other operation so long as all the timer methods are called on the same thread in which it was started.
Timer.Status
TimestampMessage	Messages that use this interface will cause the timestamp in the message to be used instead of the timestamp in the LogEvent.
TimestampResolver	Timestamp resolver.
TimestampResolverFactory	`TimestampResolver` factory.
TlsSyslogFrame	Wraps messages that are formatted according to RFC 5425.
Transform	Utility class for transforming strings.
TriConsumer<K,V,S>	An operation that accepts three input arguments and returns no result.
TriggeringPolicy	A `TriggeringPolicy` controls the conditions under which rollover occurs.
TruncatingBufferedPrintWriter
TrustStoreConfiguration	Configuration of the TrustStore
TrustStoreConfigurationException
TTCCLayoutBuilder	Build a Pattern Layout
TypeConverter<T>	Interface for doing automatic String conversion to a specific type.
TypeConverterRegistry	Registry for `TypeConverter` plugins.
TypeConverters	Collection of basic TypeConverter implementations.
TypeConverters.BigDecimalConverter	Parses a `String` into a `BigDecimal`.
TypeConverters.BigIntegerConverter	Parses a `String` into a `BigInteger`.
TypeConverters.BooleanConverter	Converts a `String` into a `Boolean`.
TypeConverters.ByteArrayConverter	Converts a `String` into a `byte[]`.
TypeConverters.ByteConverter	Converts a `String` into a `Byte`.
TypeConverters.CharacterConverter	Converts a `String` into a `Character`.
TypeConverters.CharArrayConverter	Converts a `String` into a `char[]`.
TypeConverters.CharsetConverter	Converts a `String` into a `Charset`.
TypeConverters.ClassConverter	Converts a `String` into a `Class`.
TypeConverters.CronExpressionConverter
TypeConverters.DoubleConverter	Converts a `String` into a `Double`.
TypeConverters.DurationConverter	Converts a `String` into a `Duration`.
TypeConverters.FileConverter	Converts a `String` into a `File`.
TypeConverters.FloatConverter	Converts a `String` into a `Float`.
TypeConverters.InetAddressConverter	Converts a `String` into an `InetAddress`.
TypeConverters.IntegerConverter	Converts a `String` into a `Integer`.
TypeConverters.LevelConverter	Converts a `String` into a Log4j `Level`.
TypeConverters.LongConverter	Converts a `String` into a `Long`.
TypeConverters.PathConverter	Converts a `String` into a `Path`.
TypeConverters.PatternConverter	Converts a `String` into a `Pattern`.
TypeConverters.SecurityProviderConverter	Converts a `String` into a `Provider`.
TypeConverters.ShortConverter	Converts a `String` into a `Short`.
TypeConverters.StringConverter	Returns the given `String`, no conversion takes place.
TypeConverters.UriConverter	Converts a `String` into a `URI`.
TypeConverters.UrlConverter	Converts a `String` into a `URL`.
TypeConverters.UuidConverter	Converts a `String` into a `UUID`.
TypeUtil	Utility class for working with Java `Type`s and derivatives.
Unbox	Utility for preventing primitive parameter values from being auto-boxed.
UnrecognizedElementHandler	When implemented by an object configured by DOMConfigurator, the handle method will be called when an unrecognized child element is encountered.
UpperLookup	Converts values to upper case.
Uris
UrlConnectionFactory	Constructs an HTTPURLConnection.
UuidPatternConverter	Formats the event sequence number.
UuidUtil	Generates a unique ID.
ValidHost	Indicates that a plugin attribute must be a valid host.
ValidHostValidator	Validator that checks an object to verify it is a valid hostname or IP address.
ValidPort	Indicates that a plugin attribute must be a valid port number.
ValidPortValidator	Validator that checks an object to verify it is a valid port number (an integer between 0 and 65535).
VariablesNotEmptyReplacementConverter	VariablesNotEmpty pattern converter.
Version
Watcher	Watches for changes in a Source and performs an action when it is modified.
WatcherFactory	Creates Watchers of various types.
WatchEventService
WatchManager	Manages `FileWatcher`s.
WebLoggerContextUtils	Convenience methods for retrieving the `LoggerContext` associated with a particular ServletContext.
WebLookup
WrappedFileWatcher
WriterAppender	WriterAppender appends log events to a `Writer` or an `OutputStream` depending on the user's choice.
WriterAppender	Appends log events to a `Writer`.
WriterAppender.Builder<B extends WriterAppender.Builder<B>>	Builds WriterAppender instances.
WriterManager	Manages a Writer so that it can be shared by multiple Appenders and will allow appenders to reconfigure without requiring a new writer.
XmlConfiguration	Class Description goes here.
XmlConfiguration	Creates a Node hierarchy from an XML file.
XmlConfigurationFactory	Constructs a Configuration usable in Log4j 2 from a Log4j 1 configuration file.
XmlConfigurationFactory	Factory to construct an XmlConfiguration.
ZipCompressAction	Compresses a file using Zip compression.