since: 1.5 -

 protected LogManager() 
{
        // Add a shutdown hook to close the global handlers.
        try {
            Runtime.getRuntime().addShutdownHook(new Cleaner());
        } catch (IllegalStateException e) {
            // If the VM is already shutting down,
            // We do not need to register shutdownHook.
        }
}

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.

 public synchronized boolean addLogger(Logger logger) 
{
        final String name = logger.getName();
        if (name == null) {
            throw new NullPointerException();
        }
        WeakReference< Logger > ref = loggers.get(name);
        if (ref != null) {
            if (ref.get() == null) {
                // Hashtable holds stale weak reference
                // to a logger which has been GC-ed.
                // Allow to register new one.
                loggers.remove(name);
            } else {
                // We already have a registered logger with the given name.
                return false;
            }
        }
        // We're adding a new logger.
        // Note that we are creating a weak reference here.
        loggers.put(name, new WeakReference< Logger >(logger));
        // Apply any initial level defined for the new logger.
        Level level = getLevelProperty(name+".level", null);
        if (level != null) {
            doSetLevel(logger, level);
        }
        // Do we have a per logger handler too?
        // Note: this will add a 200ms penalty
        loadLoggerHandlers(logger, name, name+".handlers");
        processParentHandlers(logger, name);
        // Find the new node and its parent.
        LogNode node = findNode(name);
        node.loggerRef = new WeakReference< Logger >(logger);
        Logger parent = null;
        LogNode nodep = node.parent;
        while (nodep != null) {
            WeakReference< Logger > nodeRef = nodep.loggerRef;
            if (nodeRef != null) {
                parent = nodeRef.get();
                if (parent != null) {
                    break;
                }
            }
            nodep = nodep.parent;
        }
        if (parent != null) {
            doSetParent(logger, parent);
        }
        // Walk over the children and tell them we are their new parent.
        node.walkAndSetParent(logger);
        return true;
}

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.

 public  void addPropertyChangeListener(PropertyChangeListener l) throws SecurityException 
{
        if (l == null) {
            throw new NullPointerException();
        }
        checkAccess();
        changes.addPropertyChangeListener(l);
}

Adds an event listener to be invoked when the logging properties are re-read. Adding multiple instances of the same event Listener results in multiple entries in the property event listener table.

 public  void checkAccess() throws SecurityException 
{
                                                                   
        SecurityManager sm = System.getSecurityManager();
        if (sm == null) {
            return;
        }
        sm.checkPermission(ourPermission);
}

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.

 synchronized Logger demandLogger(String name) 
{
        Logger result = getLogger(name);
        if (result == null) {
            result = new Logger(name, null);
            addLogger(result);
            result = getLogger(name);
        }
        return result;
}

 boolean getBooleanProperty(String name,
    boolean defaultValue) 
{
        String val = getProperty(name);
        if (val == null) {
            return defaultValue;
        }
        val = val.toLowerCase();
        if (val.equals("true") || val.equals("1")) {
            return true;
        } else if (val.equals("false") || val.equals("0")) {
            return false;
        }
        return defaultValue;
}

 Filter getFilterProperty(String name,
    Filter defaultValue) 
{
        String val = getProperty(name);
        try {
            if (val != null) {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(val);
                return (Filter) clz.newInstance();
            }
        } catch (Exception ex) {
            // We got one of a variety of exceptions in creating the
            // class or creating an instance.
            // Drop through.
        }
        // We got an exception.  Return the defaultValue.
        return defaultValue;
}

 Formatter getFormatterProperty(String name,
    Formatter defaultValue) 
{
        String val = getProperty(name);
        try {
            if (val != null) {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(val);
                return (Formatter) clz.newInstance();
            }
        } catch (Exception ex) {
            // We got one of a variety of exceptions in creating the
            // class or creating an instance.
            // Drop through.
        }
        // We got an exception.  Return the defaultValue.
        return defaultValue;
}

 int getIntProperty(String name,
    int defaultValue) 
{
        String val = getProperty(name);
        if (val == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(val.trim());
        } catch (Exception ex) {
            return defaultValue;
        }
}

 Level getLevelProperty(String name,
    Level defaultValue) 
{
        String val = getProperty(name);
        if (val == null) {
            return defaultValue;
        }
        try {
            return Level.parse(val.trim());
        } catch (Exception ex) {
            return defaultValue;
        }
}

 public static LogManager getLogManager() 
{
        if (manager != null) {
            manager.readPrimordialConfiguration();
        }
        return manager;
}

