An AsyncLogger instance can wrap any other logger, causing log entries to be written asynchronously in a background thread

A CompositeLogger contains other Logger instances.

ConfigLogger is a self-configuring (by reading the config file) CompositeLogger subclass

DebugLogger encapsulates logging to System.Diagnostics.Debug in a Logger.

DelegatableLogger can be used to easily create a logger to which will use a given delegate to actually do the logging.

An EmailLogger sends log information via an email message.

EventLogLogger writes log entries to the Windows Event Log

Summary description for FileLogger.

Wrap instances of this class around any other logger. If the wrapped logger fails to successfully log an entry, then this instance will keep trying to log the entry.

Represents an entry that gets logged by a Logger.

Instances filter LogEntries based on their categories.

Concrete subclasses of this abstract class are used by loggers to "filter" each item and decide whether or not to actually log it.

A LogEntryFormatter subclass that works like the string.Format() method. Instead of using an index for the parameter, use certain reserved names, such as: application machine category severity timestamp message eg. "{timestamp:G}..{severity}..{message}"

Concrete subclasses of this abstract class are responsible for formatting LogEntries.

This formatter is concerned only with a LogEntry's message, ignoring all other information

This Filter "passes" all LogEntries.

This class formats strings using a format string with named parameters, with data from a LogEntry. variables to replace are: application machine category severity timestamp message A format string might look like: "{timestamp:G}..{severity}..{message}"

This formatter is the default one that formats all LogEntry information in a reasonable way.

Concrete subclasses of this abstract class do the actual logging of information to their respective "logs."

Class to support errors that occur during logging

LoggerTester can be used to test Loggers.

This class can be used as a convenient base class when creating a logger that receives LogEntries over a Socket.

Instances of this class are used to create instances of LogReceiverLogger subclasses when socket connections are made to clients sending LogEntry information.

An Exception class thrown when an invalid Logger is used with LogReceiverLoggerFactory.

An instance of LogSocketReader reads serialized LogEntries from a socket and subsequently logs the LogEntries to its respective logger.

Inner class used for listening for connections.

Instances store LogEntries in memory.

Instances of this class can be used as placeholders where the actual logger is not yet known. Notice that the only difference between this class and its superclass is that this class is not abstract.

RollingFileLogger can be used to automatically roll-over files by any determination. It does not delete old log files, it just creates new log files as required.

RollOverDateStrategy provides date-based roll-over functionality.

This class is a general replacement for RollOverDateStrategy. It can replicate RollOverDateStrategy simply by using a format string like "MyLog_{timestamp:yyydMMdd}.log" This class can be used to put items of different categories into different files also, using a format string like: "MyLog_{category}.log"

RollOverSizeStrategy provides log file size-based roll-over functionality

RollOverStrategy is an abstract class that defines the basic functionality required by a RollingFileLogger to roll-over.

Instances of SerialLogger write out serialized LogEntries to it's OutputStream

Instances of SerialSocketLogger write out serialized LogEntries to a Socket

Instances of TextWriterLogger write LogEntry information to a TextWriter.

TraceLogger encapsulates logging to System.Diagnostics.Trace in a Logger

Implementers of this interface are sent the ReaderReady message when a client logger has made a connection to LogSocketReader.Listener

This is a delegate used to handle writing log entries based on the LogEntry

This is a delegate used to handle writing log entries based in the string to be written to the log

A delegate that can be used by satelite classes to trigger the LoggingError event

The set of items that can be formatted

Represent severities of LogEntries.