java.util.logging
Class LogManager

java.lang.Object
  java.util.logging.LogManager

public class LogManager

extends Object

There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services.

This LogManager object:

• Manages a hierarchical namespace of Logger objects. All named Loggers are stored in this namespace.
• Manages a set of logging control properties. These are simple key-value pairs that can be used by Handlers and other logging objects to configure themselves.

The global LogManager object can be retrieved using LogManager.getLogManager(). The LogManager object is created during class initialization and cannot subsequently be changed.

At startup the LogManager class is located using the java.util.logging.manager system property.

By default, the LogManager reads its initial configuration from a properties file "lib/logging.properties" in the JRE directory. If you edit that property file you can change the default logging configuration for all uses of that JRE.

In addition, the LogManager uses two optional system properties that allow more control over reading the initial configuration:

• "java.util.logging.config.class"
• "java.util.logging.config.file"

These two properties may be set via the Preferences API, or as command line property definitions to the "java" command, or as system property definitions passed to JNI_CreateJavaVM.

If the "java.util.logging.config.class" property is set, then the property value is treated as a class name. The given class will be loaded, an object will be instantiated, and that object's constructor is responsible for reading in the initial configuration. (That object may use other system properties to control its configuration.) The alternate configuration class can use readConfiguration(InputStream) to define properties in the LogManager.

If "java.util.logging.config.class" property is not set, then the "java.util.logging.config.file" system property can be used to specify a properties file (in java.util.Properties format). The initial logging configuration will be read from this file.

If neither of these properties is defined then, as described above, the LogManager will read its initial configuration from a properties file "lib/logging.properties" in the JRE directory.

The properties for loggers and Handlers will have names starting with the dot-separated name for the handler or logger.

The global logging properties may include:

• A property "handlers". This defines a whitespace separated list of class names for handler classes to load and register as handlers on the root Logger (the Logger named ""). Each class name must be for a Handler class which has a default constructor. Note that these Handlers may be created lazily, when they are first used.
• A property "config". This property is intended to allow arbitrary configuration code to be run. The property defines a whitespace separated list of class names. A new instance will be created for each named class. The default constructor of each class may execute arbitrary code to update the logging configuration, such as setting logger levels, adding handlers, adding filters, etc.

Note that all classes loaded during LogManager configuration must be on the system class path. That includes the LogManager class, any config classes, and any handler classes.

Loggers are organized into a naming hierarchy based on their dot separated names. Thus "a.b.c" is a child of "a.b", but "a.b1" and a.b2" are peers.

All properties whose names end with ".level" are assumed to define log levels for Loggers. Thus "foo.level" defines a log level for the logger called "foo" and (recursively) for any of its children in the naming hierarchy. Log Levels are applied in the order they are defined in the properties file. Thus level settings for child nodes in the tree should come after settings for their parents. The property name ".level" can be used to set the level for the root of the tree.

All methods on the LogManager object are multi-thread safe.

Since:

1.4

Nested Class Summary

private class	LogManager.Cleaner
private static class	LogManager.LogNode
private class	LogManager.RootLogger

Field Summary

private java.beans.PropertyChangeSupport	changes
private boolean	deathImminent
private static Level	defaultLevel
private static Handler[]	emptyHandlers
private boolean	initializedGlobalHandlers
private Hashtable	loggers
private static LogManager	manager
private java.security.Permission	ourPermission
private Properties	props
private boolean	readPrimordialConfiguration
private LogManager.LogNode	root
private Logger	rootLogger

Constructor Summary

protected

LogManager() Protected constructor.

Method Summary

boolean	addLogger(Logger logger) Add a named logger.
void	addPropertyChangeListener(java.beans.PropertyChangeListener l) Add an event listener to be invoked when the logging properties are re-read.
void	checkAccess() Check that the current context is trusted to modify the logging configuration.
private static void	doSetLevel(Logger logger, Level level)
private static void	doSetParent(Logger logger, Logger parent)
private LogManager.LogNode	findNode(String name)
(package private) boolean	getBooleanProperty(String name, boolean defaultValue)
(package private) Filter	getFilterProperty(String name, Filter defaultValue)
(package private) Formatter	getFormatterProperty(String name, Formatter defaultValue)
(package private) int	getIntProperty(String name, int defaultValue)
(package private) Level	getLevelProperty(String name, Level defaultValue)
Logger	getLogger(String name) Method to find a named logger.
Enumeration	getLoggerNames() Get an enumeration of known logger names.
static LogManager	getLogManager() Return the global LogManager object.
String	getProperty(String name) Get the value of a logging property.
(package private) String	getStringProperty(String name, String defaultValue)
private void	initializeGlobalHandlers()
private String[]	parseClassNames(String propertyName)
void	readConfiguration() Reinitialize the logging properties and reread the logging configuration.
void	readConfiguration(InputStream ins) Reinitialize the logging properties and reread the logging configuration from the given stream, which should be in java.util.Properties format.
private void	readPrimordialConfiguration()
void	removePropertyChangeListener(java.beans.PropertyChangeListener l) Remove an event listener for property change events.
void	reset() Reset the logging configuration.
private void	resetLogger(String name)
private void	setLevelsOnExistingLoggers()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