Return the global LogManager object.

 public synchronized Logger getLogger(String name) 
{
        WeakReference< Logger > ref = loggers.get(name);
        if (ref == null) {
            return null;
        }
        Logger logger = ref.get();
        if (logger == null) {
            // Hashtable holds stale weak reference
            // to a logger which has been GC-ed.
            loggers.remove(name);
        }
        return logger;
}

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.

 public synchronized Enumeration getLoggerNames() 
{
        return loggers.keys();
}

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.

 public static synchronized LoggingMXBean getLoggingMXBean() 
{
                                   
        if (loggingMXBean == null) {
            loggingMXBean =  new Logging();
        }
        return loggingMXBean;
}

Returns LoggingMXBean for managing loggers. The LoggingMXBean can also obtained from the platform MBeanServer method.

 public String getProperty(String name) 
{
        return props.getProperty(name);
}

Get the value of a logging property. The method returns null if the property is not found.

 String getStringProperty(String name,
    String defaultValue) 
{
        String val = getProperty(name);
        if (val == null) {
            return defaultValue;
        }
        return val.trim();
}

 public  void readConfiguration() throws SecurityException, IOException 
{
        checkAccess();
        // if a configuration class is specified, load it and use it.
        String cname = System.getProperty("java.util.logging.config.class");
        if (cname != null) {
            try {
                // Instantiate the named class.  It is its constructor's
                // responsibility to initialize the logging configuration, by
                // calling readConfiguration(InputStream) with a suitable stream.
                try {
                    Class clz = ClassLoader.getSystemClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                } catch (ClassNotFoundException ex) {
                    Class clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                }
            } catch (Exception ex) {
                System.err.println("Logging configuration class \"" + cname + "\" failed");
                System.err.println("" + ex);
                // keep going and useful config file.
            }
        }
        String fname = System.getProperty("java.util.logging.config.file");
        if (fname == null) {
            fname = System.getProperty("java.home");
            if (fname == null) {
                throw new Error("Can't find java.home ??");
            }
            File f = new File(fname, "lib");
            f = new File(f, "logging.properties");
            fname = f.getCanonicalPath();
        }
        InputStream in = new FileInputStream(fname);
        BufferedInputStream bin = new BufferedInputStream(in);
        try {
            readConfiguration(bin);
        } finally {
            if (in != null) {
                in.close();
            }
        }
}

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.

 public  void readConfiguration(InputStream ins) throws SecurityException, IOException 
{
        checkAccess();
        reset();
        // Load the properties
        props.load(ins);
        // Instantiate new configuration objects.
        String names[] = parseClassNames("config");
        for (int i = 0; i <  names.length; i++) {
            String word = names[i];
            try {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
                clz.newInstance();
            } catch (Exception ex) {
                System.err.println("Can't load config class \"" + word + "\"");
                System.err.println("" + ex);
                // ex.printStackTrace();
            }
        }
        // Set levels on any pre-existing loggers, based on the new properties.
        setLevelsOnExistingLoggers();
        // Notify any interested parties that our properties have changed.
        changes.firePropertyChange(null, null, null);
        // Note that we need to reinitialize global handles when
        // they are first referenced.
        synchronized (this) {
            initializedGlobalHandlers = false;
        }
}

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.

 public  void removePropertyChangeListener(PropertyChangeListener l) throws SecurityException 
{
        checkAccess();
        changes.removePropertyChangeListener(l);
}

Removes an event listener for property change events. If the same listener instance has been added to the listener table through multiple invocations of addPropertyChangeListener, then an equivalent number of removePropertyChangeListener invocations are required to remove all instances of that listener from the listener table.

Returns silently if the given listener is not found.

 public  void reset() throws SecurityException 
{
        checkAccess();
        synchronized (this) {
            props = new Properties();
            // Since we are doing a reset we no longer want to initialize
            // the global handlers, if they haven't been initialized yet.
            initializedGlobalHandlers = true;
        }
        Enumeration enum_ = getLoggerNames();
        while (enum_.hasMoreElements()) {
            String name = (String)enum_.nextElement();
            resetLogger(name);
        }
}

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.