All Classes and Interfaces
Class
Description
Some basic plumbing for Preference related dialogs.
Net based entities that 'work with' an Address
should consider implementing this
interface so that they can be treated generically.
Encapsulates the Chainsaw Application wide properties
A panel used by the user to modify any application-wide preferences.
Helper class that helps delegate the work of loading and saving the values
of the ApplicationPreferenceModel, allowing that class to remain a simple
bean.
All of the Preferences panels used in this class extend from
this, it is used to provide standard L&F required by all.
A simple About box telling people stuff about this project
ChainsawAppender receives LoggingEvents from the local
Log4J environment, and appends them into a model that
can be used inside a Swing GUI
A handler class that either extends a particular appender hierarchy or can be
bound into the Log4j appender framework, and queues events, to be later
dispatched to registered/interested parties.
Constants used throught Chainsaw.
A CyclicBuffer implementation of the EventContainer.
A container class that contains a group of events split up
into branches based on Identifiers
A simple splash screen to be used at startup, while everything get's initialized.
A general purpose status bar for all Frame windows
The only reason this class is needed is because
of a stupid 'issue' with the JTabbedPane.
Encapsulates the full Toolbar, and menus and all the actions that can be performed from it.
Chainsaw compatible gui viewers must implement this interface
in order to be opened and configured by the ChainsawAppender class.
A ListCellRenderer that display a check box if the value
has been "checked".
Given a LoggingEvent, can determine an appropriate
Color to use based on whatever this implementation
has been coded.
Panel which updates a RuleColorizer, allowing the user to build expression-based
color rules.
A common interface shared by log4j components.
Most log4j components derive from this class.
The
ConnectionSource interface provides a pluggable means of
transparently obtaining JDBC Connections for log4j classes
that require the use of a Connection.Constants used internally throughout log4j.
Converts log data stored in a database into LoggingEvents.
CyclicBuffer implementation that is Object generic, and implements the List interface.
The DataSourceConnectionSource is an implementation of
ConnectionSource
that obtains the Connection in the recommended JDBC manner based on
a DataSource.The DBAppender inserts loggin events into three database tables in a format
independent of the Java programming language.
Actual retrieval of data is made by the instance of DBReceiverJob associated
with DBReceiver.
Allow LoggingEvents to be reconstructed from a different format
(usually XML).
Factory class to load and cache Layout information from resources.
Extends the functionality of a JPanel by providing a 'docked' state.
The DriverManagerConnectionSource is an implementation of
ConnectionSource
that obtains the Connection in the traditional JDBC manner based on the
connection URL.Used to store special log4j errors which cannot be logged using internal
logging.
Implementations of this interface like to be notified
of arriving batches of LoggingEvents, but may only
be interested in those coming from a particular source
To allow pluggable TableModel implementations for Chainsaw, this interface has been factored out.
Listeners can be notified when the # of events in a particular model
changes
This layout is used for formatting HTML text for use inside
the Chainsaw Event Detail Panel, and the tooltip used
when mouse-over on a particular log event row.
A Container class used to hold unique LoggingEvent values
and provide them as unique ListModels.
A popup menu which assists in building expression rules.
This class provides all the functionality to work out when files are dragged onto
a particular JComponent instance, and then notifies listeners via
the standard PropertyChangesListener semantics to indicate that a list of
files have been dropped onto the target.
Allows the user to specify a particular file to open and import the events
into a new tab.
The complete File Menu for the main GUI, containing
the Load, Save, Close Welcome Tab, and Exit actions
Allows the user to specify a particular file to which the current tab's
displayed events will be saved.
This class is used as a Model for Filtering, and retains the unique entries that
come through over a set of LoggingEvents
Class designed to stress, and/or test the Chainsaw GUI by sending it
lots of Logging Events.
A BeanInfo class to be used as meta-data about the
Generator plugin
A helper class that assists the HelpManager by serving as a collection of
Class loaders based on URL roots.
Singleton help manager where objects can register to display
Help for something, an independant viewer can register to
be notified when the requested Help URL changes and can display
it appropriately.
The HSQLDB dialect.
JMSReceiver receives a remote logging event on a configured
JSM topic and "posts" it to a LoggerRepository as if the event was
generated locally.
BeanInfo class for the JMSReceiver.
The
JNDIConnectionSource is an implementation of
ConnectionSource that obtains a DataSource from a
JNDI provider and uses it to obtain a Connection.Job is a very simple interface.
A Sortable JTable implementation that allows a user to click on a
specific Column and have the row information sorted by that column.
Apply system font and size (normal size + 1) rule if the JEditorPane document contains html.
An editor Pane that allows a user to Edit a Pattern Layout and preview the output it would
generate with an example LoggingEvent
A simple factory/facade for creating some of the standard Icons that are based
on line drawings
A nice and simple 'X' style icon that is used to indicate a 'close' operation.
A nice and simple 'X' style icon that is used to indicate a 'close' operation.
A very basic appender that takes the events and stores them in to a
ListModel for late retrieval.
An implementation of ULogger on org.apache.log4j.Logger.
LogFilePatternReceiver can parse and tail log files, converting entries into
LoggingEvents.
BeanInfo class for the meta-data of the LogFilePatternReceiver.
LogFileXMLReceiver will read an xml-formated log file and make the events in the log file
available to the log4j framework.
Interface used to listen for Logger related events such as
add/remove appender or changing levels.
Implementations are notified when new Logger names
are added to the related LoggerNameModel instance.
Implementations of this model contain all the known Logger
names within it's model space.
An implementation of LoggerNameModel which can be used as a delegate
LoggerNameTree is used to display a TreeModel of LoggerNames.
A panel that encapsulates the Logger Name tree, with associated actions
and implements the Rule interface so that it can filter in/out events
that do not match the users request for refining the view based on Loggers.
Interface used to listen for LoggerRepository related
events such as startup, reset, and shutdown.
A
LoggerRepository is used to create and retrieve
Loggers.This class implements LoggerRepositoryEx by
wrapping an existing LoggerRepository implementation
and implementing the newly added capabilities.
Proxy that implements HierarchyEventListener
and delegates to LoggerEventListener.
Implementation of RendererSupportImpl if not
provided by LoggerRepository.
Wrap access to a LoggingEvent.
A LogPanel provides a view to a collection of LoggingEvents.
As events are received, the keywords in the 'tab identifier' application preference are replaced with the values from the received event.
As events are received, the keywords in the 'tab identifier' application preference are replaced with the values from the received event.
A TreeModel that represents the Loggers for a given LogPanel
Used to encapsulate all the preferences for a given LogPanel
GUI panel used to manipulate the PreferenceModel for a Log Panel
The main entry point for Chainsaw, this class represents the first frame
that is used to display a Welcome panel, and any other panels that are
generated because Logging Events are streamed via a Receiver, or other
mechanism.
This policy rewrites events where the message of the
original event implementes java.util.Map.
The MessageCenter is central place for all elements within Chainsaw to
notify the user of important information.
This class simply renders an event by delegating the effort to a
Log4j layout instance.
Formats messages according to very simple rules.
Loads/Saves the MRU lists from preferences
The MS SQL Server dialect is untested.
Multicast-based Appender.
Multicast-based receiver.
BeanInfo class for the meta-data of the MulticastReceiver.
The parent of all the Network based interfaces.
An event representing when a Key has arrived inside a Chainsaw model that has
not been seen previously.
Interested parties are notified when a MDC/Property key has arrived
that has not been seen before by the source Model
A panel that allows a user to configure a new Plugin, and
view that plugins javadoc at the same time
A no operation (NOP) implementation of
ULogger.The Oracle dialect.
This class leverages the 'Desktop' awt API in order to follow Mac-specific UI guidelines.
Instances of this interface can be paused, and resumed.
Defines the required interface for all Plugin objects.
A factory class to create a Classloader that can refenerence jars/classes/resources
within a users plugin directory.
All Plugin events are encapsulated in this class, which
simply contains the source Plugin, but may in future include more
information.
PluginListeners are notified when plugins are started or stopped
by the PluginRegistry.
A panel that allows the user to edit a particular Plugin, by using introspection
this class discovers the modifiable properties of the Plugin
This is a registry for Plugin instances.
A convienent abstract class for plugin subclasses that implements
the basic methods of the Plugin interface.
Ensures that a specific popupMenu is displayed when the relevant
mouse events are trapped.
Net based entities that 'work with' a Port should consider implementing this
interface so that they can be treated generically.
A component implementing this interface is interested in being able to
configure itself.
A simple ProgressPanel that can be used, a little more flexible
than ProgressMonitor when you want it to be shown REGARDLESS
of any timeouts etc.
This policy rewrites events by adding
a user-specified list of properties to the event.
Defines the base class for Receiver plugins.
A panel providing receiver configuration options
Helper class to assisit with all the known Receivers.
This panel is used to manage all the Receivers configured within Log4j
A TreeModel that encapsulates the details of all the Receivers and their
related information in the Log4j framework
A TreeCellRenderer that can format the information of Receivers
and their children
This policy rewrites events by evaluating any
JavaBean properties on the message object and adding them
to the event properties.
This appender forwards a logging request to another
appender after possibly rewriting the logging event.
This interface is implemented to provide a rewrite
strategy for RewriteAppender.
A colorizer supporting an ordered collection of ColorRules, including support for notification of
color rule changes via a propertyChangeListener and the 'colorrule' property.
A mediator class that implements the Rule interface, by combining several
optional rules used by Chainsaw's filtering GUI's into a single Rule.
This class is used to in saving and loading the tab settings
of Chainsaw....
A simple but still useful implementation of a Scheduler (in memory only).
Represents an entry in job scheduler.
Components, or objects, that are interested in being notified when
Settings are loaded or being saved, can implement this interface.
SettingManager allows components to register interest in Saving/Loading
of general application preferences/settings.
Chainsaw notifies these Listeners when the user has requested
it to shutdown.
A simple implementation that logs messages of level INFO or higher on
the console (
System.out).A better button class that has nice roll over effects.
A better button class that has nice roll over effects.
Interface used to listen for
SocketNode related
events.An Icon that is a Nice arrow to be used for displaying which
Column is being used for sorting.
A Table Column header renederer that displays a nice Up/Down arrow
depending on whether this column is the current sort column or not,
and which way the sort is functioning
An extended TableModel interface that allows Column sorting
A collection of standard utility methods for use within Swing.
The Sybase dialect.
A specific TableCellRenderer that colourizes a particular cell based on
some ColourFilters that have been stored according to the value for the row
XStream Converter implementation that deals with TableColumns settings
An interface that defines the required methods for supporting the
setting and getting of a level threshold.
A Slider implementation that allows a user to
choose a particular Threshold
.
An "editor" that doesn't allow editing, but allows the user to press a "..." for more detail about this
Column.
A runnable element that installs into the Log4j environment some fake Receivers
which generates events for use as a tutorial.
Sends log information as a UDP datagrams.
Receive LoggingEvents encoded with an XMLLayout, convert the XML data to a
LoggingEvent and post the LoggingEvent.
A proxy for org.slf4j.ULogger.
An
EntityResolver specifically designed to return
an empty InputSource for logger.dtd.An extension of the Level class that provides support for java.util.logging
Levels.
Decodes JDK 1.4's java.util.logging package events
delivered via XML (using the logger.dtd).
A VFS-enabled version of org.apache.log4j.varia.LogFilePatternReceiver.
BeanInfo class for the meta-data of the VFSLogFilePatternReceiver.
If a receiver has a visual component, implement this interface and Chainsaw will call
'setContainer' passing in a container that the receiver can use.
An initial Welcome Panel that is used when Chainsaw starts up, can displays
a HTML pages based on URLs.
Decodes Logging Events in XML formated into elements that are used by
Chainsaw.
Read
LoggingEvent objects sent from a remote client using XML over
Sockets (TCP).XMLSocketReceiver receives a remote logging event via XML on a configured
socket and "posts" it to a LoggerRepository as if the event were
generated locally.
This plugin is designed to detect specific Zeroconf zones (Rendevouz/Bonjour,
whatever people are calling it) and allow the user to double click on
'devices' to try and connect to them with no configuration needed.