Package com.antelmann.util.logging

This package contains classes that implement a custom logging for this framework - separate from java.util.logging.

See:
Description

Interface Summary

LogEntryFormatter<T>	allows for several LogWriters to share the same formatting
LogExceptionHandler	A LogExceptionHandler is used to control the behavior of a Logger in regards to occuring LogException events.
LoggerProvider	denotes a class that provides a suitable Logger for itself that allows to log data within the context of the implementing class.
LogWriter	The LogWriter interface defines objects that can be used as a handler for the Logger class.

Class Summary

AbstractExceptionWriter	an abstract class to handle exceptions that occur in a LogEntry.
AbstractLogWriter<T>	provides filtering capabilities for a LogWriter.
AppendableLogWriter	writes to a given Appendable (PrintStream, StringBuffer, etc) using a String
AsynchLogWriter	allows to operate any LogWriter asynchronously.
BinaryFileLog	A LogWriter that logs the entries synchronously serialized to a file.
BinaryLogFormatter	formats the LogEntry as a serialized byte array.
ConsoleLog	ConsoleLog prints abbreviated log messages to the console using System.out.println().
DBLineLogFormatter	formats a LogEntry into a format that can be easily imported into databases.
EmailWriter	uses email to send each LogEntry object over the Internet.
ExceptionDialogWriter	shows a dialog upon each Throwable encountered.
FileLog	writes entries to a file without continuously holding a lock on the file.
JDBCLogWriter	JDBCLogWriter provides a LogWriter that writes to a java.sql.Connection.
JTextAreaLog	a more efficient visible log as it uses JTextArea methods to append the text
JTextComponentLog	JTextComponentLog writes abbreviated log messages into a given JTextComponent synchronously.
Level	Level classifies the logging of LogEntry objects.
LevelFilter	filters LogEntry objects by their level using the natural order of Level objects
LogEntry	LogEntry represents a single record of a log logged by a Logger object and handled by a LogWriter object.
LogFile	LogFile provides great convenience for logging information from a program into a file.
Logger	Logger somewhat leans on the functionality of the java.util.logging functionality of J2SE 1.4, but it's not quite the same (and was implemented before J2SE 1.4).
LoggerCache	provides a simple mechanism to cache LogEntries from a Logger
LoggerHandler	provides a bridge to the java.util.logging facility
LoggerManager	a central point to manager different Logger instances
LoggerWriter	provides a writer that propagates the LogEntries to another logger
LogNetPropagator	can be registered to listen logging events and then propagates them as serialized byte arrays over its NetConnectionServer.
LogNetReceiver	can be used to easily listen to a LogNetPropagator; most easily used in conjunction with a MessageDispatcher.
MemoryLogger	allows to monitor memory usage through a Logger.
SocketLogListener	used to listen to LogEntry objects send through a NetConnection.
SocketWriter	simply used to write serialized LogEntry objects via network
StackTraceFileWriter	writes full stack trace of entries that log an exception to a given file.
StringLineFormatter	formats a LogEntry into a simple one-line String terminated by a line break.
XMLLogFormatter	formats LogEntry objects as XML.
XMLLogWriter	writes LogEntry objects formatted as XML to either a PrintStream or PrintWriter.

Exception Summary

LogException

LogException is thrown when a problem is encountered while writing to a LogWriter

Package com.antelmann.util.logging Description

This package contains classes that implement a custom logging for this framework - separate from java.util.logging.

The classes in this package have been implemented prior to J2SE 1.4 when java.util.logging became available. However, they have been slightly changed since then and were finally put in this package (as they were in com.antelmann.util before), so that they are kept separate.

One difference between this com.antelmann.util.logging and java.util.logging is that this logging here can be synchronous, i.e. the log entry may be flushed to its destination every time before any of the logging methods return - done at the discretion of any given LogWriter object. Also, exceptions that may occur can be propagated into the thread that called the log method (alternatively, this can be handled by setting up a separate exception handler). In addition, the log entry here can include a full stack trace of the occurrence. Finally, this logging facility is somewhat simpler (naturally, as it is not as complex).

There are of course many more differences, but the above is the main thing.