| /* Logger.java -- a class for logging messages |
| Copyright (C) 2002, 2004, 2006, 2007 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.util.logging; |
| |
| import gnu.java.lang.CPStringBuilder; |
| |
| import java.util.List; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| /** |
| * A Logger is used for logging information about events. Usually, there is a |
| * seprate logger for each subsystem or component, although there is a shared |
| * instance for components that make only occasional use of the logging |
| * framework. |
| * <p> |
| * It is common to name a logger after the name of a corresponding Java package. |
| * Loggers are organized into a hierarchical namespace; for example, the logger |
| * <code>"org.gnu.foo"</code> is the <em>parent</em> of logger |
| * <code>"org.gnu.foo.bar"</code>. |
| * <p> |
| * A logger for a named subsystem can be obtained through {@link |
| * java.util.logging.Logger#getLogger(java.lang.String)}. However, only code |
| * which has been granted the permission to control the logging infrastructure |
| * will be allowed to customize that logger. Untrusted code can obtain a |
| * private, anonymous logger through {@link #getAnonymousLogger()} if it wants |
| * to perform any modifications to the logger. |
| * <p> |
| * FIXME: Write more documentation. |
| * |
| * @author Sascha Brawer (brawer@acm.org) |
| */ |
| public class Logger |
| { |
| static final Logger root = new Logger("", null); |
| |
| /** |
| * A logger provided to applications that make only occasional use of the |
| * logging framework, typically early prototypes. Serious products are |
| * supposed to create and use their own Loggers, so they can be controlled |
| * individually. |
| */ |
| public static final Logger global; |
| |
| /** |
| * Use to lock methods on this class instead of calling synchronize on methods |
| * to avoid deadlocks. Yeah, no kidding, we got them :) |
| */ |
| private static final Object[] lock = new Object[0]; |
| |
| static |
| { |
| // Our class might be initialized from an unprivileged context |
| global = (Logger) AccessController.doPrivileged(new PrivilegedAction() |
| { |
| public Object run() |
| { |
| return getLogger("global"); |
| } |
| }); |
| } |
| |
| /** |
| * The name of the Logger, or <code>null</code> if the logger is anonymous. |
| * <p> |
| * A previous version of the GNU Classpath implementation granted untrusted |
| * code the permission to control any logger whose name was null. However, |
| * test code revealed that the Sun J2SE 1.4 reference implementation enforces |
| * the security control for any logger that was not created through |
| * getAnonymousLogger, even if it has a null name. Therefore, a separate flag |
| * {@link Logger#anonymous} was introduced. |
| */ |
| private final String name; |
| |
| /** |
| * The name of the resource bundle used for localization. |
| * <p> |
| * This variable cannot be declared as <code>final</code> because its value |
| * can change as a result of calling getLogger(String,String). |
| */ |
| private String resourceBundleName; |
| |
| /** |
| * The resource bundle used for localization. |
| * <p> |
| * This variable cannot be declared as <code>final</code> because its value |
| * can change as a result of calling getLogger(String,String). |
| */ |
| private ResourceBundle resourceBundle; |
| |
| private Filter filter; |
| |
| private final List handlerList = new java.util.ArrayList(4); |
| |
| private Handler[] handlers = new Handler[0]; |
| |
| /** |
| * Indicates whether or not this logger is anonymous. While a |
| * LoggingPermission is required for any modifications to a normal logger, |
| * untrusted code can obtain an anonymous logger and modify it according to |
| * its needs. |
| * <p> |
| * A previous version of the GNU Classpath implementation granted access to |
| * every logger whose name was null. However, test code revealed that the Sun |
| * J2SE 1.4 reference implementation enforces the security control for any |
| * logger that was not created through getAnonymousLogger, even if it has a |
| * null name. |
| */ |
| private boolean anonymous; |
| |
| private boolean useParentHandlers; |
| |
| private Level level; |
| |
| private Logger parent; |
| |
| /** |
| * Constructs a Logger for a subsystem. Most applications do not need to |
| * create new Loggers explicitly; instead, they should call the static factory |
| * methods {@link #getLogger(java.lang.String,java.lang.String) getLogger} |
| * (with ResourceBundle for localization) or |
| * {@link #getLogger(java.lang.String) getLogger} (without ResourceBundle), |
| * respectively. |
| * |
| * @param name the name for the logger, for example "java.awt" or |
| * "com.foo.bar". The name should be based on the name of the |
| * package issuing log records and consist of dot-separated Java |
| * identifiers. |
| * @param resourceBundleName the name of a resource bundle for localizing |
| * messages, or <code>null</code> to indicate that messages do |
| * not need to be localized. |
| * @throws java.util.MissingResourceException if |
| * <code>resourceBundleName</code> is not <code>null</code> |
| * and no such bundle could be located. |
| */ |
| protected Logger(String name, String resourceBundleName) |
| throws MissingResourceException |
| { |
| this.name = name; |
| this.resourceBundleName = resourceBundleName; |
| |
| if (resourceBundleName == null) |
| resourceBundle = null; |
| else |
| resourceBundle = ResourceBundle.getBundle(resourceBundleName); |
| |
| level = null; |
| |
| /* |
| * This is null when the root logger is being constructed, and the root |
| * logger afterwards. |
| */ |
| parent = root; |
| |
| useParentHandlers = (parent != null); |
| } |
| |
| /** |
| * Finds a registered logger for a subsystem, or creates one in case no logger |
| * has been registered yet. |
| * |
| * @param name the name for the logger, for example "java.awt" or |
| * "com.foo.bar". The name should be based on the name of the |
| * package issuing log records and consist of dot-separated Java |
| * identifiers. |
| * @throws IllegalArgumentException if a logger for the subsystem identified |
| * by <code>name</code> has already been created, but uses a a |
| * resource bundle for localizing messages. |
| * @throws NullPointerException if <code>name</code> is <code>null</code>. |
| * @return a logger for the subsystem specified by <code>name</code> that |
| * does not localize messages. |
| */ |
| public static Logger getLogger(String name) |
| { |
| return getLogger(name, null); |
| } |
| |
| /** |
| * Finds a registered logger for a subsystem, or creates one in case no logger |
| * has been registered yet. |
| * <p> |
| * If a logger with the specified name has already been registered, the |
| * behavior depends on the resource bundle that is currently associated with |
| * the existing logger. |
| * <ul> |
| * <li>If the existing logger uses the same resource bundle as specified by |
| * <code>resourceBundleName</code>, the existing logger is returned.</li> |
| * <li>If the existing logger currently does not localize messages, the |
| * existing logger is modified to use the bundle specified by |
| * <code>resourceBundleName</code>. The existing logger is then returned. |
| * Therefore, all subsystems currently using this logger will produce |
| * localized messages from now on.</li> |
| * <li>If the existing logger already has an associated resource bundle, but |
| * a different one than specified by <code>resourceBundleName</code>, an |
| * <code>IllegalArgumentException</code> is thrown.</li> |
| * </ul> |
| * |
| * @param name the name for the logger, for example "java.awt" or |
| * "org.gnu.foo". The name should be based on the name of the |
| * package issuing log records and consist of dot-separated Java |
| * identifiers. |
| * @param resourceBundleName the name of a resource bundle for localizing |
| * messages, or <code>null</code> to indicate that messages do |
| * not need to be localized. |
| * @return a logger for the subsystem specified by <code>name</code>. |
| * @throws java.util.MissingResourceException if |
| * <code>resourceBundleName</code> is not <code>null</code> |
| * and no such bundle could be located. |
| * @throws IllegalArgumentException if a logger for the subsystem identified |
| * by <code>name</code> has already been created, but uses a |
| * different resource bundle for localizing messages. |
| * @throws NullPointerException if <code>name</code> is <code>null</code>. |
| */ |
| public static Logger getLogger(String name, String resourceBundleName) |
| { |
| LogManager lm = LogManager.getLogManager(); |
| Logger result; |
| |
| if (name == null) |
| throw new NullPointerException(); |
| |
| /* |
| * Without synchronized(lm), it could happen that another thread would |
| * create a logger between our calls to getLogger and addLogger. While |
| * addLogger would indicate this by returning false, we could not be sure |
| * that this other logger was still existing when we called getLogger a |
| * second time in order to retrieve it -- note that LogManager is only |
| * allowed to keep weak references to registered loggers, so Loggers can be |
| * garbage collected at any time in general, and between our call to |
| * addLogger and our second call go getLogger in particular. Of course, we |
| * assume here that LogManager.addLogger etc. are synchronizing on the |
| * global LogManager object. There is a comment in the implementation of |
| * LogManager.addLogger referring to this comment here, so that any change |
| * in the synchronization of LogManager will be reflected here. |
| */ |
| synchronized (lock) |
| { |
| synchronized (lm) |
| { |
| result = lm.getLogger(name); |
| if (result == null) |
| { |
| boolean couldBeAdded; |
| |
| result = new Logger(name, resourceBundleName); |
| couldBeAdded = lm.addLogger(result); |
| if (! couldBeAdded) |
| throw new IllegalStateException("cannot register new logger"); |
| } |
| else |
| { |
| /* |
| * The logger already exists. Make sure it uses the same |
| * resource bundle for localizing messages. |
| */ |
| String existingBundleName = result.getResourceBundleName(); |
| |
| /* |
| * The Sun J2SE 1.4 reference implementation will return the |
| * registered logger object, even if it does not have a resource |
| * bundle associated with it. However, it seems to change the |
| * resourceBundle of the registered logger to the bundle whose |
| * name was passed to getLogger. |
| */ |
| if ((existingBundleName == null) && |
| (resourceBundleName != null)) |
| { |
| /* |
| * If ResourceBundle.getBundle throws an exception, the |
| * existing logger will be unchanged. This would be |
| * different if the assignment to resourceBundleName came |
| * first. |
| */ |
| result.resourceBundle = |
| ResourceBundle.getBundle(resourceBundleName); |
| |
| result.resourceBundleName = resourceBundleName; |
| return result; |
| } |
| |
| if ((existingBundleName != resourceBundleName) |
| && ((existingBundleName == null) |
| || !existingBundleName.equals(resourceBundleName))) |
| { |
| throw new IllegalArgumentException(); |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Creates a new, unnamed logger. Unnamed loggers are not registered in the |
| * namespace of the LogManager, and no special security permission is required |
| * for changing their state. Therefore, untrusted applets are able to modify |
| * their private logger instance obtained through this method. |
| * <p> |
| * The parent of the newly created logger will the the root logger, from which |
| * the level threshold and the handlers are inherited. |
| */ |
| public static Logger getAnonymousLogger() |
| { |
| return getAnonymousLogger(null); |
| } |
| |
| /** |
| * Creates a new, unnamed logger. Unnamed loggers are not registered in the |
| * namespace of the LogManager, and no special security permission is required |
| * for changing their state. Therefore, untrusted applets are able to modify |
| * their private logger instance obtained through this method. |
| * <p> |
| * The parent of the newly created logger will the the root logger, from which |
| * the level threshold and the handlers are inherited. |
| * |
| * @param resourceBundleName the name of a resource bundle for localizing |
| * messages, or <code>null</code> to indicate that messages do |
| * not need to be localized. |
| * @throws java.util.MissingResourceException if |
| * <code>resourceBundleName</code> is not <code>null</code> |
| * and no such bundle could be located. |
| */ |
| public static Logger getAnonymousLogger(String resourceBundleName) |
| throws MissingResourceException |
| { |
| Logger result; |
| |
| result = new Logger(null, resourceBundleName); |
| result.anonymous = true; |
| return result; |
| } |
| |
| /** |
| * Returns the name of the resource bundle that is being used for localizing |
| * messages. |
| * |
| * @return the name of the resource bundle used for localizing messages, or |
| * <code>null</code> if the parent's resource bundle is used for |
| * this purpose. |
| */ |
| public String getResourceBundleName() |
| { |
| synchronized (lock) |
| { |
| return resourceBundleName; |
| } |
| } |
| |
| /** |
| * Returns the resource bundle that is being used for localizing messages. |
| * |
| * @return the resource bundle used for localizing messages, or |
| * <code>null</code> if the parent's resource bundle is used for |
| * this purpose. |
| */ |
| public ResourceBundle getResourceBundle() |
| { |
| synchronized (lock) |
| { |
| return resourceBundle; |
| } |
| } |
| |
| /** |
| * Returns the severity level threshold for this <code>Handler</code>. All |
| * log records with a lower severity level will be discarded; a log record of |
| * the same or a higher level will be published unless an installed |
| * <code>Filter</code> decides to discard it. |
| * |
| * @return the severity level below which all log messages will be discarded, |
| * or <code>null</code> if the logger inherits the threshold from |
| * its parent. |
| */ |
| public Level getLevel() |
| { |
| synchronized (lock) |
| { |
| return level; |
| } |
| } |
| |
| /** |
| * Returns whether or not a message of the specified level would be logged by |
| * this logger. |
| * |
| * @throws NullPointerException if <code>level</code> is <code>null</code>. |
| */ |
| public boolean isLoggable(Level level) |
| { |
| synchronized (lock) |
| { |
| if (this.level != null) |
| return this.level.intValue() <= level.intValue(); |
| |
| if (parent != null) |
| return parent.isLoggable(level); |
| else |
| return false; |
| } |
| } |
| |
| /** |
| * Sets the severity level threshold for this <code>Handler</code>. All log |
| * records with a lower severity level will be discarded immediately. A log |
| * record of the same or a higher level will be published unless an installed |
| * <code>Filter</code> decides to discard it. |
| * |
| * @param level the severity level below which all log messages will be |
| * discarded, or <code>null</code> to indicate that the logger |
| * should inherit the threshold from its parent. |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method |
| * {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| */ |
| public void setLevel(Level level) |
| { |
| synchronized (lock) |
| { |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| this.level = level; |
| } |
| } |
| |
| public Filter getFilter() |
| { |
| synchronized (lock) |
| { |
| return filter; |
| } |
| } |
| |
| /** |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method |
| * {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| */ |
| public void setFilter(Filter filter) throws SecurityException |
| { |
| synchronized (lock) |
| { |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| this.filter = filter; |
| } |
| } |
| |
| /** |
| * Returns the name of this logger. |
| * |
| * @return the name of this logger, or <code>null</code> if the logger is |
| * anonymous. |
| */ |
| public String getName() |
| { |
| /* |
| * Note that the name of a logger cannot be changed during its lifetime, so |
| * no synchronization is needed. |
| */ |
| return name; |
| } |
| |
| /** |
| * Passes a record to registered handlers, provided the record is considered |
| * as loggable both by {@link #isLoggable(Level)} and a possibly installed |
| * custom {@link #setFilter(Filter) filter}. |
| * <p> |
| * If the logger has been configured to use parent handlers, the record will |
| * be forwarded to the parent of this logger in addition to being processed by |
| * the handlers registered with this logger. |
| * <p> |
| * The other logging methods in this class are convenience methods that merely |
| * create a new LogRecord and pass it to this method. Therefore, subclasses |
| * usually just need to override this single method for customizing the |
| * logging behavior. |
| * |
| * @param record the log record to be inspected and possibly forwarded. |
| */ |
| public void log(LogRecord record) |
| { |
| synchronized (lock) |
| { |
| if (!isLoggable(record.getLevel())) |
| return; |
| |
| if ((filter != null) && ! filter.isLoggable(record)) |
| return; |
| |
| /* |
| * If no logger name has been set for the log record, use the name of |
| * this logger. |
| */ |
| if (record.getLoggerName() == null) |
| record.setLoggerName(name); |
| |
| /* |
| * Avoid that some other thread is changing the logger hierarchy while |
| * we are traversing it. |
| */ |
| synchronized (LogManager.getLogManager()) |
| { |
| Logger curLogger = this; |
| |
| do |
| { |
| /* |
| * The Sun J2SE 1.4 reference implementation seems to call the |
| * filter only for the logger whose log method is called, never |
| * for any of its parents. Also, parent loggers publish log |
| * record whatever their level might be. This is pretty weird, |
| * but GNU Classpath tries to be as compatible as possible to |
| * the reference implementation. |
| */ |
| for (int i = 0; i < curLogger.handlers.length; i++) |
| curLogger.handlers[i].publish(record); |
| |
| if (curLogger.getUseParentHandlers() == false) |
| break; |
| |
| curLogger = curLogger.getParent(); |
| } |
| while (parent != null); |
| } |
| } |
| } |
| |
| public void log(Level level, String message) |
| { |
| if (isLoggable(level)) |
| log(level, message, (Object[]) null); |
| } |
| |
| public void log(Level level, String message, Object param) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(level)) |
| { |
| StackTraceElement caller = getCallerStackFrame(); |
| logp(level, caller != null ? caller.getClassName() : "<unknown>", |
| caller != null ? caller.getMethodName() : "<unknown>", |
| message, param); |
| } |
| } |
| } |
| |
| public void log(Level level, String message, Object[] params) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(level)) |
| { |
| StackTraceElement caller = getCallerStackFrame(); |
| logp(level, caller != null ? caller.getClassName() : "<unknown>", |
| caller != null ? caller.getMethodName() : "<unknown>", |
| message, params); |
| |
| } |
| } |
| } |
| |
| public void log(Level level, String message, Throwable thrown) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(level)) |
| { |
| StackTraceElement caller = getCallerStackFrame(); |
| logp(level, caller != null ? caller.getClassName() : "<unknown>", |
| caller != null ? caller.getMethodName() : "<unknown>", |
| message, thrown); |
| } |
| } |
| } |
| |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String message) |
| { |
| synchronized (lock) |
| { |
| logp(level, sourceClass, sourceMethod, message, (Object[]) null); |
| } |
| } |
| |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String message, Object param) |
| { |
| synchronized (lock) |
| { |
| logp(level, sourceClass, sourceMethod, message, new Object[] { param }); |
| } |
| |
| } |
| |
| private ResourceBundle findResourceBundle() |
| { |
| synchronized (lock) |
| { |
| if (resourceBundle != null) |
| return resourceBundle; |
| |
| if (parent != null) |
| return parent.findResourceBundle(); |
| |
| return null; |
| } |
| } |
| |
| private void logImpl(Level level, String sourceClass, String sourceMethod, |
| String message, Object[] params) |
| { |
| synchronized (lock) |
| { |
| LogRecord rec = new LogRecord(level, message); |
| |
| rec.setResourceBundle(findResourceBundle()); |
| rec.setSourceClassName(sourceClass); |
| rec.setSourceMethodName(sourceMethod); |
| rec.setParameters(params); |
| |
| log(rec); |
| } |
| } |
| |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String message, Object[] params) |
| { |
| synchronized (lock) |
| { |
| logImpl(level, sourceClass, sourceMethod, message, params); |
| } |
| } |
| |
| public void logp(Level level, String sourceClass, String sourceMethod, |
| String message, Throwable thrown) |
| { |
| synchronized (lock) |
| { |
| LogRecord rec = new LogRecord(level, message); |
| |
| rec.setResourceBundle(resourceBundle); |
| rec.setSourceClassName(sourceClass); |
| rec.setSourceMethodName(sourceMethod); |
| rec.setThrown(thrown); |
| |
| log(rec); |
| } |
| } |
| |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String message) |
| { |
| synchronized (lock) |
| { |
| logrb(level, sourceClass, sourceMethod, bundleName, message, |
| (Object[]) null); |
| } |
| } |
| |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String message, Object param) |
| { |
| synchronized (lock) |
| { |
| logrb(level, sourceClass, sourceMethod, bundleName, message, |
| new Object[] { param }); |
| } |
| } |
| |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String message, Object[] params) |
| { |
| synchronized (lock) |
| { |
| LogRecord rec = new LogRecord(level, message); |
| |
| rec.setResourceBundleName(bundleName); |
| rec.setSourceClassName(sourceClass); |
| rec.setSourceMethodName(sourceMethod); |
| rec.setParameters(params); |
| |
| log(rec); |
| } |
| } |
| |
| public void logrb(Level level, String sourceClass, String sourceMethod, |
| String bundleName, String message, Throwable thrown) |
| { |
| synchronized (lock) |
| { |
| LogRecord rec = new LogRecord(level, message); |
| |
| rec.setResourceBundleName(bundleName); |
| rec.setSourceClassName(sourceClass); |
| rec.setSourceMethodName(sourceMethod); |
| rec.setThrown(thrown); |
| |
| log(rec); |
| } |
| } |
| |
| public void entering(String sourceClass, String sourceMethod) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| logp(Level.FINER, sourceClass, sourceMethod, "ENTRY"); |
| } |
| } |
| |
| public void entering(String sourceClass, String sourceMethod, Object param) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| logp(Level.FINER, sourceClass, sourceMethod, "ENTRY {0}", param); |
| } |
| } |
| |
| public void entering(String sourceClass, String sourceMethod, Object[] params) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| { |
| CPStringBuilder buf = new CPStringBuilder(80); |
| buf.append("ENTRY"); |
| for (int i = 0; i < params.length; i++) |
| { |
| buf.append(" {"); |
| buf.append(i); |
| buf.append('}'); |
| } |
| |
| logp(Level.FINER, sourceClass, sourceMethod, buf.toString(), params); |
| } |
| } |
| } |
| |
| public void exiting(String sourceClass, String sourceMethod) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| logp(Level.FINER, sourceClass, sourceMethod, "RETURN"); |
| } |
| } |
| |
| public void exiting(String sourceClass, String sourceMethod, Object result) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| logp(Level.FINER, sourceClass, sourceMethod, "RETURN {0}", result); |
| } |
| } |
| |
| public void throwing(String sourceClass, String sourceMethod, Throwable thrown) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| logp(Level.FINER, sourceClass, sourceMethod, "THROW", thrown); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level SEVERE, indicating a serious failure |
| * that prevents normal program execution. Messages at this level should be |
| * understandable to an inexperienced, non-technical end user. Ideally, they |
| * explain in simple words what actions the user can take in order to resolve |
| * the problem. |
| * |
| * @see Level#SEVERE |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void severe(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.SEVERE)) |
| log(Level.SEVERE, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level WARNING, indicating a potential problem |
| * that does not prevent normal program execution. Messages at this level |
| * should be understandable to an inexperienced, non-technical end user. |
| * Ideally, they explain in simple words what actions the user can take in |
| * order to resolve the problem. |
| * |
| * @see Level#WARNING |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void warning(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.WARNING)) |
| log(Level.WARNING, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level INFO. {@link Level#INFO} is intended for |
| * purely informational messages that do not indicate error or warning |
| * situations. In the default logging configuration, INFO messages will be |
| * written to the system console. For this reason, the INFO level should be |
| * used only for messages that are important to end users and system |
| * administrators. Messages at this level should be understandable to an |
| * inexperienced, non-technical user. |
| * |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void info(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.INFO)) |
| log(Level.INFO, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level CONFIG. {@link Level#CONFIG} is intended |
| * for static configuration messages, for example about the windowing |
| * environment, the operating system version, etc. |
| * |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void config(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.CONFIG)) |
| log(Level.CONFIG, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level FINE. {@link Level#FINE} is intended for |
| * messages that are relevant for developers using the component generating |
| * log messages. Examples include minor, recoverable failures, or possible |
| * inefficiencies. |
| * |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void fine(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINE)) |
| log(Level.FINE, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level FINER. {@link Level#FINER} is intended |
| * for rather detailed tracing, for example entering a method, returning from |
| * a method, or throwing an exception. |
| * |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void finer(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINER)) |
| log(Level.FINER, message); |
| } |
| } |
| |
| /** |
| * Logs a message with severity level FINEST. {@link Level#FINEST} is intended |
| * for highly detailed tracing, for example reaching a certain point inside |
| * the body of a method. |
| * |
| * @param message the message text, also used as look-up key if the logger is |
| * localizing messages with a resource bundle. While it is possible |
| * to pass <code>null</code>, this is not recommended, since a |
| * logging message without text is unlikely to be helpful. |
| */ |
| public void finest(String message) |
| { |
| synchronized (lock) |
| { |
| if (isLoggable(Level.FINEST)) |
| log(Level.FINEST, message); |
| } |
| } |
| |
| /** |
| * Adds a handler to the set of handlers that get notified when a log record |
| * is to be published. |
| * |
| * @param handler the handler to be added. |
| * @throws NullPointerException if <code>handler</code> is <code>null</code>. |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method |
| * {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| */ |
| public void addHandler(Handler handler) throws SecurityException |
| { |
| synchronized (lock) |
| { |
| if (handler == null) |
| throw new NullPointerException(); |
| |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| if (! handlerList.contains(handler)) |
| { |
| handlerList.add(handler); |
| handlers = getHandlers(); |
| } |
| } |
| } |
| |
| /** |
| * Removes a handler from the set of handlers that get notified when a log |
| * record is to be published. |
| * |
| * @param handler the handler to be removed. |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method {@link |
| * #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| * @throws NullPointerException if <code>handler</code> is <code>null</code>. |
| */ |
| public void removeHandler(Handler handler) throws SecurityException |
| { |
| synchronized (lock) |
| { |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| if (handler == null) |
| throw new NullPointerException(); |
| |
| handlerList.remove(handler); |
| handlers = getHandlers(); |
| } |
| } |
| |
| /** |
| * Returns the handlers currently registered for this Logger. When a log |
| * record has been deemed as being loggable, it will be passed to all |
| * registered handlers for publication. In addition, if the logger uses parent |
| * handlers (see {@link #getUseParentHandlers() getUseParentHandlers} and |
| * {@link #setUseParentHandlers(boolean) setUseParentHandlers}, the log |
| * record will be passed to the parent's handlers. |
| */ |
| public Handler[] getHandlers() |
| { |
| synchronized (lock) |
| { |
| /* |
| * We cannot return our internal handlers array because we do not have |
| * any guarantee that the caller would not change the array entries. |
| */ |
| return (Handler[]) handlerList.toArray(new Handler[handlerList.size()]); |
| } |
| } |
| |
| /** |
| * Returns whether or not this Logger forwards log records to handlers |
| * registered for its parent loggers. |
| * |
| * @return <code>false</code> if this Logger sends log records merely to |
| * Handlers registered with itself; <code>true</code> if this Logger |
| * sends log records not only to Handlers registered with itself, but |
| * also to those Handlers registered with parent loggers. |
| */ |
| public boolean getUseParentHandlers() |
| { |
| synchronized (lock) |
| { |
| return useParentHandlers; |
| } |
| } |
| |
| /** |
| * Sets whether or not this Logger forwards log records to handlers registered |
| * for its parent loggers. |
| * |
| * @param useParentHandlers <code>false</code> to let this Logger send log |
| * records merely to Handlers registered with itself; |
| * <code>true</code> to let this Logger send log records not only |
| * to Handlers registered with itself, but also to those Handlers |
| * registered with parent loggers. |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method |
| * {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| */ |
| public void setUseParentHandlers(boolean useParentHandlers) |
| { |
| synchronized (lock) |
| { |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| this.useParentHandlers = useParentHandlers; |
| } |
| } |
| |
| /** |
| * Returns the parent of this logger. By default, the parent is assigned by |
| * the LogManager by inspecting the logger's name. |
| * |
| * @return the parent of this logger (as detemined by the LogManager by |
| * inspecting logger names), the root logger if no other logger has a |
| * name which is a prefix of this logger's name, or <code>null</code> |
| * for the root logger. |
| */ |
| public Logger getParent() |
| { |
| synchronized (lock) |
| { |
| return parent; |
| } |
| } |
| |
| /** |
| * Sets the parent of this logger. Usually, applications do not call this |
| * method directly. Instead, the LogManager will ensure that the tree of |
| * loggers reflects the hierarchical logger namespace. Basically, this method |
| * should not be public at all, but the GNU implementation follows the API |
| * specification. |
| * |
| * @throws NullPointerException if <code>parent</code> is <code>null</code>. |
| * @throws SecurityException if this logger is not anonymous, a security |
| * manager exists, and the caller is not granted the permission to |
| * control the logging infrastructure by having |
| * LoggingPermission("control"). Untrusted code can obtain an |
| * anonymous logger through the static factory method |
| * {@link #getAnonymousLogger(java.lang.String) getAnonymousLogger}. |
| */ |
| public void setParent(Logger parent) |
| { |
| synchronized (lock) |
| { |
| if (parent == null) |
| throw new NullPointerException(); |
| |
| if (this == root) |
| throw new IllegalArgumentException( |
| "the root logger can only have a null parent"); |
| |
| /* |
| * An application is allowed to control an anonymous logger without |
| * having the permission to control the logging infrastructure. |
| */ |
| if (! anonymous) |
| LogManager.getLogManager().checkAccess(); |
| |
| this.parent = parent; |
| } |
| } |
| |
| /** |
| * Gets the StackTraceElement of the first class that is not this class. That |
| * should be the initial caller of a logging method. |
| * |
| * @return caller of the initial logging method or null if unknown. |
| */ |
| private StackTraceElement getCallerStackFrame() |
| { |
| Throwable t = new Throwable(); |
| StackTraceElement[] stackTrace = t.getStackTrace(); |
| int index = 0; |
| |
| // skip to stackentries until this class |
| while (index < stackTrace.length |
| && ! stackTrace[index].getClassName().equals(getClass().getName())) |
| index++; |
| |
| // skip the stackentries of this class |
| while (index < stackTrace.length |
| && stackTrace[index].getClassName().equals(getClass().getName())) |
| index++; |
| |
| return index < stackTrace.length ? stackTrace[index] : null; |
| } |
| |
| /** |
| * Reset and close handlers attached to this logger. This function is package |
| * private because it must only be available to the LogManager. |
| */ |
| void resetLogger() |
| { |
| for (int i = 0; i < handlers.length; i++) |
| { |
| handlers[i].close(); |
| handlerList.remove(handlers[i]); |
| } |
| handlers = getHandlers(); |
| } |
| } |
