/*
 * JBoss, Home of Professional Open Source.
 *
 * Copyright 2011 Red Hat, 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 org.jboss.logging;

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.PrivilegedAction;
import java.util.Locale;

import static java.security.AccessController.doPrivileged;

An abstracted logging entry point.
/** * An abstracted logging entry point. */
public abstract class Logger implements Serializable, BasicLogger { private static final long serialVersionUID = 4232175575988879434L; private static final String FQCN = Logger.class.getName();
Levels used by this logging API.
/** * Levels used by this logging API. */
public enum Level { FATAL, ERROR, WARN, INFO, DEBUG, TRACE, } private final String name;
Construct a new instance.
Params:
  • name – the logger category name
/** * Construct a new instance. * * @param name the logger category name */
protected Logger(final String name) { this.name = name; }
Return the name of this logger.
Returns:The name of this logger.
/** * Return the name of this logger. * * @return The name of this logger. */
public String getName() { return name; }
Implementation log method (standard parameter formatting).
Params:
  • level – the level
  • loggerClassName – the logger class name
  • message – the message to log
  • parameters – the parameters of the message
  • thrown – the exception which was thrown, if any
/** * Implementation log method (standard parameter formatting). * * @param level the level * @param loggerClassName the logger class name * @param message the message to log * @param parameters the parameters of the message * @param thrown the exception which was thrown, if any */
protected abstract void doLog(Level level, String loggerClassName, Object message, Object[] parameters, Throwable thrown);
Implementation log method (printf formatting).
Params:
  • level – the level
  • loggerClassName – the logger class name
  • format – the format string to log
  • parameters – the parameters of the message
  • thrown – the exception which was thrown, if any
/** * Implementation log method (printf formatting). * * @param level the level * @param loggerClassName the logger class name * @param format the format string to log * @param parameters the parameters of the message * @param thrown the exception which was thrown, if any */
protected abstract void doLogf(Level level, String loggerClassName, String format, Object[] parameters, Throwable thrown);
Check to see if the TRACE level is enabled for this logger.
Returns:true if messages logged at Level.TRACE may be accepted, false otherwise
/** * Check to see if the {@code TRACE} level is enabled for this logger. * * @return {@code true} if messages logged at {@link Level#TRACE} may be accepted, {@code false} otherwise */
public boolean isTraceEnabled() { return isEnabled(Level.TRACE); }
Issue a log message with a level of TRACE.
Params:
  • message – the message
/** * Issue a log message with a level of TRACE. * * @param message the message */
public void trace(Object message) { doLog(Level.TRACE, FQCN, message, null, null); }
Issue a log message and throwable with a level of TRACE.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of TRACE. * * @param message the message * @param t the throwable */
public void trace(Object message, Throwable t) { doLog(Level.TRACE, FQCN, message, null, t); }
Issue a log message and throwable with a level of TRACE and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of TRACE and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void trace(String loggerFqcn, Object message, Throwable t) { doLog(Level.TRACE, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of TRACE.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using tracev(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of TRACE. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #tracev(String, Object...)} is recommended. */
@Deprecated public void trace(Object message, Object[] params) { doLog(Level.TRACE, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of TRACE.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using tracev(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of TRACE. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #tracev(Throwable, String, Object...)} is recommended. */
@Deprecated public void trace(Object message, Object[] params, Throwable t) { doLog(Level.TRACE, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of TRACE.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of TRACE. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void trace(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.TRACE, loggerFqcn, message, params, t); }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void tracev(String format, Object... params) { doLog(Level.TRACE, FQCN, format, params, null); }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void tracev(String format, Object param1) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void tracev(String format, Object param1, Object param2) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void tracev(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void tracev(Throwable t, String format, Object... params) { doLog(Level.TRACE, FQCN, format, params, t); }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void tracev(Throwable t, String format, Object param1) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void tracev(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of TRACE using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of TRACE using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void tracev(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.TRACE)) { doLog(Level.TRACE, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of TRACE.
Params:
/** * Issue a formatted log message with a level of TRACE. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void tracef(String format, Object... params) { doLogf(Level.TRACE, FQCN, format, params, null); }
Issue a formatted log message with a level of TRACE.
Params:
/** * Issue a formatted log message with a level of TRACE. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void tracef(String format, Object param1) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of TRACE.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of TRACE. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void tracef(String format, Object param1, Object param2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of TRACE.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of TRACE. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void tracef(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of TRACE.
Params:
/** * Issue a formatted log message with a level of TRACE. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void tracef(Throwable t, String format, Object... params) { doLogf(Level.TRACE, FQCN, format, params, t); }
Issue a formatted log message with a level of TRACE.
Params:
/** * Issue a formatted log message with a level of TRACE. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void tracef(Throwable t, String format, Object param1) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of TRACE.
Params:
/** * Issue a formatted log message with a level of TRACE. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void tracef(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of TRACE.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of TRACE. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void tracef(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { param1, param2, param3 }, t); } } public void tracef(final String format, final int arg) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg }, null); } } public void tracef(final String format, final int arg1, final int arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void tracef(final String format, final int arg1, final Object arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void tracef(final String format, final int arg1, final int arg2, final int arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final String format, final int arg1, final int arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final String format, final int arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final Throwable t, final String format, final int arg) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg }, t); } } public void tracef(final Throwable t, final String format, final int arg1, final int arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void tracef(final Throwable t, final String format, final int arg1, final Object arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void tracef(final Throwable t, final String format, final int arg1, final int arg2, final int arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void tracef(final Throwable t, final String format, final int arg1, final int arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void tracef(final Throwable t, final String format, final int arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void tracef(final String format, final long arg) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg }, null); } } public void tracef(final String format, final long arg1, final long arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void tracef(final String format, final long arg1, final Object arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void tracef(final String format, final long arg1, final long arg2, final long arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final String format, final long arg1, final long arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final String format, final long arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void tracef(final Throwable t, final String format, final long arg) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg }, t); } } public void tracef(final Throwable t, final String format, final long arg1, final long arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void tracef(final Throwable t, final String format, final long arg1, final Object arg2) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void tracef(final Throwable t, final String format, final long arg1, final long arg2, final long arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void tracef(final Throwable t, final String format, final long arg1, final long arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void tracef(final Throwable t, final String format, final long arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.TRACE)) { doLogf(Level.TRACE, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } }
Check to see if the DEBUG level is enabled for this logger.
Returns:true if messages logged at Level.DEBUG may be accepted, false otherwise
/** * Check to see if the {@code DEBUG} level is enabled for this logger. * * @return {@code true} if messages logged at {@link Level#DEBUG} may be accepted, {@code false} otherwise */
public boolean isDebugEnabled() { return isEnabled(Level.DEBUG); }
Issue a log message with a level of DEBUG.
Params:
  • message – the message
/** * Issue a log message with a level of DEBUG. * * @param message the message */
public void debug(Object message) { doLog(Level.DEBUG, FQCN, message, null, null); }
Issue a log message and throwable with a level of DEBUG.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of DEBUG. * * @param message the message * @param t the throwable */
public void debug(Object message, Throwable t) { doLog(Level.DEBUG, FQCN, message, null, t); }
Issue a log message and throwable with a level of DEBUG and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of DEBUG and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void debug(String loggerFqcn, Object message, Throwable t) { doLog(Level.DEBUG, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of DEBUG.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using debugv(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of DEBUG. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #debugv(String, Object...)} is recommended. */
@Deprecated public void debug(Object message, Object[] params) { doLog(Level.DEBUG, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of DEBUG.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using debugv(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of DEBUG. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #debugv(Throwable, String, Object...)} is recommended. */
@Deprecated public void debug(Object message, Object[] params, Throwable t) { doLog(Level.DEBUG, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of DEBUG.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of DEBUG. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void debug(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.DEBUG, loggerFqcn, message, params, t); }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void debugv(String format, Object... params) { doLog(Level.DEBUG, FQCN, format, params, null); }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void debugv(String format, Object param1) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void debugv(String format, Object param1, Object param2) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void debugv(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void debugv(Throwable t, String format, Object... params) { doLog(Level.DEBUG, FQCN, format, params, t); }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void debugv(Throwable t, String format, Object param1) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void debugv(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of DEBUG using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of DEBUG using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void debugv(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.DEBUG)) { doLog(Level.DEBUG, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of DEBUG.
Params:
/** * Issue a formatted log message with a level of DEBUG. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void debugf(String format, Object... params) { doLogf(Level.DEBUG, FQCN, format, params, null); }
Issue a formatted log message with a level of DEBUG.
Params:
/** * Issue a formatted log message with a level of DEBUG. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void debugf(String format, Object param1) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of DEBUG.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of DEBUG. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void debugf(String format, Object param1, Object param2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of DEBUG.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of DEBUG. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void debugf(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of DEBUG.
Params:
/** * Issue a formatted log message with a level of DEBUG. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void debugf(Throwable t, String format, Object... params) { doLogf(Level.DEBUG, FQCN, format, params, t); }
Issue a formatted log message with a level of DEBUG.
Params:
/** * Issue a formatted log message with a level of DEBUG. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void debugf(Throwable t, String format, Object param1) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of DEBUG.
Params:
/** * Issue a formatted log message with a level of DEBUG. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void debugf(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of DEBUG.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of DEBUG. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void debugf(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { param1, param2, param3 }, t); } } public void debugf(final String format, final int arg) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg }, null); } } public void debugf(final String format, final int arg1, final int arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void debugf(final String format, final int arg1, final Object arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void debugf(final String format, final int arg1, final int arg2, final int arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final String format, final int arg1, final int arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final String format, final int arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final Throwable t, final String format, final int arg) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg }, t); } } public void debugf(final Throwable t, final String format, final int arg1, final int arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void debugf(final Throwable t, final String format, final int arg1, final Object arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void debugf(final Throwable t, final String format, final int arg1, final int arg2, final int arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void debugf(final Throwable t, final String format, final int arg1, final int arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void debugf(final Throwable t, final String format, final int arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void debugf(final String format, final long arg) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg }, null); } } public void debugf(final String format, final long arg1, final long arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void debugf(final String format, final long arg1, final Object arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, null); } } public void debugf(final String format, final long arg1, final long arg2, final long arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final String format, final long arg1, final long arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final String format, final long arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, null); } } public void debugf(final Throwable t, final String format, final long arg) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg }, t); } } public void debugf(final Throwable t, final String format, final long arg1, final long arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void debugf(final Throwable t, final String format, final long arg1, final Object arg2) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2 }, t); } } public void debugf(final Throwable t, final String format, final long arg1, final long arg2, final long arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void debugf(final Throwable t, final String format, final long arg1, final long arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } } public void debugf(final Throwable t, final String format, final long arg1, final Object arg2, final Object arg3) { if (isEnabled(Level.DEBUG)) { doLogf(Level.DEBUG, FQCN, format, new Object[] { arg1, arg2, arg3 }, t); } }
Check to see if the INFO level is enabled for this logger.
Returns:true if messages logged at Level.INFO may be accepted, false otherwise
/** * Check to see if the {@code INFO} level is enabled for this logger. * * @return {@code true} if messages logged at {@link Level#INFO} may be accepted, {@code false} otherwise */
public boolean isInfoEnabled() { return isEnabled(Level.INFO); }
Issue a log message with a level of INFO.
Params:
  • message – the message
/** * Issue a log message with a level of INFO. * * @param message the message */
public void info(Object message) { doLog(Level.INFO, FQCN, message, null, null); }
Issue a log message and throwable with a level of INFO.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of INFO. * * @param message the message * @param t the throwable */
public void info(Object message, Throwable t) { doLog(Level.INFO, FQCN, message, null, t); }
Issue a log message and throwable with a level of INFO and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of INFO and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void info(String loggerFqcn, Object message, Throwable t) { doLog(Level.INFO, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of INFO.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using infov(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of INFO. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #infov(String, Object...)} is recommended. */
@Deprecated public void info(Object message, Object[] params) { doLog(Level.INFO, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of INFO.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using infov(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of INFO. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #infov(Throwable, String, Object...)} is recommended. */
@Deprecated public void info(Object message, Object[] params, Throwable t) { doLog(Level.INFO, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of INFO.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of INFO. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void info(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.INFO, loggerFqcn, message, params, t); }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void infov(String format, Object... params) { doLog(Level.INFO, FQCN, format, params, null); }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void infov(String format, Object param1) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void infov(String format, Object param1, Object param2) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void infov(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void infov(Throwable t, String format, Object... params) { doLog(Level.INFO, FQCN, format, params, t); }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void infov(Throwable t, String format, Object param1) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void infov(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of INFO using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of INFO using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void infov(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.INFO)) { doLog(Level.INFO, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of INFO.
Params:
/** * Issue a formatted log message with a level of INFO. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void infof(String format, Object... params) { doLogf(Level.INFO, FQCN, format, params, null); }
Issue a formatted log message with a level of INFO.
Params:
/** * Issue a formatted log message with a level of INFO. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void infof(String format, Object param1) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of INFO.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of INFO. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void infof(String format, Object param1, Object param2) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of INFO.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of INFO. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void infof(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of INFO.
Params:
/** * Issue a formatted log message with a level of INFO. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void infof(Throwable t, String format, Object... params) { doLogf(Level.INFO, FQCN, format, params, t); }
Issue a formatted log message with a level of INFO.
Params:
/** * Issue a formatted log message with a level of INFO. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void infof(Throwable t, String format, Object param1) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of INFO.
Params:
/** * Issue a formatted log message with a level of INFO. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void infof(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of INFO.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of INFO. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void infof(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.INFO)) { doLogf(Level.INFO, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a log message with a level of WARN.
Params:
  • message – the message
/** * Issue a log message with a level of WARN. * * @param message the message */
public void warn(Object message) { doLog(Level.WARN, FQCN, message, null, null); }
Issue a log message and throwable with a level of WARN.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of WARN. * * @param message the message * @param t the throwable */
public void warn(Object message, Throwable t) { doLog(Level.WARN, FQCN, message, null, t); }
Issue a log message and throwable with a level of WARN and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of WARN and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void warn(String loggerFqcn, Object message, Throwable t) { doLog(Level.WARN, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of WARN.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using warnv(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of WARN. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #warnv(String, Object...)} is recommended. */
@Deprecated public void warn(Object message, Object[] params) { doLog(Level.WARN, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of WARN.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using warnv(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of WARN. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #warnv(Throwable, String, Object...)} is recommended. */
@Deprecated public void warn(Object message, Object[] params, Throwable t) { doLog(Level.WARN, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of WARN.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of WARN. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void warn(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.WARN, loggerFqcn, message, params, t); }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void warnv(String format, Object... params) { doLog(Level.WARN, FQCN, format, params, null); }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void warnv(String format, Object param1) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void warnv(String format, Object param1, Object param2) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void warnv(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void warnv(Throwable t, String format, Object... params) { doLog(Level.WARN, FQCN, format, params, t); }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void warnv(Throwable t, String format, Object param1) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void warnv(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of WARN using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of WARN using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void warnv(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.WARN)) { doLog(Level.WARN, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of WARN.
Params:
/** * Issue a formatted log message with a level of WARN. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void warnf(String format, Object... params) { doLogf(Level.WARN, FQCN, format, params, null); }
Issue a formatted log message with a level of WARN.
Params:
/** * Issue a formatted log message with a level of WARN. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void warnf(String format, Object param1) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of WARN.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of WARN. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void warnf(String format, Object param1, Object param2) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of WARN.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of WARN. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void warnf(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of WARN.
Params:
/** * Issue a formatted log message with a level of WARN. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void warnf(Throwable t, String format, Object... params) { doLogf(Level.WARN, FQCN, format, params, t); }
Issue a formatted log message with a level of WARN.
Params:
/** * Issue a formatted log message with a level of WARN. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void warnf(Throwable t, String format, Object param1) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of WARN.
Params:
/** * Issue a formatted log message with a level of WARN. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void warnf(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of WARN.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of WARN. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void warnf(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.WARN)) { doLogf(Level.WARN, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a log message with a level of ERROR.
Params:
  • message – the message
/** * Issue a log message with a level of ERROR. * * @param message the message */
public void error(Object message) { doLog(Level.ERROR, FQCN, message, null, null); }
Issue a log message and throwable with a level of ERROR.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of ERROR. * * @param message the message * @param t the throwable */
public void error(Object message, Throwable t) { doLog(Level.ERROR, FQCN, message, null, t); }
Issue a log message and throwable with a level of ERROR and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of ERROR and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void error(String loggerFqcn, Object message, Throwable t) { doLog(Level.ERROR, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of ERROR.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using errorv(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of ERROR. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #errorv(String, Object...)} is recommended. */
@Deprecated public void error(Object message, Object[] params) { doLog(Level.ERROR, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of ERROR.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using errorv(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of ERROR. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #errorv(Throwable, String, Object...)} is recommended. */
@Deprecated public void error(Object message, Object[] params, Throwable t) { doLog(Level.ERROR, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of ERROR.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of ERROR. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void error(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.ERROR, loggerFqcn, message, params, t); }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void errorv(String format, Object... params) { doLog(Level.ERROR, FQCN, format, params, null); }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void errorv(String format, Object param1) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void errorv(String format, Object param1, Object param2) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void errorv(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void errorv(Throwable t, String format, Object... params) { doLog(Level.ERROR, FQCN, format, params, t); }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void errorv(Throwable t, String format, Object param1) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void errorv(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of ERROR using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of ERROR using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void errorv(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.ERROR)) { doLog(Level.ERROR, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of ERROR.
Params:
/** * Issue a formatted log message with a level of ERROR. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void errorf(String format, Object... params) { doLogf(Level.ERROR, FQCN, format, params, null); }
Issue a formatted log message with a level of ERROR.
Params:
/** * Issue a formatted log message with a level of ERROR. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void errorf(String format, Object param1) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of ERROR.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of ERROR. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void errorf(String format, Object param1, Object param2) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of ERROR.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of ERROR. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void errorf(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of ERROR.
Params:
/** * Issue a formatted log message with a level of ERROR. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void errorf(Throwable t, String format, Object... params) { doLogf(Level.ERROR, FQCN, format, params, t); }
Issue a formatted log message with a level of ERROR.
Params:
/** * Issue a formatted log message with a level of ERROR. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void errorf(Throwable t, String format, Object param1) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of ERROR.
Params:
/** * Issue a formatted log message with a level of ERROR. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void errorf(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of ERROR.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of ERROR. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void errorf(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.ERROR)) { doLogf(Level.ERROR, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a log message with a level of FATAL.
Params:
  • message – the message
/** * Issue a log message with a level of FATAL. * * @param message the message */
public void fatal(Object message) { doLog(Level.FATAL, FQCN, message, null, null); }
Issue a log message and throwable with a level of FATAL.
Params:
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of FATAL. * * @param message the message * @param t the throwable */
public void fatal(Object message, Throwable t) { doLog(Level.FATAL, FQCN, message, null, t); }
Issue a log message and throwable with a level of FATAL and a specific logger class name.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable with a level of FATAL and a specific logger class name. * * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void fatal(String loggerFqcn, Object message, Throwable t) { doLog(Level.FATAL, loggerFqcn, message, null, t); }
Issue a log message with parameters with a level of FATAL.
Params:
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using fatalv(String, Object...) is recommended.
/** * Issue a log message with parameters with a level of FATAL. * * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #fatalv(String, Object...)} is recommended. */
@Deprecated public void fatal(Object message, Object[] params) { doLog(Level.FATAL, FQCN, message, params, null); }
Issue a log message with parameters and a throwable with a level of FATAL.
Params:
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using fatalv(Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable with a level of FATAL. * * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #fatalv(Throwable, String, Object...)} is recommended. */
@Deprecated public void fatal(Object message, Object[] params, Throwable t) { doLog(Level.FATAL, FQCN, message, params, t); }
Issue a log message with parameters and a throwable with a level of FATAL.
Params:
  • loggerFqcn – the logger class name
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable with a level of FATAL. * * @param loggerFqcn the logger class name * @param message the message * @param params the message parameters * @param t the throwable */
public void fatal(String loggerFqcn, Object message, Object[] params, Throwable t) { doLog(Level.FATAL, loggerFqcn, message, params, t); }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param params the parameters */
public void fatalv(String format, Object... params) { doLog(Level.FATAL, FQCN, format, params, null); }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the sole parameter */
public void fatalv(String format, Object param1) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void fatalv(String format, Object param1, Object param2) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void fatalv(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param params the parameters */
public void fatalv(Throwable t, String format, Object... params) { doLog(Level.FATAL, FQCN, format, params, t); }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void fatalv(Throwable t, String format, Object param1) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void fatalv(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message with a level of FATAL using MessageFormat-style formatting.
Params:
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message with a level of FATAL using {@link java.text.MessageFormat}-style formatting. * * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void fatalv(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.FATAL)) { doLog(Level.FATAL, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message with a level of FATAL.
Params:
/** * Issue a formatted log message with a level of FATAL. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void fatalf(String format, Object... params) { doLogf(Level.FATAL, FQCN, format, params, null); }
Issue a formatted log message with a level of FATAL.
Params:
/** * Issue a formatted log message with a level of FATAL. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void fatalf(String format, Object param1) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message with a level of FATAL.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message with a level of FATAL. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void fatalf(String format, Object param1, Object param2) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message with a level of FATAL.
Params:
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of FATAL. * * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void fatalf(String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message with a level of FATAL.
Params:
/** * Issue a formatted log message with a level of FATAL. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void fatalf(Throwable t, String format, Object... params) { doLogf(Level.FATAL, FQCN, format, params, t); }
Issue a formatted log message with a level of FATAL.
Params:
/** * Issue a formatted log message with a level of FATAL. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void fatalf(Throwable t, String format, Object param1) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message with a level of FATAL.
Params:
/** * Issue a formatted log message with a level of FATAL. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void fatalf(Throwable t, String format, Object param1, Object param2) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message with a level of FATAL.
Params:
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message with a level of FATAL. * * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void fatalf(Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(Level.FATAL)) { doLogf(Level.FATAL, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Log a message at the given level.
Params:
  • level – the level
  • message – the message
/** * Log a message at the given level. * * @param level the level * @param message the message */
public void log(Level level, Object message) { doLog(level, FQCN, message, null, null); }
Issue a log message and throwable at the given log level.
Params:
  • level – the level
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable at the given log level. * * @param level the level * @param message the message * @param t the throwable */
public void log(Level level, Object message, Throwable t) { doLog(level, FQCN, message, null, t); }
Issue a log message and throwable at the given log level and a specific logger class name.
Params:
  • level – the level
  • loggerFqcn – the logger class name
  • message – the message
  • t – the throwable
/** * Issue a log message and throwable at the given log level and a specific logger class name. * * @param level the level * @param loggerFqcn the logger class name * @param message the message * @param t the throwable */
public void log(Level level, String loggerFqcn, Object message, Throwable t) { doLog(level, loggerFqcn, message, null, t); }
Issue a log message with parameters at the given log level.
Params:
  • level – the level
  • message – the message
  • params – the message parameters
Deprecated:To log a message with parameters, using logv(Level, String, Object...) is recommended.
/** * Issue a log message with parameters at the given log level. * * @param level the level * @param message the message * @param params the message parameters * @deprecated To log a message with parameters, using {@link #logv(Level, String, Object...)} is recommended. */
@Deprecated public void log(Level level, Object message, Object[] params) { doLog(level, FQCN, message, params, null); }
Issue a log message with parameters and a throwable at the given log level.
Params:
  • level – the level
  • message – the message
  • params – the message parameters
  • t – the throwable
Deprecated:To log a message with parameters, using logv(Level, Throwable, String, Object...) is recommended.
/** * Issue a log message with parameters and a throwable at the given log level. * * @param level the level * @param message the message * @param params the message parameters * @param t the throwable * @deprecated To log a message with parameters, using {@link #logv(Level, Throwable, String, Object...)} is recommended. */
@Deprecated public void log(Level level, Object message, Object[] params, Throwable t) { doLog(level, FQCN, message, params, t); }
Issue a log message with parameters and a throwable at the given log level.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • message – the message
  • params – the message parameters
  • t – the throwable
/** * Issue a log message with parameters and a throwable at the given log level. * * @param loggerFqcn the logger class name * @param level the level * @param message the message * @param params the message parameters * @param t the throwable */
public void log(String loggerFqcn, Level level, Object message, Object[] params, Throwable t) { doLog(level, loggerFqcn, message, params, t); }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • format – the message format string
  • params – the parameters
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param format the message format string * @param params the parameters */
public void logv(Level level, String format, Object... params) { doLog(level, FQCN, format, params, null); }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param format the message format string * @param param1 the sole parameter */
public void logv(Level level, String format, Object param1) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1 }, null); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void logv(Level level, String format, Object param1, Object param2) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logv(Level level, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param t the throwable * @param format the message format string * @param params the parameters */
public void logv(Level level, Throwable t, String format, Object... params) { doLog(level, FQCN, format, params, t); }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void logv(Level level, Throwable t, String format, Object param1) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1 }, t); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void logv(Level level, Throwable t, String format, Object param1, Object param2) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param level the level * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logv(Level level, Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLog(level, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable
  • format – the message format string
  • params – the parameters
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable * @param format the message format string * @param params the parameters */
public void logv(String loggerFqcn, Level level, Throwable t, String format, Object... params) { doLog(level, loggerFqcn, format, params, t); }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the sole parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable * @param format the message format string * @param param1 the sole parameter */
public void logv(String loggerFqcn, Level level, Throwable t, String format, Object param1) { if (isEnabled(level)) { doLog(level, loggerFqcn, format, new Object[] { param1 }, t); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter */
public void logv(String loggerFqcn, Level level, Throwable t, String format, Object param1, Object param2) { if (isEnabled(level)) { doLog(level, loggerFqcn, format, new Object[] { param1, param2 }, t); } }
Issue a log message at the given log level using MessageFormat-style formatting.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable
  • format – the message format string
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a log message at the given log level using {@link java.text.MessageFormat}-style formatting. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable * @param format the message format string * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logv(String loggerFqcn, Level level, Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLog(level, loggerFqcn, format, new Object[] { param1, param2, param3 }, t); } }
Issue a formatted log message at the given log level.
Params:
/** * Issue a formatted log message at the given log level. * * @param level the level * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the parameters */
public void logf(Level level, String format, Object... params) { doLogf(level, FQCN, format, params, null); }
Issue a formatted log message at the given log level.
Params:
/** * Issue a formatted log message at the given log level. * * @param level the level * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void logf(Level level, String format, Object param1) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1 }, null); } }
Issue a formatted log message at the given log level.
Params:
  • level – the level
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message at the given log level. * * @param level the level * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void logf(Level level, String format, Object param1, Object param2) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1, param2 }, null); } }
Issue a formatted log message at the given log level.
Params:
  • level – the level
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message at the given log level. * * @param level the level * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logf(Level level, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1, param2, param3 }, null); } }
Issue a formatted log message at the given log level.
Params:
/** * Issue a formatted log message at the given log level. * * @param level the level * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param params the parameters */
public void logf(Level level, Throwable t, String format, Object... params) { doLogf(level, FQCN, format, params, t); }
Issue a formatted log message at the given log level.
Params:
/** * Issue a formatted log message at the given log level. * * @param level the level * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the sole parameter */
public void logf(Level level, Throwable t, String format, Object param1) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1 }, t); } }
Issue a formatted log message at the given log level.
Params:
  • level – the level
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
/** * Issue a formatted log message at the given log level. * * @param level the level * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter */
public void logf(Level level, Throwable t, String format, Object param1, Object param2) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1, param2 }, t); } }
Issue a formatted log message at the given log level.
Params:
  • level – the level
  • t – the throwable
  • format – the format string, as per String.format(String, Object...)
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Issue a formatted log message at the given log level. * * @param level the level * @param t the throwable * @param format the format string, as per {@link String#format(String, Object...)} * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logf(Level level, Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLogf(level, FQCN, format, new Object[] { param1, param2, param3 }, t); } }
Log a message at the given level.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable cause
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the sole parameter
/** * Log a message at the given level. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable cause * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the sole parameter */
public void logf(String loggerFqcn, Level level, Throwable t, String format, Object param1) { if (isEnabled(level)) { doLogf(level, loggerFqcn, format, new Object[] { param1 }, t); } }
Log a message at the given level.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable cause
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
/** * Log a message at the given level. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable cause * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter */
public void logf(String loggerFqcn, Level level, Throwable t, String format, Object param1, Object param2) { if (isEnabled(level)) { doLogf(level, loggerFqcn, format, new Object[] { param1, param2 }, t); } }
Log a message at the given level.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable cause
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • param1 – the first parameter
  • param2 – the second parameter
  • param3 – the third parameter
/** * Log a message at the given level. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable cause * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param param1 the first parameter * @param param2 the second parameter * @param param3 the third parameter */
public void logf(String loggerFqcn, Level level, Throwable t, String format, Object param1, Object param2, Object param3) { if (isEnabled(level)) { doLogf(level, loggerFqcn, format, new Object[] { param1, param2, param3 }, t); } }
Log a message at the given level.
Params:
  • loggerFqcn – the logger class name
  • level – the level
  • t – the throwable cause
  • format – the format string as per String.format(String, Object...) or resource bundle key therefor
  • params – the message parameters
/** * Log a message at the given level. * * @param loggerFqcn the logger class name * @param level the level * @param t the throwable cause * @param format the format string as per {@link String#format(String, Object...)} or resource bundle key therefor * @param params the message parameters */
public void logf(String loggerFqcn, Level level, Throwable t, String format, Object... params) { doLogf(level, loggerFqcn, format, params, t); }
Read resolver; replaces deserialized instance with a canonical instance.
Returns:the canonical logger instance
/** * Read resolver; replaces deserialized instance with a canonical instance. * * @return the canonical logger instance */
protected final Object writeReplace() { return new SerializedLogger(name); }
Get a Logger instance given the logger name.
Params:
  • name – the logger name
Returns:the logger
/** * Get a Logger instance given the logger name. * * @param name the logger name * * @return the logger */
public static Logger getLogger(String name) { return LoggerProviders.PROVIDER.getLogger(name); }
Get a Logger instance given the logger name with the given suffix.

This will include a logger separator between logger name and suffix.

Params:
  • name – the logger name
  • suffix – a suffix to append to the logger name
Returns:the logger
/** * Get a Logger instance given the logger name with the given suffix. * <p/> * <p>This will include a logger separator between logger name and suffix. * * @param name the logger name * @param suffix a suffix to append to the logger name * * @return the logger */
public static Logger getLogger(String name, String suffix) { return getLogger(name == null || name.length() == 0 ? suffix : name + "." + suffix); }
Get a Logger instance given the name of a class. This simply calls create(clazz.getName()).
Params:
  • clazz – the Class whose name will be used as the logger name
Returns:the logger
/** * Get a Logger instance given the name of a class. This simply calls create(clazz.getName()). * * @param clazz the Class whose name will be used as the logger name * * @return the logger */
public static Logger getLogger(Class<?> clazz) { return getLogger(clazz.getName()); }
Get a Logger instance given the name of a class with the given suffix.

This will include a logger separator between logger name and suffix

Params:
  • clazz – the Class whose name will be used as the logger name
  • suffix – a suffix to append to the logger name
Returns:the logger
/** * Get a Logger instance given the name of a class with the given suffix. * <p/> * <p>This will include a logger separator between logger name and suffix * * @param clazz the Class whose name will be used as the logger name * @param suffix a suffix to append to the logger name * * @return the logger */
public static Logger getLogger(Class<?> clazz, String suffix) { return getLogger(clazz.getName(), suffix); }
Get a typed logger which implements the given interface. The current default locale will be used for the new logger.
Params:
  • type – the interface to implement
  • category – the logger category
Type parameters:
  • <T> – the logger type
Returns:the typed logger
/** * Get a typed logger which implements the given interface. The current default locale will be used for the new logger. * * @param type the interface to implement * @param category the logger category * @param <T> the logger type * @return the typed logger */
public static <T> T getMessageLogger(Class<T> type, String category) { return getMessageLogger(type, category, LoggingLocale.getLocale()); }
Get a typed logger which implements the given interface. The given locale will be used for the new logger.
Params:
  • type – the interface to implement
  • category – the logger category
  • locale – the locale for the new logger
Type parameters:
  • <T> – the logger type
Returns:the typed logger
/** * Get a typed logger which implements the given interface. The given locale will be used for the new logger. * * @param type the interface to implement * @param category the logger category * @param locale the locale for the new logger * @param <T> the logger type * @return the typed logger */
public static <T> T getMessageLogger(final Class<T> type, final String category, final Locale locale) { if (System.getSecurityManager() == null) return doGetMessageLogger(type, category, locale); return doPrivileged(new PrivilegedAction<T>() { public T run() { return doGetMessageLogger(type, category, locale); } }); } private static <T> T doGetMessageLogger(final Class<T> type, final String category, final Locale locale) { String language = locale.getLanguage(); String country = locale.getCountry(); String variant = locale.getVariant(); Class<? extends T> loggerClass = null; final ClassLoader classLoader = type.getClassLoader(); final String typeName = type.getName(); if (variant != null && variant.length() > 0) try { loggerClass = Class.forName(join(typeName, "$logger", language, country, variant), true, classLoader).asSubclass(type); } catch (ClassNotFoundException e) { // ignore } if (loggerClass == null && country != null && country.length() > 0) try { loggerClass = Class.forName(join(typeName, "$logger", language, country, null), true, classLoader).asSubclass(type); } catch (ClassNotFoundException e) { // ignore } if (loggerClass == null && language != null && language.length() > 0) try { loggerClass = Class.forName(join(typeName, "$logger", language, null, null), true, classLoader).asSubclass(type); } catch (ClassNotFoundException e) { // ignore } if (loggerClass == null) try { loggerClass = Class.forName(join(typeName, "$logger", null, null, null), true, classLoader).asSubclass(type); } catch (ClassNotFoundException e) { throw new IllegalArgumentException("Invalid logger " + type + " (implementation not found in " + classLoader + ")"); } final Constructor<? extends T> constructor; try { constructor = loggerClass.getConstructor(Logger.class); } catch (NoSuchMethodException e) { throw new IllegalArgumentException("Logger implementation " + loggerClass + " has no matching constructor"); } try { return constructor.newInstance(Logger.getLogger(category)); } catch (InstantiationException e) { throw new IllegalArgumentException("Logger implementation " + loggerClass + " could not be instantiated", e); } catch (IllegalAccessException e) { throw new IllegalArgumentException("Logger implementation " + loggerClass + " could not be instantiated", e); } catch (InvocationTargetException e) { throw new IllegalArgumentException("Logger implementation " + loggerClass + " could not be instantiated", e.getCause()); } } private static String join(String interfaceName, String a, String b, String c, String d) { final StringBuilder build = new StringBuilder(); build.append(interfaceName).append('_').append(a); if (b != null && b.length() > 0) { build.append('_'); build.append(b); } if (c != null && c.length() > 0) { build.append('_'); build.append(c); } if (d != null && d.length() > 0) { build.append('_'); build.append(d); } return build.toString(); } }