since: 1.6 -

 protected Logger(String name,
    String resourceBundleName) 
{
        this.manager = LogManager.getLogManager();
        if (resourceBundleName != null) {
            // Note: we may get a MissingResourceException here.
            setupResourceInfo(resourceBundleName);
        }
        this.name = name;
        levelValue = Level.INFO.intValue();
}

Protected method to construct a logger for a named subsystem.

The logger will be initially configured with a null Level and with useParentHandlers set to true.

Parameters:

name - A name for the logger. This should be a dot-separated name and should normally be based on the package name or class name of the subsystem, such as java.net or javax.swing. It may be null for anonymous Loggers.

resourceBundleName - name of ResourceBundle to be used for localizing messages for this logger. May be null if none of the messages require localization.

Throws:

MissingResourceException - if the resourceBundleName is non-null and no corresponding resource can be found.

 public  void addHandler(Handler handler) throws SecurityException 
{
        // Check for null handler
        handler.getClass();
        checkAccess();
        handlers.add(handler);
}

Add a log Handler to receive logging messages.

By default, Loggers also send their output to their parent logger. Typically the root Logger is configured with a set of Handlers that essentially act as default handlers for all loggers.

 public  void config(String msg) 
{
        if (Level.CONFIG.intValue() <  levelValue) {
            return;
        }
        log(Level.CONFIG, msg);
}

Log a CONFIG message.

If the logger is currently enabled for the CONFIG message level then the given message is forwarded to all the registered output Handler objects.

 public  void entering(String sourceClass,
    String sourceMethod) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        logp(Level.FINER, sourceClass, sourceMethod, "ENTRY");
}

Log a method entry.

This is a convenience method that can be used to log entry to a method. A LogRecord with message "ENTRY", log level FINER, and the given sourceMethod and sourceClass is logged.

 public  void entering(String sourceClass,
    String sourceMethod,
    Object param1) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        Object params[] = { param1 };
        logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", params);
}

Log a method entry, with one parameter.

This is a convenience method that can be used to log entry to a method. A LogRecord with message "ENTRY {0}", log level FINER, and the given sourceMethod, sourceClass, and parameter is logged.

 public  void entering(String sourceClass,
    String sourceMethod,
    Object[] params) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        String msg = "ENTRY";
        if (params == null ) {
           logp(Level.FINER, sourceClass, sourceMethod, msg);
           return;
        }
        for (int i = 0; i <  params.length; i++) {
            msg = msg + " {" + i + "}";
        }
        logp(Level.FINER, sourceClass, sourceMethod, msg, params);
}

Log a method entry, with an array of parameters.

This is a convenience method that can be used to log entry to a method. A LogRecord with message "ENTRY" (followed by a format {N} indicator for each entry in the parameter array), log level FINER, and the given sourceMethod, sourceClass, and parameters is logged.

 public  void exiting(String sourceClass,
    String sourceMethod) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        logp(Level.FINER, sourceClass, sourceMethod, "RETURN");
}

Log a method return.

This is a convenience method that can be used to log returning from a method. A LogRecord with message "RETURN", log level FINER, and the given sourceMethod and sourceClass is logged.

 public  void exiting(String sourceClass,
    String sourceMethod,
    Object result) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        Object params[] = { result };
        logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result);
}

Log a method return, with result object.

This is a convenience method that can be used to log returning from a method. A LogRecord with message "RETURN {0}", log level FINER, and the gives sourceMethod, sourceClass, and result object is logged.

 public  void fine(String msg) 
{
        if (Level.FINE.intValue() <  levelValue) {
            return;
        }
        log(Level.FINE, msg);
}

Log a FINE message.

If the logger is currently enabled for the FINE message level then the given message is forwarded to all the registered output Handler objects.

 public  void finer(String msg) 
{
        if (Level.FINER.intValue() <  levelValue) {
            return;
        }
        log(Level.FINER, msg);
}

Log a FINER message.

If the logger is currently enabled for the FINER message level then the given message is forwarded to all the registered output Handler objects.

 public  void finest(String msg) 
{
        if (Level.FINEST.intValue() <  levelValue) {
            return;
        }
        log(Level.FINEST, msg);
}

Log a FINEST message.

If the logger is currently enabled for the FINEST message level then the given message is forwarded to all the registered output Handler objects.

 public static Logger getAnonymousLogger() 
{
        return getAnonymousLogger(null);
}

Create an anonymous Logger. The newly created Logger is not registered in the LogManager namespace. There will be no access checks on updates to the logger.

This factory method is primarily intended for use from applets. Because the resulting Logger is anonymous it can be kept private by the creating class. This removes the need for normal security checks, which in turn allows untrusted applet code to update the control state of the Logger. For example an applet can do a setLevel or an addHandler on an anonymous Logger.

