| /* |
| * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| |
| package java.util.logging; |
| |
| import java.lang.ref.WeakReference; |
| import java.lang.reflect.Module; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.Locale; |
| import java.util.MissingResourceException; |
| import java.util.Objects; |
| import java.util.ResourceBundle; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| import java.util.function.Supplier; |
| import sun.reflect.CallerSensitive; |
| import sun.reflect.Reflection; |
| |
| /** |
| * A Logger object is used to log messages for a specific |
| * system or application component. Loggers are normally named, |
| * using a hierarchical dot-separated namespace. Logger names |
| * can be arbitrary strings, but they should normally be based on |
| * the package name or class name of the logged component, such |
| * as java.net or javax.swing. In addition it is possible to create |
| * "anonymous" Loggers that are not stored in the Logger namespace. |
| * <p> |
| * Logger objects may be obtained by calls on one of the getLogger |
| * factory methods. These will either create a new Logger or |
| * return a suitable existing Logger. It is important to note that |
| * the Logger returned by one of the {@code getLogger} factory methods |
| * may be garbage collected at any time if a strong reference to the |
| * Logger is not kept. |
| * <p> |
| * Logging messages will be forwarded to registered Handler |
| * objects, which can forward the messages to a variety of |
| * destinations, including consoles, files, OS logs, etc. |
| * <p> |
| * Each Logger keeps track of a "parent" Logger, which is its |
| * nearest existing ancestor in the Logger namespace. |
| * <p> |
| * Each Logger has a "Level" associated with it. This reflects |
| * a minimum Level that this logger cares about. If a Logger's |
| * level is set to {@code null}, then its effective level is inherited |
| * from its parent, which may in turn obtain it recursively from its |
| * parent, and so on up the tree. |
| * <p> |
| * The log level can be configured based on the properties from the |
| * logging configuration file, as described in the description |
| * of the LogManager class. However it may also be dynamically changed |
| * by calls on the Logger.setLevel method. If a logger's level is |
| * changed the change may also affect child loggers, since any child |
| * logger that has {@code null} as its level will inherit its |
| * effective level from its parent. |
| * <p> |
| * On each logging call the Logger initially performs a cheap |
| * check of the request level (e.g., SEVERE or FINE) against the |
| * effective log level of the logger. If the request level is |
| * lower than the log level, the logging call returns immediately. |
| * <p> |
| * After passing this initial (cheap) test, the Logger will allocate |
| * a LogRecord to describe the logging message. It will then call a |
| * Filter (if present) to do a more detailed check on whether the |
| * record should be published. If that passes it will then publish |
| * the LogRecord to its output Handlers. By default, loggers also |
| * publish to their parent's Handlers, recursively up the tree. |
| * <p> |
| * Each Logger may have a {@code ResourceBundle} associated with it. |
| * The {@code ResourceBundle} may be specified by name, using the |
| * {@link #getLogger(java.lang.String, java.lang.String)} factory |
| * method, or by value - using the {@link |
| * #setResourceBundle(java.util.ResourceBundle) setResourceBundle} method. |
| * This bundle will be used for localizing logging messages. |
| * If a Logger does not have its own {@code ResourceBundle} or resource bundle |
| * name, then it will inherit the {@code ResourceBundle} or resource bundle name |
| * from its parent, recursively up the tree. |
| * <p> |
| * Most of the logger output methods take a "msg" argument. This |
| * msg argument may be either a raw value or a localization key. |
| * During formatting, if the logger has (or inherits) a localization |
| * {@code ResourceBundle} and if the {@code ResourceBundle} has a mapping for |
| * the msg string, then the msg string is replaced by the localized value. |
| * Otherwise the original msg string is used. Typically, formatters use |
| * java.text.MessageFormat style formatting to format parameters, so |
| * for example a format string "{0} {1}" would format two parameters |
| * as strings. |
| * <p> |
| * A set of methods alternatively take a "msgSupplier" instead of a "msg" |
| * argument. These methods take a {@link Supplier}{@code <String>} function |
| * which is invoked to construct the desired log message only when the message |
| * actually is to be logged based on the effective log level thus eliminating |
| * unnecessary message construction. For example, if the developer wants to |
| * log system health status for diagnosis, with the String-accepting version, |
| * the code would look like: |
| * <pre>{@code |
| * |
| * class DiagnosisMessages { |
| * static String systemHealthStatus() { |
| * // collect system health information |
| * ... |
| * } |
| * } |
| * ... |
| * logger.log(Level.FINER, DiagnosisMessages.systemHealthStatus()); |
| * }</pre> |
| * With the above code, the health status is collected unnecessarily even when |
| * the log level FINER is disabled. With the Supplier-accepting version as |
| * below, the status will only be collected when the log level FINER is |
| * enabled. |
| * <pre>{@code |
| * |
| * logger.log(Level.FINER, DiagnosisMessages::systemHealthStatus); |
| * }</pre> |
| * <p> |
| * When looking for a {@code ResourceBundle}, the logger will first look at |
| * whether a bundle was specified using {@link |
| * #setResourceBundle(java.util.ResourceBundle) setResourceBundle}, and then |
| * only whether a resource bundle name was specified through the {@link |
| * #getLogger(java.lang.String, java.lang.String) getLogger} factory method. |
| * If no {@code ResourceBundle} or no resource bundle name is found, |
| * then it will use the nearest {@code ResourceBundle} or resource bundle |
| * name inherited from its parent tree.<br> |
| * When a {@code ResourceBundle} was inherited or specified through the |
| * {@link |
| * #setResourceBundle(java.util.ResourceBundle) setResourceBundle} method, then |
| * that {@code ResourceBundle} will be used. Otherwise if the logger only |
| * has or inherited a resource bundle name, then that resource bundle name |
| * will be mapped to a {@code ResourceBundle} object, using the default Locale |
| * at the time of logging. |
| * <br id="ResourceBundleMapping">When mapping resource bundle names to |
| * {@code ResourceBundle} objects, the logger will first try to use the |
| * Thread's {@linkplain java.lang.Thread#getContextClassLoader() context class |
| * loader} to map the given resource bundle name to a {@code ResourceBundle}. |
| * If the thread context class loader is {@code null}, it will try the |
| * {@linkplain java.lang.ClassLoader#getSystemClassLoader() system class loader} |
| * instead. If the {@code ResourceBundle} is still not found, it will use the |
| * class loader of the first caller of the {@link |
| * #getLogger(java.lang.String, java.lang.String) getLogger} factory method. |
| * <p> |
| * Formatting (including localization) is the responsibility of |
| * the output Handler, which will typically call a Formatter. |
| * <p> |
| * Note that formatting need not occur synchronously. It may be delayed |
| * until a LogRecord is actually written to an external sink. |
| * <p> |
| * The logging methods are grouped in five main categories: |
| * <ul> |
| * <li><p> |
| * There are a set of "log" methods that take a log level, a message |
| * string, and optionally some parameters to the message string. |
| * <li><p> |
| * There are a set of "logp" methods (for "log precise") that are |
| * like the "log" methods, but also take an explicit source class name |
| * and method name. |
| * <li><p> |
| * There are a set of "logrb" method (for "log with resource bundle") |
| * that are like the "logp" method, but also take an explicit resource |
| * bundle object for use in localizing the log message. |
| * <li><p> |
| * There are convenience methods for tracing method entries (the |
| * "entering" methods), method returns (the "exiting" methods) and |
| * throwing exceptions (the "throwing" methods). |
| * <li><p> |
| * Finally, there are a set of convenience methods for use in the |
| * very simplest cases, when a developer simply wants to log a |
| * simple string at a given log level. These methods are named |
| * after the standard Level names ("severe", "warning", "info", etc.) |
| * and take a single argument, a message string. |
| * </ul> |
| * <p> |
| * For the methods that do not take an explicit source name and |
| * method name, the Logging framework will make a "best effort" |
| * to determine which class and method called into the logging method. |
| * However, it is important to realize that this automatically inferred |
| * information may only be approximate (or may even be quite wrong!). |
| * Virtual machines are allowed to do extensive optimizations when |
| * JITing and may entirely remove stack frames, making it impossible |
| * to reliably locate the calling class and method. |
| * <P> |
| * All methods on Logger are multi-thread safe. |
| * <p> |
| * <b>Subclassing Information:</b> Note that a LogManager class may |
| * provide its own implementation of named Loggers for any point in |
| * the namespace. Therefore, any subclasses of Logger (unless they |
| * are implemented in conjunction with a new LogManager class) should |
| * take care to obtain a Logger instance from the LogManager class and |
| * should delegate operations such as "isLoggable" and "log(LogRecord)" |
| * to that instance. Note that in order to intercept all logging |
| * output, subclasses need only override the log(LogRecord) method. |
| * All the other logging methods are implemented as calls on this |
| * log(LogRecord) method. |
| * |
| * @since 1.4 |
| */ |
| public class Logger { |
| private static final Handler emptyHandlers[] = new Handler[0]; |
| private static final int offValue = Level.OFF.intValue(); |
| |
| static final String SYSTEM_LOGGER_RB_NAME = "sun.util.logging.resources.logging"; |
| |
| // This class is immutable and it is important that it remains so. |
| private static final class LoggerBundle { |
| final String resourceBundleName; // Base name of the bundle. |
| final ResourceBundle userBundle; // Bundle set through setResourceBundle. |
| private LoggerBundle(String resourceBundleName, ResourceBundle bundle) { |
| this.resourceBundleName = resourceBundleName; |
| this.userBundle = bundle; |
| } |
| boolean isSystemBundle() { |
| return SYSTEM_LOGGER_RB_NAME.equals(resourceBundleName); |
| } |
| static LoggerBundle get(String name, ResourceBundle bundle) { |
| if (name == null && bundle == null) { |
| return NO_RESOURCE_BUNDLE; |
| } else if (SYSTEM_LOGGER_RB_NAME.equals(name) && bundle == null) { |
| return SYSTEM_BUNDLE; |
| } else { |
| return new LoggerBundle(name, bundle); |
| } |
| } |
| } |
| |
| // This instance will be shared by all loggers created by the system |
| // code |
| private static final LoggerBundle SYSTEM_BUNDLE = |
| new LoggerBundle(SYSTEM_LOGGER_RB_NAME, null); |
| |
| // This instance indicates that no resource bundle has been specified yet, |
| // and it will be shared by all loggers which have no resource bundle. |
| private static final LoggerBundle NO_RESOURCE_BUNDLE = |
| new LoggerBundle(null, null); |
| |
| private static final RuntimePermission GET_CLASS_LOADER_PERMISSION = |
| new RuntimePermission("getClassLoader"); |
| |
| private volatile LogManager manager; |
| private String name; |
| private final CopyOnWriteArrayList<Handler> handlers = |
| new CopyOnWriteArrayList<>(); |
| private volatile LoggerBundle loggerBundle = NO_RESOURCE_BUNDLE; |
| private volatile boolean useParentHandlers = true; |
| private volatile Filter filter; |
| private boolean anonymous; |
| |
| // Cache to speed up behavior of findResourceBundle: |
| private ResourceBundle catalog; // Cached resource bundle |
| private String catalogName; // name associated with catalog |
| private Locale catalogLocale; // locale associated with catalog |
| |
| // The fields relating to parent-child relationships and levels |
| // are managed under a separate lock, the treeLock. |
| private static final Object treeLock = new Object(); |
| // We keep weak references from parents to children, but strong |
| // references from children to parents. |
| private volatile Logger parent; // our nearest parent. |
| private ArrayList<LogManager.LoggerWeakRef> kids; // WeakReferences to loggers that have us as parent |
| private volatile Level levelObject; |
| private volatile int levelValue; // current effective level value |
| private WeakReference<Module> callerModuleRef; |
| private final boolean isSystemLogger; |
| |
| /** |
| * GLOBAL_LOGGER_NAME is a name for the global logger. |
| * |
| * @since 1.6 |
| */ |
| public static final String GLOBAL_LOGGER_NAME = "global"; |
| |
| /** |
| * Return global logger object with the name Logger.GLOBAL_LOGGER_NAME. |
| * |
| * @return global logger object |
| * @since 1.7 |
| */ |
| public static final Logger getGlobal() { |
| // In order to break a cyclic dependence between the LogManager |
| // and Logger static initializers causing deadlocks, the global |
| // logger is created with a special constructor that does not |
| // initialize its log manager. |
| // |
| // If an application calls Logger.getGlobal() before any logger |
| // has been initialized, it is therefore possible that the |
| // LogManager class has not been initialized yet, and therefore |
| // Logger.global.manager will be null. |
| // |
| // In order to finish the initialization of the global logger, we |
| // will therefore call LogManager.getLogManager() here. |
| // |
| // To prevent race conditions we also need to call |
| // LogManager.getLogManager() unconditionally here. |
| // Indeed we cannot rely on the observed value of global.manager, |
| // because global.manager will become not null somewhere during |
| // the initialization of LogManager. |
| // If two threads are calling getGlobal() concurrently, one thread |
| // will see global.manager null and call LogManager.getLogManager(), |
| // but the other thread could come in at a time when global.manager |
| // is already set although ensureLogManagerInitialized is not finished |
| // yet... |
| // Calling LogManager.getLogManager() unconditionally will fix that. |
| |
| LogManager.getLogManager(); |
| |
| // Now the global LogManager should be initialized, |
| // and the global logger should have been added to |
| // it, unless we were called within the constructor of a LogManager |
| // subclass installed as LogManager, in which case global.manager |
| // would still be null, and global will be lazily initialized later on. |
| |
| return global; |
| } |
| |
| /** |
| * The "global" Logger object is provided as a convenience to developers |
| * who are making casual use of the Logging package. Developers |
| * who are making serious use of the logging package (for example |
| * in products) should create and use their own Logger objects, |
| * with appropriate names, so that logging can be controlled on a |
| * suitable per-Logger granularity. Developers also need to keep a |
| * strong reference to their Logger objects to prevent them from |
| * being garbage collected. |
| * |
| * @deprecated Initialization of this field is prone to deadlocks. |
| * The field must be initialized by the Logger class initialization |
| * which may cause deadlocks with the LogManager class initialization. |
| * In such cases two class initialization wait for each other to complete. |
| * The preferred way to get the global logger object is via the call |
| * {@code Logger.getGlobal()}. |
| * For compatibility with old JDK versions where the |
| * {@code Logger.getGlobal()} is not available use the call |
| * {@code Logger.getLogger(Logger.GLOBAL_LOGGER_NAME)} |
| * or {@code Logger.getLogger("global")}. |
| */ |
| @Deprecated |
| public static final Logger global = new Logger(GLOBAL_LOGGER_NAME); |
| |
| /** |
| * Protected method to construct a logger for a named subsystem. |
| * <p> |
| * The logger will be initially configured with a null Level |
| * and with useParentHandlers set to true. |
| * |
| * @param 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. |
| * @param 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. |
| */ |
| protected Logger(String name, String resourceBundleName) { |
| this(name, resourceBundleName, null, LogManager.getLogManager(), false); |
| } |
| |
| Logger(String name, String resourceBundleName, Class<?> caller, LogManager manager, boolean isSystemLogger) { |
| this.manager = manager; |
| this.isSystemLogger = isSystemLogger; |
| setupResourceInfo(resourceBundleName, caller); |
| this.name = name; |
| levelValue = Level.INFO.intValue(); |
| } |
| |
| private void setCallerModuleRef(Class<?> caller) { |
| Module callerModule = ((caller != null) |
| ? caller.getModule() |
| : null); |
| if (callerModule != null) { |
| this.callerModuleRef = new WeakReference<>(callerModule); |
| } |
| } |
| |
| private Module getCallerModule() { |
| return (callerModuleRef != null) |
| ? callerModuleRef.get() |
| : null; |
| } |
| |
| // This constructor is used only to create the global Logger. |
| // It is needed to break a cyclic dependence between the LogManager |
| // and Logger static initializers causing deadlocks. |
| private Logger(String name) { |
| // The manager field is not initialized here. |
| this.name = name; |
| this.isSystemLogger = true; |
| levelValue = Level.INFO.intValue(); |
| } |
| |
| // It is called from LoggerContext.addLocalLogger() when the logger |
| // is actually added to a LogManager. |
| void setLogManager(LogManager manager) { |
| this.manager = manager; |
| } |
| |
| private void checkPermission() throws SecurityException { |
| if (!anonymous) { |
| if (manager == null) { |
| // Complete initialization of the global Logger. |
| manager = LogManager.getLogManager(); |
| } |
| manager.checkPermission(); |
| } |
| } |
| |
| // Until all JDK code converted to call sun.util.logging.PlatformLogger |
| // (see 7054233), we need to determine if Logger.getLogger is to add |
| // a system logger or user logger. |
| // |
| // As an interim solution, if the immediate caller whose caller loader is |
| // null, we assume it's a system logger and add it to the system context. |
| // These system loggers only set the resource bundle to the given |
| // resource bundle name (rather than the default system resource bundle). |
| private static class SystemLoggerHelper { |
| static boolean disableCallerCheck = getBooleanProperty("sun.util.logging.disableCallerCheck"); |
| private static boolean getBooleanProperty(final String key) { |
| String s = AccessController.doPrivileged(new PrivilegedAction<String>() { |
| @Override |
| public String run() { |
| return System.getProperty(key); |
| } |
| }); |
| return Boolean.valueOf(s); |
| } |
| } |
| |
| private static Logger demandLogger(String name, String resourceBundleName, Class<?> caller) { |
| LogManager manager = LogManager.getLogManager(); |
| if (!SystemLoggerHelper.disableCallerCheck) { |
| if (caller.getClassLoader() == null) { |
| return manager.demandSystemLogger(name, resourceBundleName, caller); |
| } |
| } |
| return manager.demandLogger(name, resourceBundleName, caller); |
| // ends up calling new Logger(name, resourceBundleName, caller) |
| // iff the logger doesn't exist already |
| } |
| |
| /** |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param 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 |
| * @return a suitable Logger |
| * @throws NullPointerException if the name is null. |
| */ |
| |
| // Synchronization is not required here. All synchronization for |
| // adding a new Logger object is handled by LogManager.addLogger(). |
| @CallerSensitive |
| 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. |
| return Logger.getLogger(name, Reflection.getCallerClass()); |
| } |
| |
| /** |
| * Find or create a logger for a named subsystem on behalf |
| * of the given caller. |
| * |
| * This method is called by {@link #getLogger(java.lang.String)} after |
| * it has obtained a reference to its caller's class. |
| * |
| * @param name A name for the logger. |
| * @param callerClass The class that called {@link |
| * #getLogger(java.lang.String)}. |
| * @return a suitable Logger for {@code callerClass}. |
| */ |
| private static Logger getLogger(String name, Class<?> callerClass) { |
| return demandLogger(name, null, callerClass); |
| } |
| |
| /** |
| * 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. |
| * |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param 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 |
| * @param resourceBundleName name of ResourceBundle to be used for localizing |
| * messages for this logger. May be {@code null} |
| * if none of the messages require localization. |
| * @return a suitable Logger |
| * @throws MissingResourceException if the resourceBundleName is non-null and |
| * no corresponding resource can be found. |
| * @throws IllegalArgumentException if the Logger already exists and uses |
| * a different resource bundle name; or if |
| * {@code resourceBundleName} is {@code null} but the named |
| * logger has a resource bundle set. |
| * @throws NullPointerException if the name is null. |
| */ |
| |
| // Synchronization is not required here. All synchronization for |
| // adding a new Logger object is handled by LogManager.addLogger(). |
| @CallerSensitive |
| public static Logger getLogger(String name, String resourceBundleName) { |
| return Logger.getLogger(name, resourceBundleName, Reflection.getCallerClass()); |
| } |
| |
| /** |
| * Find or create a logger for a named subsystem on behalf |
| * of the given caller. |
| * |
| * This method is called by {@link |
| * #getLogger(java.lang.String, java.lang.String)} after |
| * it has obtained a reference to its caller's class. |
| * |
| * @param name A name for the logger. |
| * @param resourceBundleName name of ResourceBundle to be used for localizing |
| * messages for this logger. May be {@code null} |
| * if none of the messages require localization. |
| * @param callerClass The class that called {@link |
| * #getLogger(java.lang.String, java.lang.String)}. |
| * This class will also be used for locating the |
| * resource bundle if {@code resourceBundleName} is |
| * not {@code null}. |
| * @return a suitable Logger for {@code callerClass}. |
| */ |
| private static Logger getLogger(String name, String resourceBundleName, |
| Class<?> callerClass) { |
| Logger result = demandLogger(name, resourceBundleName, callerClass); |
| |
| // MissingResourceException or IllegalArgumentException can be |
| // thrown by setupResourceInfo(). |
| // We have to set the callers ClassLoader here in case demandLogger |
| // above found a previously created Logger. This can happen, for |
| // example, if Logger.getLogger(name) is called and subsequently |
| // Logger.getLogger(name, resourceBundleName) is called. In this case |
| // we won't necessarily have the correct classloader saved away, so |
| // we need to set it here, too. |
| |
| result.setupResourceInfo(resourceBundleName, callerClass); |
| return result; |
| } |
| |
| // package-private |
| // Add a platform logger to the system context. |
| // i.e. caller of sun.util.logging.PlatformLogger.getLogger |
| static Logger getPlatformLogger(String name) { |
| LogManager manager = LogManager.getLogManager(); |
| |
| // all loggers in the system context will default to |
| // the system logger's resource bundle - therefore the caller won't |
| // be needed and can be null. |
| Logger result = manager.demandSystemLogger(name, SYSTEM_LOGGER_RB_NAME, null); |
| 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. Changing its parent via the |
| * {@link #setParent(java.util.logging.Logger) setParent} method |
| * will still require the security permission specified by that method. |
| * |
| * @return a newly created private Logger |
| */ |
| 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. Changing its parent via the |
| * {@link #setParent(java.util.logging.Logger) setParent} method |
| * will still require the security permission specified by that method. |
| * |
| * @param resourceBundleName name of ResourceBundle to be used for localizing |
| * messages for this logger. |
| * May be null if none of the messages require localization. |
| * @return a newly created private Logger |
| * @throws MissingResourceException if the resourceBundleName is non-null and |
| * no corresponding resource can be found. |
| */ |
| |
| // Synchronization is not required here. All synchronization for |
| // adding a new anonymous Logger object is handled by doSetParent(). |
| @CallerSensitive |
| 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, |
| Reflection.getCallerClass(), manager, false); |
| result.anonymous = true; |
| Logger root = manager.getLogger(""); |
| result.doSetParent(root); |
| return result; |
| } |
| |
| /** |
| * Retrieve the localization resource bundle for this |
| * logger. |
| * This method will return a {@code ResourceBundle} that was either |
| * set by the {@link |
| * #setResourceBundle(java.util.ResourceBundle) setResourceBundle} method or |
| * <a href="#ResourceBundleMapping">mapped from the |
| * the resource bundle name</a> set via the {@link |
| * Logger#getLogger(java.lang.String, java.lang.String) getLogger} factory |
| * method for the current default locale. |
| * <br>Note that if the result is {@code null}, then the Logger will use a resource |
| * bundle or resource bundle name inherited from its parent. |
| * |
| * @return localization bundle (may be {@code null}) |
| */ |
| public ResourceBundle getResourceBundle() { |
| return findResourceBundle(getResourceBundleName(), true); |
| } |
| |
| /** |
| * Retrieve the localization resource bundle name for this |
| * logger. |
| * This is either the name specified through the {@link |
| * #getLogger(java.lang.String, java.lang.String) getLogger} factory method, |
| * or the {@linkplain ResourceBundle#getBaseBundleName() base name} of the |
| * ResourceBundle set through {@link |
| * #setResourceBundle(java.util.ResourceBundle) setResourceBundle} method. |
| * <br>Note that if the result is {@code null}, then the Logger will use a resource |
| * bundle or resource bundle name inherited from its parent. |
| * |
| * @return localization bundle name (may be {@code null}) |
| */ |
| public String getResourceBundleName() { |
| return loggerBundle.resourceBundleName; |
| } |
| |
| /** |
| * Set a filter to control output on this Logger. |
| * <P> |
| * After passing the initial "level" check, the Logger will |
| * call this Filter to check if a log record should really |
| * be published. |
| * |
| * @param newFilter a filter object (may be null) |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| */ |
| public void setFilter(Filter newFilter) throws SecurityException { |
| checkPermission(); |
| filter = newFilter; |
| } |
| |
| /** |
| * Get the current filter for this Logger. |
| * |
| * @return a filter object (may be null) |
| */ |
| public Filter getFilter() { |
| return filter; |
| } |
| |
| /** |
| * Log a LogRecord. |
| * <p> |
| * 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. |
| * |
| * @param record the LogRecord to be published |
| */ |
| public void log(LogRecord record) { |
| if (!isLoggable(record.getLevel())) { |
| 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) { |
| final Handler[] loggerHandlers = isSystemLogger |
| ? logger.accessCheckedHandlers() |
| : logger.getHandlers(); |
| |
| for (Handler handler : loggerHandlers) { |
| handler.publish(record); |
| } |
| |
| final boolean useParentHdls = isSystemLogger |
| ? logger.useParentHandlers |
| : logger.getUseParentHandlers(); |
| |
| if (!useParentHdls) { |
| break; |
| } |
| |
| logger = isSystemLogger ? logger.parent : logger.getParent(); |
| } |
| } |
| |
| // private support method for logging. |
| // We fill in the logger name, resource bundle name, and |
| // resource bundle and then call "void log(LogRecord)". |
| private void doLog(LogRecord lr) { |
| lr.setLoggerName(name); |
| final LoggerBundle lb = getEffectiveLoggerBundle(); |
| final ResourceBundle bundle = lb.userBundle; |
| final String ebname = lb.resourceBundleName; |
| if (ebname != null && bundle != null) { |
| lr.setResourceBundleName(ebname); |
| lr.setResourceBundle(bundle); |
| } |
| log(lr); |
| } |
| |
| |
| //================================================================ |
| // Start of convenience methods WITHOUT className and methodName |
| //================================================================ |
| |
| /** |
| * Log a message, with no arguments. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void log(Level level, String msg) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a message, which is only to be constructed if the logging level |
| * is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void log(Level level, Supplier<String> msgSupplier) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msgSupplier.get()); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a message, with one object parameter. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param msg The string message (or a key in the message catalog) |
| * @param param1 parameter to the message |
| */ |
| public void log(Level level, String msg, Object param1) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| Object params[] = { param1 }; |
| lr.setParameters(params); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a message, with an array of object arguments. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param msg The string message (or a key in the message catalog) |
| * @param params array of parameters to the message |
| */ |
| public void log(Level level, String msg, Object params[]) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setParameters(params); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a message, with associated Throwable information. |
| * <p> |
| * 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. |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param msg The string message (or a key in the message catalog) |
| * @param thrown Throwable associated with log message. |
| */ |
| public void log(Level level, String msg, Throwable thrown) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setThrown(thrown); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a lazily constructed message, with associated Throwable information. |
| * <p> |
| * If the logger is currently enabled for the given message level then the |
| * message is constructed by invoking the provided supplier function. The |
| * message and the given {@link Throwable} are then stored in a {@link |
| * LogRecord} which is forwarded to all registered output handlers. |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param thrown Throwable associated with log message. |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void log(Level level, Throwable thrown, Supplier<String> msgSupplier) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msgSupplier.get()); |
| lr.setThrown(thrown); |
| doLog(lr); |
| } |
| |
| //================================================================ |
| // Start of convenience methods WITH className and methodName |
| //================================================================ |
| |
| /** |
| * Log a message, specifying source class and method, |
| * with no arguments. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, String msg) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a lazily constructed message, specifying source class and method, |
| * with no arguments. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| Supplier<String> msgSupplier) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msgSupplier.get()); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a message, specifying source class and method, |
| * with a single object parameter to the log message. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param msg The string message (or a key in the message catalog) |
| * @param param1 Parameter to the log message. |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String msg, Object param1) { |
| if (!isLoggable(level)) { |
| 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 an array of object arguments. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param msg The string message (or a key in the message catalog) |
| * @param params Array of parameters to the message |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String msg, Object params[]) { |
| if (!isLoggable(level)) { |
| 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 associated Throwable information. |
| * <p> |
| * 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. |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param msg The string message (or a key in the message catalog) |
| * @param thrown Throwable associated with log message. |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String msg, Throwable thrown) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| lr.setThrown(thrown); |
| doLog(lr); |
| } |
| |
| /** |
| * Log a lazily constructed message, specifying source class and method, |
| * with associated Throwable information. |
| * <p> |
| * If the logger is currently enabled for the given message level then the |
| * message is constructed by invoking the provided supplier function. The |
| * message and the given {@link Throwable} are then stored in a {@link |
| * LogRecord} which is forwarded to all registered output handlers. |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param thrown Throwable associated with log message. |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| Throwable thrown, Supplier<String> msgSupplier) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msgSupplier.get()); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| lr.setThrown(thrown); |
| doLog(lr); |
| } |
| |
| |
| //========================================================================= |
| // Start of convenience methods WITH className, methodName and bundle name. |
| //========================================================================= |
| |
| // Private support method for logging for "logrb" methods. |
| // We fill in the logger name, resource bundle name, and |
| // resource bundle and then call "void log(LogRecord)". |
| private void doLog(LogRecord lr, String rbname) { |
| lr.setLoggerName(name); |
| if (rbname != null) { |
| lr.setResourceBundleName(rbname); |
| lr.setResourceBundle(findResourceBundle(rbname, false)); |
| } |
| log(lr); |
| } |
| |
| // Private support method for logging for "logrb" methods. |
| private void doLog(LogRecord lr, ResourceBundle rb) { |
| lr.setLoggerName(name); |
| if (rb != null) { |
| lr.setResourceBundleName(rb.getBaseBundleName()); |
| lr.setResourceBundle(rb); |
| } |
| log(lr); |
| } |
| |
| /** |
| * Log a message, specifying source class, method, and resource bundle name |
| * with no arguments. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param bundleName name of resource bundle to localize msg, |
| * can be null |
| * @param msg The string message (or a key in the message catalog) |
| * @deprecated Use {@link #logrb(java.util.logging.Level, java.lang.String, |
| * java.lang.String, java.util.ResourceBundle, java.lang.String, |
| * java.lang.Object...)} instead. |
| */ |
| @Deprecated |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String msg) { |
| if (!isLoggable(level)) { |
| 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 a single object parameter to the log message. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param bundleName name of resource bundle to localize msg, |
| * can be null |
| * @param msg The string message (or a key in the message catalog) |
| * @param param1 Parameter to the log message. |
| * @deprecated Use {@link #logrb(java.util.logging.Level, java.lang.String, |
| * java.lang.String, java.util.ResourceBundle, java.lang.String, |
| * java.lang.Object...)} instead |
| */ |
| @Deprecated |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Object param1) { |
| if (!isLoggable(level)) { |
| 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 an array of object arguments. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param bundleName name of resource bundle to localize msg, |
| * can be null. |
| * @param msg The string message (or a key in the message catalog) |
| * @param params Array of parameters to the message |
| * @deprecated Use {@link #logrb(java.util.logging.Level, java.lang.String, |
| * java.lang.String, java.util.ResourceBundle, java.lang.String, |
| * java.lang.Object...)} instead. |
| */ |
| @Deprecated |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Object params[]) { |
| if (!isLoggable(level)) { |
| 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, |
| * with an optional list of message parameters. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * {@code level} then a corresponding {@code LogRecord} is created and |
| * forwarded to all the registered output {@code Handler} objects. |
| * <p> |
| * The {@code msg} string is localized using the given resource bundle. |
| * If the resource bundle is {@code null}, then the {@code msg} string is not |
| * localized. |
| * |
| * @param level One of the message level identifiers, e.g., {@code SEVERE} |
| * @param sourceClass Name of the class that issued the logging request |
| * @param sourceMethod Name of the method that issued the logging request |
| * @param bundle Resource bundle to localize {@code msg}, |
| * can be {@code null}. |
| * @param msg The string message (or a key in the message catalog) |
| * @param params Parameters to the message (optional, may be none). |
| * @since 1.8 |
| */ |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| ResourceBundle bundle, String msg, Object... params) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| if (params != null && params.length != 0) { |
| lr.setParameters(params); |
| } |
| doLog(lr, bundle); |
| } |
| |
| /** |
| * Log a message, specifying source class, method, and resource bundle, |
| * with an optional list of message parameters. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * {@code level} then a corresponding {@code LogRecord} is created |
| * and forwarded to all the registered output {@code Handler} objects. |
| * <p> |
| * The {@code msg} string is localized using the given resource bundle. |
| * If the resource bundle is {@code null}, then the {@code msg} string is not |
| * localized. |
| * <p> |
| * @param level One of the message level identifiers, e.g., {@code SEVERE} |
| * @param bundle Resource bundle to localize {@code msg}; |
| * can be {@code null}. |
| * @param msg The string message (or a key in the message catalog) |
| * @param params Parameters to the message (optional, may be none). |
| * @since 9 |
| */ |
| public void logrb(Level level, ResourceBundle bundle, String msg, Object... params) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| if (params != null && params.length != 0) { |
| lr.setParameters(params); |
| } |
| doLog(lr, bundle); |
| } |
| |
| /** |
| * Log a message, specifying source class, method, and resource bundle name, |
| * with associated Throwable information. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param level One of the message level identifiers, e.g., SEVERE |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that issued the logging request |
| * @param bundleName name of resource bundle to localize msg, |
| * can be null |
| * @param msg The string message (or a key in the message catalog) |
| * @param thrown Throwable associated with log message. |
| * @deprecated Use {@link #logrb(java.util.logging.Level, java.lang.String, |
| * java.lang.String, java.util.ResourceBundle, java.lang.String, |
| * java.lang.Throwable)} instead. |
| */ |
| @Deprecated |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Throwable thrown) { |
| if (!isLoggable(level)) { |
| 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, |
| * with associated Throwable information. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * {@code level} then the given arguments are stored in a {@code LogRecord} |
| * which is forwarded to all registered output handlers. |
| * <p> |
| * The {@code msg} string is localized using the given resource bundle. |
| * If the resource bundle is {@code null}, then the {@code msg} string is not |
| * localized. |
| * <p> |
| * Note that the {@code thrown} argument is stored in the {@code LogRecord} |
| * {@code thrown} property, rather than the {@code LogRecord} |
| * {@code parameters} property. Thus it is |
| * processed specially by output {@code Formatter} objects and is not treated |
| * as a formatting parameter to the {@code LogRecord} {@code message} property. |
| * |
| * @param level One of the message level identifiers, e.g., {@code SEVERE} |
| * @param sourceClass Name of the class that issued the logging request |
| * @param sourceMethod Name of the method that issued the logging request |
| * @param bundle Resource bundle to localize {@code msg}, |
| * can be {@code null} |
| * @param msg The string message (or a key in the message catalog) |
| * @param thrown Throwable associated with the log message. |
| * @since 1.8 |
| */ |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| ResourceBundle bundle, String msg, Throwable thrown) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| lr.setThrown(thrown); |
| doLog(lr, bundle); |
| } |
| |
| /** |
| * Log a message, specifying source class, method, and resource bundle, |
| * with associated Throwable information. |
| * <p> |
| * If the logger is currently enabled for the given message |
| * {@code level} then the given arguments are stored in a {@code LogRecord} |
| * which is forwarded to all registered output handlers. |
| * <p> |
| * The {@code msg} string is localized using the given resource bundle. |
| * If the resource bundle is {@code null}, then the {@code msg} string is not |
| * localized. |
| * <p> |
| * Note that the {@code thrown} argument is stored in the {@code LogRecord} |
| * {@code thrown} property, rather than the {@code LogRecord} |
| * {@code parameters} property. Thus it is |
| * processed specially by output {@code Formatter} objects and is not treated |
| * as a formatting parameter to the {@code LogRecord} {@code message} |
| * property. |
| * <p> |
| * @param level One of the message level identifiers, e.g., {@code SEVERE} |
| * @param bundle Resource bundle to localize {@code msg}; |
| * can be {@code null}. |
| * @param msg The string message (or a key in the message catalog) |
| * @param thrown Throwable associated with the log message. |
| * @since 9 |
| */ |
| public void logrb(Level level, ResourceBundle bundle, String msg, |
| Throwable thrown) { |
| if (!isLoggable(level)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(level, msg); |
| lr.setThrown(thrown); |
| doLog(lr, bundle); |
| } |
| |
| //====================================================================== |
| // Start of convenience methods for logging method entries and returns. |
| //====================================================================== |
| |
| /** |
| * Log a method entry. |
| * <p> |
| * 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. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that is being entered |
| */ |
| public void entering(String sourceClass, String sourceMethod) { |
| logp(Level.FINER, sourceClass, sourceMethod, "ENTRY"); |
| } |
| |
| /** |
| * Log a method entry, with one parameter. |
| * <p> |
| * 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. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that is being entered |
| * @param param1 parameter to the method being entered |
| */ |
| public void entering(String sourceClass, String sourceMethod, Object param1) { |
| logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", param1); |
| } |
| |
| /** |
| * Log a method entry, with an array of parameters. |
| * <p> |
| * 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. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of method that is being entered |
| * @param params array of parameters to the method being entered |
| */ |
| public void entering(String sourceClass, String sourceMethod, Object params[]) { |
| String msg = "ENTRY"; |
| if (params == null ) { |
| logp(Level.FINER, sourceClass, sourceMethod, msg); |
| return; |
| } |
| if (!isLoggable(Level.FINER)) return; |
| if (params.length > 0) { |
| final StringBuilder b = new StringBuilder(msg); |
| for (int i = 0; i < params.length; i++) { |
| b.append(' ').append('{').append(i).append('}'); |
| } |
| msg = b.toString(); |
| } |
| logp(Level.FINER, sourceClass, sourceMethod, msg, params); |
| } |
| |
| /** |
| * Log a method return. |
| * <p> |
| * 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. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of the method |
| */ |
| public void exiting(String sourceClass, String sourceMethod) { |
| logp(Level.FINER, sourceClass, sourceMethod, "RETURN"); |
| } |
| |
| |
| /** |
| * Log a method return, with result object. |
| * <p> |
| * 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. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of the method |
| * @param result Object that is being returned |
| */ |
| public void exiting(String sourceClass, String sourceMethod, Object result) { |
| logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result); |
| } |
| |
| /** |
| * Log throwing an exception. |
| * <p> |
| * This is a convenience method to log that a method is |
| * terminating by throwing an exception. The logging is done |
| * using the FINER level. |
| * <p> |
| * 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". |
| * <p> |
| * Note that the thrown argument is stored in the LogRecord thrown |
| * property, rather than the LogRecord parameters property. Thus it is |
| * processed specially by output Formatters and is not treated |
| * as a formatting parameter to the LogRecord message property. |
| * |
| * @param sourceClass name of class that issued the logging request |
| * @param sourceMethod name of the method. |
| * @param thrown The Throwable that is being thrown. |
| */ |
| public void throwing(String sourceClass, String sourceMethod, Throwable thrown) { |
| if (!isLoggable(Level.FINER)) { |
| return; |
| } |
| LogRecord lr = new LogRecord(Level.FINER, "THROW"); |
| lr.setSourceClassName(sourceClass); |
| lr.setSourceMethodName(sourceMethod); |
| lr.setThrown(thrown); |
| doLog(lr); |
| } |
| |
| //======================================================================= |
| // Start of simple convenience methods using level names as method names |
| //======================================================================= |
| |
| /** |
| * Log a SEVERE message. |
| * <p> |
| * If the logger is currently enabled for the SEVERE message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void severe(String msg) { |
| log(Level.SEVERE, msg); |
| } |
| |
| /** |
| * Log a WARNING message. |
| * <p> |
| * If the logger is currently enabled for the WARNING message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void warning(String msg) { |
| log(Level.WARNING, msg); |
| } |
| |
| /** |
| * Log an INFO message. |
| * <p> |
| * If the logger is currently enabled for the INFO message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void info(String msg) { |
| log(Level.INFO, msg); |
| } |
| |
| /** |
| * Log a CONFIG message. |
| * <p> |
| * If the logger is currently enabled for the CONFIG message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void config(String msg) { |
| log(Level.CONFIG, msg); |
| } |
| |
| /** |
| * Log a FINE message. |
| * <p> |
| * If the logger is currently enabled for the FINE message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void fine(String msg) { |
| log(Level.FINE, msg); |
| } |
| |
| /** |
| * Log a FINER message. |
| * <p> |
| * If the logger is currently enabled for the FINER message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void finer(String msg) { |
| log(Level.FINER, msg); |
| } |
| |
| /** |
| * Log a FINEST message. |
| * <p> |
| * If the logger is currently enabled for the FINEST message |
| * level then the given message is forwarded to all the |
| * registered output Handler objects. |
| * |
| * @param msg The string message (or a key in the message catalog) |
| */ |
| public void finest(String msg) { |
| log(Level.FINEST, msg); |
| } |
| |
| //======================================================================= |
| // Start of simple convenience methods using level names as method names |
| // and use Supplier<String> |
| //======================================================================= |
| |
| /** |
| * Log a SEVERE message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the SEVERE message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void severe(Supplier<String> msgSupplier) { |
| log(Level.SEVERE, msgSupplier); |
| } |
| |
| /** |
| * Log a WARNING message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the WARNING message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void warning(Supplier<String> msgSupplier) { |
| log(Level.WARNING, msgSupplier); |
| } |
| |
| /** |
| * Log a INFO message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the INFO message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void info(Supplier<String> msgSupplier) { |
| log(Level.INFO, msgSupplier); |
| } |
| |
| /** |
| * Log a CONFIG message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the CONFIG message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void config(Supplier<String> msgSupplier) { |
| log(Level.CONFIG, msgSupplier); |
| } |
| |
| /** |
| * Log a FINE message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the FINE message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void fine(Supplier<String> msgSupplier) { |
| log(Level.FINE, msgSupplier); |
| } |
| |
| /** |
| * Log a FINER message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the FINER message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void finer(Supplier<String> msgSupplier) { |
| log(Level.FINER, msgSupplier); |
| } |
| |
| /** |
| * Log a FINEST message, which is only to be constructed if the logging |
| * level is such that the message will actually be logged. |
| * <p> |
| * If the logger is currently enabled for the FINEST message |
| * level then the message is constructed by invoking the provided |
| * supplier function and forwarded to all the registered output |
| * Handler objects. |
| * |
| * @param msgSupplier A function, which when called, produces the |
| * desired log message |
| * @since 1.8 |
| */ |
| public void finest(Supplier<String> msgSupplier) { |
| log(Level.FINEST, msgSupplier); |
| } |
| |
| //================================================================ |
| // End of convenience methods |
| //================================================================ |
| |
| /** |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param newLevel the new value for the log level (may be null) |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| */ |
| public void setLevel(Level newLevel) throws SecurityException { |
| checkPermission(); |
| synchronized (treeLock) { |
| levelObject = newLevel; |
| updateEffectiveLevel(); |
| } |
| } |
| |
| final boolean isLevelInitialized() { |
| return levelObject != null; |
| } |
| |
| /** |
| * 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. |
| * |
| * @return this Logger's level |
| */ |
| public Level getLevel() { |
| return levelObject; |
| } |
| |
| /** |
| * 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. |
| * |
| * @param level a message logging level |
| * @return true if the given message level is currently being logged. |
| */ |
| public boolean isLoggable(Level level) { |
| if (level.intValue() < levelValue || levelValue == offValue) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Get the name for this logger. |
| * @return logger name. Will be null for anonymous Loggers. |
| */ |
| public String getName() { |
| return name; |
| } |
| |
| /** |
| * Add a log Handler to receive logging messages. |
| * <p> |
| * 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. |
| * |
| * @param handler a logging Handler |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| */ |
| public void addHandler(Handler handler) throws SecurityException { |
| Objects.requireNonNull(handler); |
| checkPermission(); |
| handlers.add(handler); |
| } |
| |
| /** |
| * Remove a log Handler. |
| * <P> |
| * Returns silently if the given Handler is not found or is null |
| * |
| * @param handler a logging Handler |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| */ |
| public void removeHandler(Handler handler) throws SecurityException { |
| checkPermission(); |
| if (handler == null) { |
| return; |
| } |
| handlers.remove(handler); |
| } |
| |
| /** |
| * Get the Handlers associated with this logger. |
| * |
| * @return an array of all registered Handlers |
| */ |
| public Handler[] getHandlers() { |
| return accessCheckedHandlers(); |
| } |
| |
| // This method should ideally be marked final - but unfortunately |
| // it needs to be overridden by LogManager.RootLogger |
| Handler[] accessCheckedHandlers() { |
| return handlers.toArray(emptyHandlers); |
| } |
| |
| /** |
| * 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. |
| * |
| * @param useParentHandlers true if output is to be sent to the |
| * logger's parent. |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| */ |
| public void setUseParentHandlers(boolean useParentHandlers) { |
| checkPermission(); |
| this.useParentHandlers = useParentHandlers; |
| } |
| |
| /** |
| * Discover whether or not this logger is sending its output |
| * to its parent logger. |
| * |
| * @return true if output is to be sent to the logger's parent |
| */ |
| public boolean getUseParentHandlers() { |
| return useParentHandlers; |
| } |
| |
| /** |
| * Private utility method to map a resource bundle name to an |
| * actual resource bundle, using a simple one-entry cache. |
| * Returns null for a null name. |
| * May also return null if we can't find the resource bundle and |
| * there is no suitable previous cached value. |
| * |
| * @param name the ResourceBundle to locate |
| * @param useCallersModule if true search using the caller's module. |
| * @return ResourceBundle specified by name or null if not found |
| */ |
| private synchronized ResourceBundle findResourceBundle(String name, |
| boolean useCallersModule) { |
| // When this method is called from logrb, useCallersModule==false, and |
| // the resource bundle 'name' is the argument provided to logrb. |
| // It may, or may not be, equal to lb.resourceBundleName. |
| // Otherwise, useCallersModule==true, and name is the resource bundle |
| // name that is set (or will be set) in this logger. |
| // |
| // When useCallersModule is false, or when the caller's module is |
| // null, or when the caller's module is an unnamed module, we look |
| // first in the TCCL (or the System ClassLoader if the TCCL is null) |
| // to locate the resource bundle. |
| // |
| // Otherwise, if useCallersModule is true, and the caller's module is not |
| // null, and the caller's module is named, we look in the caller's module |
| // to locate the resource bundle. |
| // |
| // Finally, if the caller's module is not null and is unnamed, and |
| // useCallersModule is true, we look in the caller's module class loader |
| // (unless we already looked there in step 1). |
| |
| // Return a null bundle for a null name. |
| if (name == null) { |
| return null; |
| } |
| |
| Locale currentLocale = Locale.getDefault(); |
| final LoggerBundle lb = loggerBundle; |
| |
| // Normally we should hit on our simple one entry cache. |
| if (lb.userBundle != null && |
| name.equals(lb.resourceBundleName)) { |
| return lb.userBundle; |
| } else if (catalog != null && currentLocale.equals(catalogLocale) |
| && name.equals(catalogName)) { |
| return catalog; |
| } |
| |
| // Use the thread's context ClassLoader. If there isn't one, use the |
| // {@linkplain java.lang.ClassLoader#getSystemClassLoader() system ClassLoader}. |
| ClassLoader cl = Thread.currentThread().getContextClassLoader(); |
| if (cl == null) { |
| cl = ClassLoader.getSystemClassLoader(); |
| } |
| |
| final Module callerModule = getCallerModule(); |
| |
| // If useCallersModule is false, we are called by logrb, with a name |
| // that is provided by the user. In that case we will look in the TCCL. |
| // We also look in the TCCL if callerModule is null or unnamed. |
| if (!useCallersModule || callerModule == null || !callerModule.isNamed()) { |
| try { |
| Module mod = cl.getUnnamedModule(); |
| PrivilegedAction<ResourceBundle> pa = () -> |
| ResourceBundle.getBundle(name, currentLocale, mod); |
| catalog = AccessController.doPrivileged(pa, null, GET_CLASS_LOADER_PERMISSION); |
| catalogName = name; |
| catalogLocale = currentLocale; |
| return catalog; |
| } catch (MissingResourceException ex) { |
| // We can't find the ResourceBundle in the default |
| // ClassLoader. Drop through. |
| if (useCallersModule && callerModule != null) { |
| try { |
| // We are called by an unnamed module: try with the |
| // unnamed module class loader: |
| PrivilegedAction<ClassLoader> getModuleClassLoader = |
| () -> callerModule.getClassLoader(); |
| ClassLoader moduleCL = |
| AccessController.doPrivileged(getModuleClassLoader); |
| // moduleCL can be null if the logger is created by a class |
| // appended to the bootclasspath. |
| // If moduleCL is null we would use cl, but we already tried |
| // that above (we first looked in the TCCL for unnamed |
| // caller modules) - so there no point in trying again: we |
| // won't find anything more this second time. |
| // In this case just return null. |
| if (moduleCL == cl || moduleCL == null) return null; |
| |
| // we already tried the TCCL and found nothing - so try |
| // with the module's loader this time. |
| catalog = ResourceBundle.getBundle(name, currentLocale, |
| moduleCL); |
| catalogName = name; |
| catalogLocale = currentLocale; |
| return catalog; |
| } catch (MissingResourceException x) { |
| return null; // no luck |
| } |
| } else { |
| return null; |
| } |
| } |
| } else { |
| // we should have: |
| // useCallersModule && callerModule != null && callerModule.isNamed(); |
| // Try with the caller's module |
| try { |
| // Use the caller's module |
| PrivilegedAction<ResourceBundle> pa = () -> |
| ResourceBundle.getBundle(name, currentLocale, callerModule); |
| catalog = AccessController.doPrivileged(pa, null, GET_CLASS_LOADER_PERMISSION); |
| catalogName = name; |
| catalogLocale = currentLocale; |
| return catalog; |
| } catch (MissingResourceException ex) { |
| return null; // no luck |
| } |
| } |
| } |
| |
| // Private utility method to initialize our one entry |
| // resource bundle name cache and the callers Module |
| // Note: for consistency reasons, we are careful to check |
| // that a suitable ResourceBundle exists before setting the |
| // resourceBundleName field. |
| // Synchronized to prevent races in setting the fields. |
| private synchronized void setupResourceInfo(String name, |
| Class<?> callerClass) { |
| final LoggerBundle lb = loggerBundle; |
| if (lb.resourceBundleName != null) { |
| // this Logger already has a ResourceBundle |
| |
| if (lb.resourceBundleName.equals(name)) { |
| // the names match so there is nothing more to do |
| return; |
| } |
| |
| // cannot change ResourceBundles once they are set |
| throw new IllegalArgumentException( |
| lb.resourceBundleName + " != " + name); |
| } |
| |
| if (name == null) { |
| return; |
| } |
| |
| setCallerModuleRef(callerClass); |
| if (isSystemLogger && (callerClass != null && callerClass.getClassLoader() != null)) { |
| checkPermission(); |
| } |
| |
| if (name.equals(SYSTEM_LOGGER_RB_NAME)) { |
| loggerBundle = SYSTEM_BUNDLE; |
| } else { |
| ResourceBundle bundle = findResourceBundle(name, true); |
| if (bundle == null) { |
| // We've failed to find an expected ResourceBundle. |
| // unset the caller's module since we were unable to find the |
| // the bundle using it |
| this.callerModuleRef = null; |
| throw new MissingResourceException("Can't find " + name + " bundle from ", |
| name, ""); |
| } |
| |
| loggerBundle = LoggerBundle.get(name, null); |
| } |
| } |
| |
| /** |
| * Sets a resource bundle on this logger. |
| * All messages will be logged using the given resource bundle for its |
| * specific {@linkplain ResourceBundle#getLocale locale}. |
| * @param bundle The resource bundle that this logger shall use. |
| * @throws NullPointerException if the given bundle is {@code null}. |
| * @throws IllegalArgumentException if the given bundle doesn't have a |
| * {@linkplain ResourceBundle#getBaseBundleName base name}, |
| * or if this logger already has a resource bundle set but |
| * the given bundle has a different base name. |
| * @throws SecurityException if a security manager exists, |
| * this logger is not anonymous, and the caller |
| * does not have LoggingPermission("control"). |
| * @since 1.8 |
| */ |
| public void setResourceBundle(ResourceBundle bundle) { |
| checkPermission(); |
| |
| // Will throw NPE if bundle is null. |
| final String baseName = bundle.getBaseBundleName(); |
| |
| // bundle must have a name |
| if (baseName == null || baseName.isEmpty()) { |
| throw new IllegalArgumentException("resource bundle must have a name"); |
| } |
| |
| synchronized (this) { |
| LoggerBundle lb = loggerBundle; |
| final boolean canReplaceResourceBundle = lb.resourceBundleName == null |
| || lb.resourceBundleName.equals(baseName); |
| |
| if (!canReplaceResourceBundle) { |
| throw new IllegalArgumentException("can't replace resource bundle"); |
| } |
| |
| |
| loggerBundle = LoggerBundle.get(baseName, bundle); |
| } |
| } |
| |
| /** |
| * Return the parent for this Logger. |
| * <p> |
| * 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". |
| * <p> |
| * The result will be null if it is called on the root Logger |
| * in the namespace. |
| * |
| * @return nearest existing parent 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; |
| } |
| |
| /** |
| * Set the parent for this Logger. This method is used by |
| * the LogManager to update a Logger when the namespace changes. |
| * <p> |
| * It should not be called from application code. |
| * |
| * @param parent the new parent logger |
| * @throws SecurityException if a security manager exists and if |
| * the caller does not have LoggingPermission("control"). |
| */ |
| public void setParent(Logger parent) { |
| if (parent == null) { |
| throw new NullPointerException(); |
| } |
| |
| // check permission for all loggers, including anonymous loggers |
| if (manager == null) { |
| manager = LogManager.getLogManager(); |
| } |
| manager.checkPermission(); |
| |
| doSetParent(parent); |
| } |
| |
| // Private method to do the work for parenting a child |
| // Logger onto a parent logger. |
| private void doSetParent(Logger newParent) { |
| |
| // System.err.println("doSetParent \"" + getName() + "\" \"" |
| // + newParent.getName() + "\""); |
| |
| synchronized (treeLock) { |
| |
| // Remove ourself from any previous parent. |
| LogManager.LoggerWeakRef ref = null; |
| if (parent != null) { |
| // assert parent.kids != null; |
| for (Iterator<LogManager.LoggerWeakRef> iter = parent.kids.iterator(); iter.hasNext(); ) { |
| ref = iter.next(); |
| Logger kid = ref.get(); |
| if (kid == this) { |
| // ref is used down below to complete the reparenting |
| iter.remove(); |
| break; |
| } else { |
| ref = null; |
| } |
| } |
| // We have now removed ourself from our parents' kids. |
| } |
| |
| // Set our new parent. |
| parent = newParent; |
| if (parent.kids == null) { |
| parent.kids = new ArrayList<>(2); |
| } |
| if (ref == null) { |
| // we didn't have a previous parent |
| ref = manager.new LoggerWeakRef(this); |
| } |
| ref.setParentRef(new WeakReference<>(parent)); |
| parent.kids.add(ref); |
| |
| // As a result of the reparenting, the effective level |
| // may have changed for us and our children. |
| updateEffectiveLevel(); |
| |
| } |
| } |
| |
| // Package-level method. |
| // Remove the weak reference for the specified child Logger from the |
| // kid list. We should only be called from LoggerWeakRef.dispose(). |
| final void removeChildLogger(LogManager.LoggerWeakRef child) { |
| synchronized (treeLock) { |
| for (Iterator<LogManager.LoggerWeakRef> iter = kids.iterator(); iter.hasNext(); ) { |
| LogManager.LoggerWeakRef ref = iter.next(); |
| if (ref == child) { |
| iter.remove(); |
| return; |
| } |
| } |
| } |
| } |
| |
| // Recalculate the effective level for this node and |
| // recursively for our children. |
| |
| private void updateEffectiveLevel() { |
| // assert Thread.holdsLock(treeLock); |
| |
| // Figure out our current effective level. |
| int newLevelValue; |
| if (levelObject != null) { |
| newLevelValue = levelObject.intValue(); |
| } else { |
| if (parent != null) { |
| newLevelValue = parent.levelValue; |
| } else { |
| // This may happen during initialization. |
| newLevelValue = Level.INFO.intValue(); |
| } |
| } |
| |
| // If our effective value hasn't changed, we're done. |
| if (levelValue == newLevelValue) { |
| return; |
| } |
| |
| levelValue = newLevelValue; |
| |
| // System.err.println("effective level: \"" + getName() + "\" := " + level); |
| |
| // Recursively update the level on each of our kids. |
| if (kids != null) { |
| for (LogManager.LoggerWeakRef ref : kids) { |
| Logger kid = ref.get(); |
| if (kid != null) { |
| kid.updateEffectiveLevel(); |
| } |
| } |
| } |
| } |
| |
| |
| // Private method to get the potentially inherited |
| // resource bundle and resource bundle name for this Logger. |
| // This method never returns null. |
| private LoggerBundle getEffectiveLoggerBundle() { |
| final LoggerBundle lb = loggerBundle; |
| if (lb.isSystemBundle()) { |
| return SYSTEM_BUNDLE; |
| } |
| |
| // first take care of this logger |
| final ResourceBundle b = getResourceBundle(); |
| if (b != null && b == lb.userBundle) { |
| return lb; |
| } else if (b != null) { |
| // either lb.userBundle is null or getResourceBundle() is |
| // overriden |
| final String rbName = getResourceBundleName(); |
| return LoggerBundle.get(rbName, b); |
| } |
| |
| // no resource bundle was specified on this logger, look up the |
| // parent stack. |
| Logger target = this.parent; |
| while (target != null) { |
| final LoggerBundle trb = target.loggerBundle; |
| if (trb.isSystemBundle()) { |
| return SYSTEM_BUNDLE; |
| } |
| if (trb.userBundle != null) { |
| return trb; |
| } |
| final String rbName = isSystemLogger |
| // ancestor of a system logger is expected to be a system logger. |
| // ignore resource bundle name if it's not. |
| ? (target.isSystemLogger ? trb.resourceBundleName : null) |
| : target.getResourceBundleName(); |
| if (rbName != null) { |
| return LoggerBundle.get(rbName, |
| findResourceBundle(rbName, true)); |
| } |
| target = isSystemLogger ? target.parent : target.getParent(); |
| } |
| return NO_RESOURCE_BUNDLE; |
| } |
| |
| } |