mirror of git://gcc.gnu.org/git/gcc.git
1194 lines
41 KiB
Java
1194 lines
41 KiB
Java
/* 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();
|
|
}
|
|
}
|