Even although the new logger is anonymous, it is configured to have the root logger ("") as its parent. This means that by default it inherits its effective level and handlers from the root logger.

 public static Logger getAnonymousLogger(String resourceBundleName) 
{
        LogManager manager = LogManager.getLogManager();
        // cleanup some Loggers that have been GC'ed
        manager.drainLoggerRefQueueBounded();
        Logger result = new Logger(null, resourceBundleName);
        result.anonymous = true;
        Logger root = manager.getLogger("");
        result.doSetParent(root);
        return result;
}

Create an anonymous Logger. The newly created Logger is not registered in the LogManager namespace. There will be no access checks on updates to the logger.

This factory method is primarily intended for use from applets. Because the resulting Logger is anonymous it can be kept private by the creating class. This removes the need for normal security checks, which in turn allows untrusted applet code to update the control state of the Logger. For example an applet can do a setLevel or an addHandler on an anonymous Logger.

Even although the new logger is anonymous, it is configured to have the root logger ("") as its parent. This means that by default it inherits its effective level and handlers from the root logger.

 public Filter getFilter() 
{
        return filter;
}

Get the current filter for this Logger.

 public static final Logger getGlobal() 
{
        return global;
}

Return global logger object with the name Logger.GLOBAL_LOGGER_NAME.

 public Handler[] getHandlers() 
{
        return handlers.toArray(emptyHandlers);
}

Get the Handlers associated with this logger.

 public Level getLevel() 
{
        return levelObject;
}

Get the log Level that has been specified for this Logger. The result may be null, which means that this logger's effective level will be inherited from its parent.

 public static Logger getLogger(String name) 
{
        // This method is intentionally not a wrapper around a call
        // to getLogger(name, resourceBundleName). If it were then
        // this sequence:
        //
        //     getLogger("Foo", "resourceBundleForFoo");
        //     getLogger("Foo");
        //
        // would throw an IllegalArgumentException in the second call
        // because the wrapper would result in an attempt to replace
        // the existing "resourceBundleForFoo" with null.
        LogManager manager = LogManager.getLogManager();
        return manager.demandLogger(name);
}

Find or create a logger for a named subsystem. If a logger has already been created with the given name it is returned. Otherwise a new logger is created.

If a new logger is created its log level will be configured based on the LogManager configuration and it will configured to also send logging output to its parent's Handlers. It will be registered in the LogManager global namespace.

Note: The LogManager may only retain a weak reference to the newly created Logger. It is important to understand that a previously created Logger with the given name may be garbage collected at any time if there is no strong reference to the Logger. In particular, this means that two back-to-back calls like {@code getLogger("MyLogger").log(...)} may use different Logger objects named "MyLogger" if there is no strong reference to the Logger named "MyLogger" elsewhere in the program.

 public static Logger getLogger(String name,
    String resourceBundleName) 
{
        LogManager manager = LogManager.getLogManager();
        Logger result = manager.demandLogger(name);
        if (result.resourceBundleName == null) {
            // Note: we may get a MissingResourceException here.
            result.setupResourceInfo(resourceBundleName);
        } else if (!result.resourceBundleName.equals(resourceBundleName)) {
            throw new IllegalArgumentException(result.resourceBundleName +
                                " != " + resourceBundleName);
        }
        return result;
}

Find or create a logger for a named subsystem. If a logger has already been created with the given name it is returned. Otherwise a new logger is created.

If a new logger is created its log level will be configured based on the LogManager and it will configured to also send logging output to its parent's Handlers. It will be registered in the LogManager global namespace.

Note: The LogManager may only retain a weak reference to the newly created Logger. It is important to understand that a previously created Logger with the given name may be garbage collected at any time if there is no strong reference to the Logger. In particular, this means that two back-to-back calls like {@code getLogger("MyLogger", ...).log(...)} may use different Logger objects named "MyLogger" if there is no strong reference to the Logger named "MyLogger" elsewhere in the program.

If the named Logger already exists and does not yet have a localization resource bundle then the given resource bundle name is used. If the named Logger already exists and has a different resource bundle name then an IllegalArgumentException is thrown.

 public String getName() 
{
        return name;
}

Get the name for this logger.

 public Logger getParent() 
{
        // Note: this used to be synchronized on treeLock.  However, this only
        // provided memory semantics, as there was no guarantee that the caller
        // would synchronize on treeLock (in fact, there is no way for external
        // callers to so synchronize).  Therefore, we have made parent volatile
        // instead.
        return parent;
}

Return the parent for this Logger.

This method returns the nearest extant parent in the namespace. Thus if a Logger is called "a.b.c.d", and a Logger called "a.b" has been created but no logger "a.b.c" exists, then a call of getParent on the Logger "a.b.c.d" will return the Logger "a.b".