manager

private static LogManager manager

emptyHandlers

private static final Handler[] emptyHandlers

props

private Properties props

changes

private java.beans.PropertyChangeSupport changes

defaultLevel

private static final Level defaultLevel

loggers

private Hashtable loggers

root

private LogManager.LogNode root

rootLogger

private Logger rootLogger

readPrimordialConfiguration

private volatile boolean readPrimordialConfiguration

initializedGlobalHandlers

private boolean initializedGlobalHandlers

deathImminent

private boolean deathImminent

ourPermission

private java.security.Permission ourPermission

Constructor Detail

LogManager

protected LogManager()

Protected constructor. This is protected so that container applications (such as J2EE containers) can subclass the object. It is non-public as it is intended that there only be one LogManager object, whose value is retrieved by calling Logmanager.getLogManager.

Method Detail

getLogManager

public static LogManager getLogManager()

Return the global LogManager object.

readPrimordialConfiguration

private void readPrimordialConfiguration()

addPropertyChangeListener

public void addPropertyChangeListener(java.beans.PropertyChangeListener l)
                               throws SecurityException

Add an event listener to be invoked when the logging properties are re-read.

Parameters:

l - event listener

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

removePropertyChangeListener

public void removePropertyChangeListener(java.beans.PropertyChangeListener l)
                                  throws SecurityException

Remove an event listener for property change events.

Returns silently if the given listener is not found.

Parameters:

l - event listener

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

addLogger

public boolean addLogger(Logger logger)

Add a named logger. This does nothing and returns false if a logger with the same name is already registered.

The Logger factory methods call this method to register each newly created Logger.

The application should retain its own reference to the Logger object to avoid it being garbage collected. The LogManager may only retain a weak reference.

Parameters:

logger - the new logger.

Returns:

true if the argument logger was registered successfully, false if a logger of that name already exists.

Throws:

NullPointerException - if the logger name is null.

doSetLevel

private static void doSetLevel(Logger logger,
                               Level level)

doSetParent

private static void doSetParent(Logger logger,
                                Logger parent)

findNode

private LogManager.LogNode findNode(String name)

getLogger

public Logger getLogger(String name)

Method to find a named logger.

Note that since untrusted code may create loggers with arbitrary names this method should not be relied on to find Loggers for security sensitive logging.

Parameters:

name - name of the logger

Returns:

matching logger or null if none is found

getLoggerNames

public Enumeration getLoggerNames()

Get an enumeration of known logger names.

Note: Loggers may be added dynamically as new classes are loaded. This method only reports on the loggers that are currently registered.

Returns:

enumeration of logger name strings

readConfiguration

public void readConfiguration()
                       throws IOException,
                              SecurityException

Reinitialize the logging properties and reread the logging configuration.

The same rules are used for locating the configuration properties as are used at startup. So normally the logging properties will be re-read from the same file that was used at startup.

Any log level definitions in the new configuration file will be applied using Logger.setLevel(), if the target Logger exists.

A PropertyChangeEvent will be fired after the properties are read.

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

IOException - if there are IO problems reading the configuration.

reset

public void reset()
           throws SecurityException

Reset the logging configuration.

For all named loggers, the reset operation removes and closes all Handlers and (except for the root logger) sets the level to null. The root logger's level is set to Level.INFO.

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

resetLogger

private void resetLogger(String name)

parseClassNames

private String[] parseClassNames(String propertyName)

readConfiguration

public void readConfiguration(InputStream ins)
                       throws IOException,
                              SecurityException

Reinitialize the logging properties and reread the logging configuration from the given stream, which should be in java.util.Properties format. A PropertyChangeEvent will be fired after the properties are read.

Any log level definitions in the new configuration file will be applied using Logger.setLevel(), if the target Logger exists.

Parameters:

ins - stream to read properties from

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

IOException - if there are problems reading from the stream.

getProperty

public String getProperty(String name)

Get the value of a logging property.

Parameters:

name - property name

Returns:

property value

getStringProperty

String getStringProperty(String name,
                         String defaultValue)

getIntProperty

int getIntProperty(String name,
                   int defaultValue)

getBooleanProperty

boolean getBooleanProperty(String name,
                           boolean defaultValue)

getLevelProperty

Level getLevelProperty(String name,
                       Level defaultValue)

getFilterProperty

Filter getFilterProperty(String name,
                         Filter defaultValue)

getFormatterProperty

Formatter getFormatterProperty(String name,
                               Formatter defaultValue)

initializeGlobalHandlers

private void initializeGlobalHandlers()

checkAccess

public void checkAccess()
                 throws SecurityException

Check that the current context is trusted to modify the logging configuration. This requires LoggingPermission("control").

If the check fails we throw a SecurityException, otherwise we return normally.

Throws:

SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control").

setLevelsOnExistingLoggers

private void setLevelsOnExistingLoggers()