OpenJDK 27 · java.util.logging.LogManager · APIdia, the JavaDoc alternative

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.

LogManager Configuration

A LogManager initializes the logging configuration via the readConfiguration() method during LogManager initialization. By default, LogManager default configuration is used. The logging configuration read by LogManager must be in the properties file format.

The LogManager defines two optional system properties that allow control over the initial configuration, as specified in the readConfiguration() method:

java.util.logging.config.class
java.util.logging.config.file

These two system properties may be specified on the command line to the "java" command, or as system property definitions passed to JNI_CreateJavaVM.

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 or comma 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 "<logger>.handlers". This defines a whitespace or comma separated list of class names for handlers classes to load and register as handlers to the specified logger. 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 "<logger>.handlers.ensureCloseOnReset". This defines a a boolean value. If "<logger>.handlers" is not defined or is empty, this property is ignored. Otherwise it defaults to true. When the value is true, the handlers associated with the logger are guaranteed to be closed on reset and shutdown. This can be turned off by explicitly setting "<logger>.handlers.ensureCloseOnReset=false" in the configuration. Note that turning this property off causes the risk of introducing a resource leak, as the logger may get garbage collected before reset() is called, thus preventing its handlers from being closed on reset(). In that case it is the responsibility of the application to ensure that the handlers are closed before the logger is garbage collected.
A property "<logger>.useParentHandlers". This defines a boolean value. By default every logger calls its parent in addition to handling the logging message itself, this often result in messages being handled by the root logger as well. When setting this property to false a Handler needs to be configured for this logger otherwise no logging messages are delivered.
A property "config". This property is intended to allow arbitrary configuration code to be run. The property defines a whitespace or comma 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 are first searched on the system class path before any user 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.

Nested and Inner Type Summary

Modifier and Type	Class and Description
private class	LogManager.Cleaner
private static class	LogManager.CloseOnReset
pack-priv static enum	LogManager.ConfigProperty
pack-priv class	LogManager.LoggerContext
pack-priv class	LogManager.LoggerWeakRef
private static class	LogManager.LoggingProviderAccess This class allows the `LoggingProviderImpl` to demand loggers on behalf of system and application classes.
private static class	LogManager.LogNode
pack-priv static enum	LogManager.ModType Type of the modification for a given property.
private class	LogManager.RootLogger
pack-priv class	LogManager.SystemLoggerContext
pack-priv static class	LogManager.VisitedLoggers An object that keep track of loggers we have already visited.

Field Summary

Modifier and Type	Field and Description
private final CopyOnWriteArrayList<LogManager.CloseOnReset>	closeOnResetLoggers
private final ReentrantLock	configurationLock
private static final Level	defaultLevel
private volatile int	globalHandlersState
private volatile boolean	initializationDone
private boolean	initializedCalled Lazy initialization: if this instance of manager is the global manager then this method will read the initial configuration and add the root logger and global logger by calling addLogger().
private final Map<Object, Runnable>	listeners
private final ReferenceQueue<Logger>	loggerRefQueue
public static final String	LOGGING_MXBEAN_NAME String representation of the `java.management/javax.management.ObjectName` for the management interface for the logging facility.
private static final LogManager	manager
private static final int	MAX_ITERATIONS
private volatile Properties	props
private volatile boolean	readPrimordialConfiguration
private volatile Logger	rootLogger
private static final int	STATE_INITIALIZED
private static final int	STATE_INITIALIZING
private static final int	STATE_READING_CONFIG
private static final int	STATE_SHUTDOWN
private static final int	STATE_UNINITIALIZED
private final LogManager.LoggerContext	systemContext
private final LogManager.LoggerContext	userContext

Constructor Summary

Access	Constructor and Description
protected	LogManager() Protected constructor.

Method Summary

