/* Copyright (c) 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.gdata.util.common.logging;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
/**
* A wrapped logger chock-full of convenience methods.
*
* The introduction of varargs in Java 5 has provided two ways to further
* simplify logging information.<p/>
*
* First, the level-based convenience methods such as
* {@code Logger.foo(String msg)} can contain an additional
* {@code Object... args} parameter that formats your message according to the
* logger's {@link java.util.logging.Formatter}.<p/>
*
* Second, for those times when you don't want the
* {@link java.util.logging.Formatter} to manage formatting your message, you
* can use the {@code FormattingLogger.xxxfmt(String fmt, Object... params)}
* methods. These methods leverage the Java 5
* {@link String#format(String format, Object... args)} method. However,
* {@code logger.infofmt("%s %s", foo, bar)} is slightly more efficient than
* {@code logger.info(String.format("%s %s", foo, bar))} since the text is
* only formatted when the message is sufficiently important. It's also a little
* more readable.<p/>
*
* Keep in mind that this class mixes two ways to format text: one that expects
* text to be formatted by the logger's {@link java.util.logging.Formatter}
* and one that depends upon the new
* {@link java.lang.String#format(java.lang.String, java.lang.Object[])} style.
* If, in this class, method name ends with {@code fmt}, it's formatting using
* the latter. If the class method does not end with {@code fmt}, it's using
* the traditional formatting style.
*
* NOTE(future extenders): any time a new {@link #logfmt} variant is added
* to this class a matching {@link #logpfmt} variant must also be added, and
* vice versa. This enables {@code
* com.google.monitoring.runtime.instrumentation.LogFasterer} to do its job.
*
* by calls to the private method doLog, which sets the resource bundle.
* FormattingLogger does not support that yet; this functionality may change.
*
*
*/
public final class FormattingLogger {
// For use with LogRecord.inferCaller
private static final String LOGGER_CLASS_NAME =
FormattingLogger.class.getName();
/**
* An extension of {@link LogRecord} used to support a custom version of
* its private {@code inferCaller(String)} method.
*
*
*/
public static class Record extends LogRecord {
private static final long serialVersionUID = 1L;
private boolean needToInferCaller;
private String sourceMethodName;
private String sourceClassName;
/**
* Arguments passed to *fmt variants that we want to keep track of for
* users of this object.
*/
private final Object[] formatterArgs;
private final String formatterFormat;
@Override
public String getSourceMethodName() {
if (needToInferCaller) {
inferCaller(LOGGER_CLASS_NAME);
}
return sourceMethodName;
}
@Override
public String getSourceClassName() {
if (needToInferCaller) {
inferCaller(LOGGER_CLASS_NAME);
}
return sourceClassName;
}
public Object[] getFormatterArgs() {
return formatterArgs;
}
public String getFormatterFormat() {
return formatterFormat;
}
@Override
public void setSourceClassName(String sourceClassName) {
this.sourceClassName = sourceClassName;
super.setSourceClassName(sourceClassName);
}
@Override
public void setSourceMethodName(String sourceMethodName) {
this.sourceMethodName = sourceMethodName;
super.setSourceMethodName(sourceMethodName);
}
/**
* @param level
* @param msg
*/
Record(Level level, String msg) {
super(level, msg);
needToInferCaller = true;
formatterFormat = null;
formatterArgs = null;
}
/**
* Constructs a Record object given a {@link java.util.Formatter} format
* string and arguments
*
*/
Record(Level level, String fmt, Object[] args) {
super(level, String.format(fmt, args));
needToInferCaller = true;
formatterFormat = fmt;
formatterArgs = args;
}
/**
* Constructs a Record object when the class + method context are known.
* @param level the severity of the log statement
* @param msg the content of the log statement
* @param sourceClassName the class generating the log statement
* @param sourceMethodName the method generating the log statement
*/
Record(Level level, String msg, String sourceClassName,
String sourceMethodName) {
super(level, msg);
setSourceClassName(sourceClassName);
setSourceMethodName(sourceMethodName);
formatterFormat = null;
formatterArgs = null;
}
/**
* Constructs a Record object when the class + method context are known and
* {@link java.util.Formatter} messages are used.
*/
Record(Level level, String fmt, Object[] args, String sourceClassName,
String sourceMethodName) {
super(level, String.format(fmt, args));
setSourceClassName(sourceClassName);
setSourceMethodName(sourceMethodName);
formatterFormat = fmt;
formatterArgs = args;
}
/**
* Like LogRecord.inferCaller, we're making a 'best effort'.
*/
protected void inferCaller(String loggerClassName) {
needToInferCaller = false;
// true when searching for loggerClassName, false when not.
boolean isSearchingForLogger = true;
for (StackTraceElement elem : new Throwable().getStackTrace()) {
String className = elem.getClassName();
boolean matches = className.equals(loggerClassName);
// Found FormattingLogger in the stack.
if (matches && isSearchingForLogger) {
isSearchingForLogger = false;
continue;
}
// Found first call past FormattingLogger.
if (!matches && !isSearchingForLogger) {
setSourceClassName(className);
setSourceMethodName(elem.getMethodName());
return;
}
}
}
}
private final Logger logger;
/**
* Returns an instance of {@code FormattingLogger}.
*/
public static FormattingLogger getLogger(String name) {
return new FormattingLogger(Logger.getLogger(name));
}
/**
* Returns an instance of {@code FormattingLogger} using the
* {@link Class#getCanonicalName()} as a source for the underlying logger's
* name.
*/
public static FormattingLogger getLogger(Class<?> cls) {
return getLogger(cls.getCanonicalName());
}
/**
* Creates a new FormattingLogger.
*
* This is convenience ctor that creates a named backing {@code Logger} with
* the name of the passed-in class.
*
* @param cls The class whose name will be used to name the backing logger.
*/
public FormattingLogger(Class<?> cls) {
this(Logger.getLogger(cls.getCanonicalName()));
}
/**
* Creates a new FormattingLogger.
*
* This is a convenience ctor that creates an anonymous backing
* {@code Logger}.
*/
public FormattingLogger() {
this(Logger.getAnonymousLogger());
}
/**
* Creates a new FormattingLogger by wrapping a {@code Logger}.
*
* @param logger The {@code Logger} to wrap.
*/
public FormattingLogger(Logger logger) {
if (logger == null) {
throw new NullPointerException("logger is null");
}
this.logger = logger;
}
/**
* Gets the {@code Logger} wrapped by this FormattingLogger.
* @return the {@code Logger} wrapped by this FormattingLogger.
*/
public Logger getFormattingLogger() {
return logger;
}
/**
* Similar to {@link Logger#log(Level, String, Object[])}, allows you to delay
* formatting with {@link java.text.MessageFormat}.
*/
public void log(Level level, String msg, Object... params) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg);
record.setParameters(params);
nameAndLog(record);
}
/**
* Similar to {@link Logger#log(Level, String, Throwable)}, sets the value
* of {@link LogRecord#getThrown()}.
*/
public void log(Level level, String msg, Throwable thrown) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg);
record.setThrown(thrown);
nameAndLog(record);
}
/**
* Similar to {@link Logger#log(Level, String, Throwable)}, but takes
* variable arguments and allows you to delay formatting with
* {@link java.text.MessageFormat}.
* Calls {@link LogRecord#setThrown(Throwable)} if thrown is non-null.
*/
public void log(Level level, Throwable thrown,
String msg, Object... params) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg);
if (thrown != null) {
record.setThrown(thrown);
}
if (params != null && params.length != 0) {
record.setParameters(params);
}
nameAndLog(record);
}
private void nameAndLog(Record record) {
record.setLoggerName(logger.getName());
log(record);
}
/**
* Log a {@link java.util.logging.LogRecord}. The log message, level and
* other parameters are contained in the {@code LogRecord}, but the source
* class and method will be set if necessary.
*/
public void log(LogRecord lr) {
if (!(lr instanceof Record)) {
// set the source class and method name by creating a bogus
// record, and getting the class and method names from it.
// This may look like a hack, but it's pretty much no worse than anything
// else, we'll need to create a new Object, no matter what. Hey, we need
// the stack trace, so this is peanuts compared to that.
Record rec = new Record(Level.INFO, null);
lr.setSourceClassName(rec.getSourceClassName());
lr.setSourceMethodName(rec.getSourceMethodName());
}
logger.log(lr);
}
/**
* Logs an event with a known context, similar to
* {@link java.util.logging.Logger#logp(java.util.logging.Level, String, String, String)}.
* However, this delays formatting of the message.
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param msg the basic message string
* @param params the parameters for the message string
*/
public void logp(Level level, String sourceClassName, String sourceMethodName,
String msg, Object... params) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg, sourceClassName, sourceMethodName);
if (params != null && params.length != 0) {
record.setParameters(params);
}
nameAndLog(record);
}
/**
* Logs an event with a known context, similar to
* {@link java.util.logging.Logger#logp(java.util.logging.Level, String,
* String, String, Throwable)}.
* However, this delays formatting of the message.
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param msg the message string
* @param thrown the throwable which triggered this log event
*/
public void logp(Level level, String sourceClassName, String sourceMethodName,
String msg, Throwable thrown) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg, sourceClassName, sourceMethodName);
record.setThrown(thrown);
nameAndLog(record);
}
/**
* Logs an event with a known context, similar to
* {@link java.util.logging.Logger#logp(java.util.logging.Level, String,
* String, String, Throwable)}.
* However, this delays formatting of the message.
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param thrown the throwable which triggered this log event
* @param msg the basic message string
* @param params the parameters for the message string
*/
public void logp(Level level, String sourceClassName, String sourceMethodName,
Throwable thrown, String msg, Object... params) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(level, msg, sourceClassName, sourceMethodName);
if (thrown != null) {
record.setThrown(thrown);
}
if (params != null && params.length != 0) {
record.setParameters(params);
}
nameAndLog(record);
}
/** Pass-through to {@link Logger#isLoggable(Level)} */
public boolean isLoggable(Level level) {
return logger.isLoggable(level);
}
/** Pass-through to {@link Logger#getLevel()} */
public Level getLevel() {
return logger.getLevel();
}
/** Pass-through to {@link Logger#setLevel(Level)} */
public void setLevel(Level level) {
logger.setLevel(level);
}
/**
* Log a message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param level One of the message level identifiers, e.g. SEVERE
* @param fmt The string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void logfmt(Level level, String fmt, Object... args) {
if (logger.isLoggable(level)) {
Record record = new Record(level, fmt, args);
nameAndLog(record);
}
}
/**
* Log a message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param level One of the message level identifiers, e.g. SEVERE
* @param fmt The string message (or a key in the message catalog)
* @param thrown the throwable which triggered this log event,
* and parameter to the format message
*/
public void logfmt(Level level, String fmt, Throwable thrown) {
if (logger.isLoggable(level)) {
Record record = new Record(level, fmt, new Object[]{thrown});
record.setThrown(thrown);
nameAndLog(record);
}
}
/**
* Log a message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param level one of the message level identifiers, e.g. SEVERE
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void logfmt(Level level, Throwable thrown,
String fmt, Object... args) {
if (logger.isLoggable(level)) {
Record record = new Record(level, fmt, args);
record.setThrown(thrown);
nameAndLog(record);
}
}
/**
* Logs an event with a known context, using explicit formatting rules.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the format message
*/
public void logpfmt(Level level, String sourceClassName,
String sourceMethodName, String fmt, Object... args) {
if (!isLoggable(level)) {
return;
}
Record record =
new Record(level, fmt, args, sourceClassName, sourceMethodName);
nameAndLog(record);
}
/**
* Logs an event with a known context, using explicit formatting rules.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param fmt the string message (or a key in the message catalog)
* @param thrown the throwable which triggered this log event,
* and parameter to the format message
*/
public void logpfmt(Level level, String sourceClassName,
String sourceMethodName, String fmt, Throwable thrown) {
if (!isLoggable(level)) {
return;
}
Record record = new Record(
level, fmt, new Object[]{thrown},
sourceClassName, sourceMethodName);
record.setThrown(thrown);
nameAndLog(record);
}
/**
* Logs an event with a known context, using explicit formatting rules.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param level one of the message level identifiers, e.g. SEVERE
* @param sourceClassName the class generating this log event
* @param sourceMethodName the method generating this log event
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void logpfmt(Level level, String sourceClassName,
String sourceMethodName, Throwable thrown,
String fmt, Object... args) {
if (logger.isLoggable(level)) {
logp(level, sourceClassName, sourceMethodName, thrown,
String.format(fmt, args), (Object[]) null);
}
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void severe(String msg, Throwable thrown) {
log(Level.SEVERE, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void warning(String msg, Throwable thrown) {
log(Level.WARNING, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void info(String msg, Throwable thrown) {
log(Level.INFO, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void config(String msg, Throwable thrown) {
log(Level.CONFIG, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void fine(String msg, Throwable thrown) {
log(Level.FINE, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void finer(String msg, Throwable thrown) {
log(Level.FINER, thrown, msg, thrown);
}
/**
* 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)
* @param thrown the throwable which triggered this log event,
* and parameter to the message
*/
public void finest(String msg, Throwable thrown) {
log(Level.FINEST, thrown, msg, thrown);
}
/**
* Log a SEVERE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void severefmt(String fmt, Throwable thrown) {
logfmt(Level.SEVERE, thrown, fmt, thrown);
}
/**
* Log a WARNING message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void warningfmt(String fmt, Throwable thrown) {
logfmt(Level.WARNING, thrown, fmt, thrown);
}
/**
* Log an INFO message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void infofmt(String fmt, Throwable thrown) {
logfmt(Level.INFO, thrown, fmt, thrown);
}
/**
* Log a CONFIG message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(java.util.Locale, String, Object[])
*/
public void configfmt(String fmt, Throwable thrown) {
logfmt(Level.CONFIG, thrown, fmt, thrown);
}
/**
* Log a FINE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finefmt(String fmt, Throwable thrown) {
logfmt(Level.FINE, thrown, fmt, thrown);
}
/**
* Log a FINER message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finerfmt(String fmt, Throwable thrown) {
logfmt(Level.FINER, thrown, fmt, thrown);
}
/**
* Log a FINEST message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the {@code fmt} and {@code thrown} are converted to a string
* using {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param thrown the throwable which triggered this log event,
* and parameter to the formatter message
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finestfmt(String fmt, Throwable thrown) {
logfmt(Level.FINEST, thrown, fmt, thrown);
}
/**
* Log a SEVERE message, with an array of object arguments.
* <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)
* @param params array of parameters to the message
*/
public void severe(String msg, Object... params) {
log(Level.SEVERE, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void warning(String msg, Object... params) {
log(Level.WARNING, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void info(String msg, Object... params) {
log(Level.INFO, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void config(String msg, Object... params) {
log(Level.CONFIG, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void fine(String msg, Object... params) {
log(Level.FINE, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void finer(String msg, Object... params) {
log(Level.FINER, msg, params);
}
/**
* 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)
* @param params array of parameters to the message
*/
public void finest(String msg, Object... params) {
log(Level.FINEST, msg, params);
}
/**
* Log a SEVERE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void severefmt(String fmt, Object... args) {
logfmt(Level.SEVERE, fmt, args);
}
/**
* Log a WARNING message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void warningfmt(String fmt, Object... args) {
logfmt(Level.WARNING, fmt, args);
}
/**
* Log an INFO message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void infofmt(String fmt, Object... args) {
logfmt(Level.INFO, fmt, args);
}
/**
* Log a CONFIG message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(java.util.Locale, String, Object[])
*/
public void configfmt(String fmt, Object... args) {
logfmt(Level.CONFIG, fmt, args);
}
/**
* Log a FINE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finefmt(String fmt, Object... args) {
logfmt(Level.FINE, fmt, args);
}
/**
* Log a FINER message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finerfmt(String fmt, Object... args) {
logfmt(Level.FINER, fmt, args);
}
/**
* Log a FINEST message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and is forwarded to all the registered output Handler objects.
*
* @param fmt A format string
* @param args array of parameters to the formatter
* @see java.util.logging.Formatter
* @see String#format(String, Object[])
*/
public void finestfmt(String fmt, Object... args) {
logfmt(Level.FINEST, fmt, args);
}
/**
* Log a SEVERE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void severefmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.SEVERE, thrown, fmt, args);
}
/**
* Log a WARNING message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void warningfmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.WARNING, thrown, fmt, args);
}
/**
* Log a INFO message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void infofmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.INFO, thrown, fmt, args);
}
/**
* Log a CONFIG message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void configfmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.CONFIG, thrown, fmt, args);
}
/**
* Log a FINE message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void finefmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.FINE, thrown, fmt, args);
}
/**
* Log a FINER message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void finerfmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.FINER, thrown, fmt, args);
}
/**
* Log a FINEST message.
* <p>
* If the logger currently accepts messages of the supplied level,
* then the fmt and args are converted to a string using
* {@link String#format(String, Object[])}
* and forwarded to all the registered output Handler objects.
*
* @param thrown the throwable which triggered this log event
* @param fmt the string message (or a key in the message catalog)
* @param args array of parameters to the message
*/
public void finestfmt(Throwable thrown, String fmt, Object... args) {
logfmt(Level.FINEST, thrown, fmt, args);
}
}