The result will be null if it is called on the root Logger in the namespace.

 public ResourceBundle getResourceBundle() 
{
        return findResourceBundle(getResourceBundleName());
}

Retrieve the localization resource bundle for this logger for the current default locale. Note that if the result is null, then the Logger will use a resource bundle inherited from its parent.

 public String getResourceBundleName() 
{
        return resourceBundleName;
}

Retrieve the localization resource bundle name for this logger. Note that if the result is null, then the Logger will use a resource bundle name inherited from its parent.

 public boolean getUseParentHandlers() 
{
        return useParentHandlers;
}

Discover whether or not this logger is sending its output to its parent logger.

 public  void info(String msg) 
{
        if (Level.INFO.intValue() <  levelValue) {
            return;
        }
        log(Level.INFO, msg);
}

Log an INFO message.

If the logger is currently enabled for the INFO message level then the given message is forwarded to all the registered output Handler objects.

 public boolean isLoggable(Level level) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return false;
        }
        return true;
}

Check if a message of the given level would actually be logged by this logger. This check is based on the Loggers effective level, which may be inherited from its parent.

 public  void log(LogRecord record) 
{
        if (record.getLevel().intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        Filter theFilter = filter;
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }
        // Post the LogRecord to all our Handlers, and then to
        // our parents' handlers, all the way up the tree.
        Logger logger = this;
        while (logger != null) {
            for (Handler handler : logger.getHandlers()) {
                handler.publish(record);
            }
            if (!logger.getUseParentHandlers()) {
                break;
            }
            logger = logger.getParent();
        }
}

Log a LogRecord.

All the other logging methods in this class call through this method to actually perform any logging. Subclasses can override this single method to capture all log activity.

 public  void log(Level level,
    String msg) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);
}

Log a message, with no arguments.

If the logger is currently enabled for the given message level then the given message is forwarded to all the registered output Handler objects.

 public  void log(Level level,
    String msg,
    Object param1) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        Object params[] = { param1 };
        lr.setParameters(params);
        doLog(lr);
}

Log a message, with one object parameter.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

 public  void log(Level level,
    String msg,
    Object[] params) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setParameters(params);
        doLog(lr);
}

Log a message, with an array of object arguments.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

 public  void log(Level level,
    String msg,
    Throwable thrown) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setThrown(thrown);
        doLog(lr);
}

Log a message, with associated Throwable information.

If the logger is currently enabled for the given message level then the given arguments are stored in a LogRecord which is forwarded to all registered output handlers.

Note that the thrown argument is stored in the LogRecord thrown property, rather than the LogRecord parameters property. Thus is it processed specially by output Formatters and is not treated as a formatting parameter to the LogRecord message property.

 public  void logp(Level level,
    String sourceClass,
    String sourceMethod,
    String msg) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        doLog(lr);
}

Log a message, specifying source class and method, with no arguments.

If the logger is currently enabled for the given message level then the given message is forwarded to all the registered output Handler objects.

 public  void logp(Level level,
    String sourceClass,
    String sourceMethod,
    String msg,
    Object param1) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        Object params[] = { param1 };
        lr.setParameters(params);
        doLog(lr);
}

Log a message, specifying source class and method, with a single object parameter to the log message.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

 public  void logp(Level level,
    String sourceClass,
    String sourceMethod,
    String msg,
    Object[] params) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        lr.setParameters(params);
        doLog(lr);
}

Log a message, specifying source class and method, with an array of object arguments.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

 public  void logp(Level level,
    String sourceClass,
    String sourceMethod,
    String msg,
    Throwable thrown) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        lr.setThrown(thrown);
        doLog(lr);
}

Log a message, specifying source class and method, with associated Throwable information.

If the logger is currently enabled for the given message level then the given arguments are stored in a LogRecord which is forwarded to all registered output handlers.

Note that the thrown argument is stored in the LogRecord thrown property, rather than the LogRecord parameters property. Thus is it processed specially by output Formatters and is not treated as a formatting parameter to the LogRecord message property.

 public  void logrb(Level level,
    String sourceClass,
    String sourceMethod,
    String bundleName,
    String msg) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        doLog(lr, bundleName);
}

Log a message, specifying source class, method, and resource bundle name with no arguments.

If the logger is currently enabled for the given message level then the given message is forwarded to all the registered output Handler objects.

The msg string is localized using the named resource bundle. If the resource bundle name is null, or an empty String or invalid then the msg string is not localized.

 public  void logrb(Level level,
    String sourceClass,
    String sourceMethod,
    String bundleName,
    String msg,
    Object param1) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        Object params[] = { param1 };
        lr.setParameters(params);
        doLog(lr, bundleName);
}

Log a message, specifying source class, method, and resource bundle name, with a single object parameter to the log message.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

The msg string is localized using the named resource bundle. If the resource bundle name is null, or an empty String or invalid then the msg string is not localized.

 public  void logrb(Level level,
    String sourceClass,
    String sourceMethod,
    String bundleName,
    String msg,
    Object[] params) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        lr.setParameters(params);
        doLog(lr, bundleName);
}

Log a message, specifying source class, method, and resource bundle name, with an array of object arguments.

If the logger is currently enabled for the given message level then a corresponding LogRecord is created and forwarded to all the registered output Handler objects.

The msg string is localized using the named resource bundle. If the resource bundle name is null, or an empty String or invalid then the msg string is not localized.

 public  void logrb(Level level,
    String sourceClass,
    String sourceMethod,
    String bundleName,
    String msg,
    Throwable thrown) 
{
        if (level.intValue() <  levelValue || levelValue == offValue) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        lr.setThrown(thrown);
        doLog(lr, bundleName);
}

Log a message, specifying source class, method, and resource bundle name, with associated Throwable information.

If the logger is currently enabled for the given message level then the given arguments are stored in a LogRecord which is forwarded to all registered output handlers.

The msg string is localized using the named resource bundle. If the resource bundle name is null, or an empty String or invalid then the msg string is not localized.

Note that the thrown argument is stored in the LogRecord thrown property, rather than the LogRecord parameters property. Thus is it processed specially by output Formatters and is not treated as a formatting parameter to the LogRecord message property.

 final  void removeChildLogger(LoggerWeakRef child) 
{
        synchronized (treeLock) {
            for (Iterator< LogManager.LoggerWeakRef > iter = kids.iterator(); iter.hasNext(); ) {
                LogManager.LoggerWeakRef ref = iter.next();
                if (ref == child) {
                    iter.remove();
                    return;
                }
            }
        }
}

 public  void removeHandler(Handler handler) throws SecurityException 
{
        checkAccess();
        if (handler == null) {
            return;
        }
        handlers.remove(handler);
}

Remove a log Handler.

Returns silently if the given Handler is not found or is null

 public  void setFilter(Filter newFilter) throws SecurityException 
{
        checkAccess();
        filter = newFilter;
}

Set a filter to control output on this Logger.

After passing the initial "level" check, the Logger will call this Filter to check if a log record should really be published.

 public  void setLevel(Level newLevel) throws SecurityException 
{
        checkAccess();
        synchronized (treeLock) {
            levelObject = newLevel;
            updateEffectiveLevel();
        }
}

Set the log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded. The level value Level.OFF can be used to turn off logging.

If the new level is null, it means that this node should inherit its level from its nearest ancestor with a specific (non-null) level value.

  void setLogManager(LogManager manager) 
{
        this.manager = manager;
}

 public  void setParent(Logger parent) 
{
        if (parent == null) {
            throw new NullPointerException();
        }
        manager.checkAccess();
        doSetParent(parent);
}

Set the parent for this Logger. This method is used by the LogManager to update a Logger when the namespace changes.

It should not be called from application code.

 public  void setUseParentHandlers(boolean useParentHandlers) 
{
        checkAccess();
        this.useParentHandlers = useParentHandlers;
}

Specify whether or not this logger should send its output to its parent Logger. This means that any LogRecords will also be written to the parent's Handlers, and potentially to its parent, recursively up the namespace.

 public  void severe(String msg) 
{
        if (Level.SEVERE.intValue() <  levelValue) {
            return;
        }
        log(Level.SEVERE, msg);
}

Log a SEVERE message.

If the logger is currently enabled for the SEVERE message level then the given message is forwarded to all the registered output Handler objects.

 public  void throwing(String sourceClass,
    String sourceMethod,
    Throwable thrown) 
{
        if (Level.FINER.intValue() <  levelValue || levelValue == offValue ) {
            return;
        }
        LogRecord lr = new LogRecord(Level.FINER, "THROW");
        lr.setSourceClassName(sourceClass);
        lr.setSourceMethodName(sourceMethod);
        lr.setThrown(thrown);
        doLog(lr);
}

Log throwing an exception.

This is a convenience method to log that a method is terminating by throwing an exception. The logging is done using the FINER level.

If the logger is currently enabled for the given message level then the given arguments are stored in a LogRecord which is forwarded to all registered output handlers. The LogRecord's message is set to "THROW".

Note that the thrown argument is stored in the LogRecord thrown property, rather than the LogRecord parameters property. Thus is it processed specially by output Formatters and is not treated as a formatting parameter to the LogRecord message property.

 public  void warning(String msg) 
{
        if (Level.WARNING.intValue() <  levelValue) {
            return;
        }
        log(Level.WARNING, msg);
}

Log a WARNING message.

If the logger is currently enabled for the WARNING message level then the given message is forwarded to all the registered output Handler objects.