Modifier and Type	Method and Description
public LogManager	Returns: This LogManager. addConfigurationListener(Runnable A configuration listener that will be invoked after the configuration changed. listener) Adds a configuration listener to be invoked each time the logging configuration is read.
public boolean	Returns: true if the argument logger was registered successfully, false if a logger of that name already exists. addLogger(Logger the new logger. logger) Add a named logger.
public void	checkAccess() Deprecated for removal since 17. This method originally checked that the current context was trusted to modify the logging configuration. Does nothing.
private void	closeHandlers(Logger logger)
private List<LogManager.LoggerContext>	contexts()
private List<Handler>	createLoggerHandlers(final String name, final String handlersPropertyName)
pack-priv Logger	demandLogger(String name, String resourceBundleName, Class<?> caller)
pack-priv Logger	demandLogger(String name, String resourceBundleName, Module module)
pack-priv Logger	demandSystemLogger(String name, String resourceBundleName, Class<?> caller)
pack-priv Logger	demandSystemLogger(String name, String resourceBundleName, Module module)
pack-priv final void	drainLoggerRefQueueBounded()
pack-priv final void	ensureLogManagerInitialized()
private boolean	forceLoadHandlers(Logger logger)
pack-priv boolean	getBooleanProperty(String name, boolean defaultValue)
pack-priv String	getConfigurationFileName()
pack-priv Filter	getFilterProperty(String name, Filter defaultValue)
pack-priv Formatter	getFormatterProperty(String name, Formatter defaultValue)
pack-priv int	getIntProperty(String name, int defaultValue)
pack-priv Level	getLevelProperty(String name, Level defaultValue)
public Logger	Returns: matching logger or null if none is found getLogger(String name of the logger name) Method to find a named logger.
public Enumeration<String>	Returns: enumeration of logger name strings getLoggerNames() Get an enumeration of known logger names.
public static synchronized LoggingMXBean	Returns: a `LoggingMXBean` object. getLoggingMXBean() Deprecated since 9. `java.util.logging.LoggingMXBean` is deprecated and replaced with `java.lang.management.PlatformLoggingMXBean`. Returns `LoggingMXBean` for managing loggers.
public static LogManager	Returns: the global LogManager object getLogManager() Returns the global LogManager object.
pack-priv long	getLongProperty(String name, long defaultValue)
public String	Returns: property value getProperty(String property name name) Get the value of a logging property.
pack-priv String	getStringProperty(String name, String defaultValue)
pack-priv final LogManager.LoggerContext	getSystemContext()
private LogManager.LoggerContext	getUserContext()
private void	initializeGlobalHandlers()
private static LogManager	initLogManager()
private void	invokeConfigurationListeners()
private void	loadLoggerHandlers(final Logger logger, final String name, final String handlersPropertyName)
private String[]	parseClassNames(String propertyName)
public void	readConfiguration() Reads and initializes the logging configuration.
public void	readConfiguration(InputStream stream to read properties from ins) Reads and initializes the logging configuration from the given input stream.
private void	readPrimordialConfiguration()
public void	removeConfigurationListener(Runnable the configuration listener to remove. listener) Removes a previously registered configuration listener.
public void	reset() Reset the logging configuration.
private void	resetLogger(Logger logger)
private void	resetLoggerContext(LogManager.LoggerContext cx)
private void	setLevelsOnExistingLoggers()
private void	setLoggerHandlers(final Logger logger, final String name, final String handlersPropertyName, List<Handler> handlers)
private static String	trim(String value)
public void	updateConfiguration(Function<String, BiFunction<String, String, String>> a functional interface that takes a configuration key k and returns a function f(o,n) whose returned value will be applied to the resulting configuration. The function f may return `null` to indicate that the property k will not be added to the resulting configuration. If `mapper` is `null` then `(k) -> ((o, n) -> n)` is assumed. For each k, the mapped function f will be invoked with the value associated with k in the old configuration (i.e o) and the value associated with k in the new configuration (i.e. n). A `null` value for o or n indicates that no value was present for k in the corresponding configuration. mapper) Updates the logging configuration.
public void	updateConfiguration(InputStream a stream to read properties from ins, Function<String, BiFunction<String, String, String>> a functional interface that takes a configuration key k and returns a function f(o,n) whose returned value will be applied to the resulting configuration. The function f may return `null` to indicate that the property k will not be added to the resulting configuration. If `mapper` is `null` then `(k) -> ((o, n) -> n)` is assumed. For each k, the mapped function f will be invoked with the value associated with k in the old configuration (i.e o) and the value associated with k in the new configuration (i.e. n). A `null` value for o or n indicates that no value was present for k in the corresponding configuration. mapper) Updates the logging configuration.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

public Class LogManager

LogManager Configuration

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary