Branch to see what folding Logger2 into Logger looks like. Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/4ca89fa7 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/4ca89fa7 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/4ca89fa7
Branch: refs/heads/master Commit: 4ca89fa711fc4818475155796ffd4b924e697a4e Parents: b0e892e Author: ggregory <[email protected]> Authored: Sun Aug 9 18:37:10 2015 -0700 Committer: ggregory <[email protected]> Committed: Sun Aug 9 18:37:10 2015 -0700 ---------------------------------------------------------------------- .../org/apache/logging/log4j/LogManager.java | 105 --- .../java/org/apache/logging/log4j/Logger.java | 713 ++++++++++++++++++ .../java/org/apache/logging/log4j/Logger2.java | 738 ------------------- .../logging/log4j/spi/AbstractLogger.java | 2 +- .../logging/log4j/spi/ExtendedLogger.java | 39 + .../logging/log4j/spi/ExtendedLogger2.java | 70 -- 6 files changed, 753 insertions(+), 914 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/4ca89fa7/log4j-api/src/main/java/org/apache/logging/log4j/LogManager.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/LogManager.java b/log4j-api/src/main/java/org/apache/logging/log4j/LogManager.java index c9a82b1..c99837d 100644 --- a/log4j-api/src/main/java/org/apache/logging/log4j/LogManager.java +++ b/log4j-api/src/main/java/org/apache/logging/log4j/LogManager.java @@ -415,16 +415,6 @@ public class LogManager { StringFormatterMessageFactory.INSTANCE); } - /** - * Returns a Logger2 with the name of the calling class. - * @return The Logger2 for the calling class. - * @throws UnsupportedOperationException if the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2() { - return (Logger2) getLogger(ReflectionUtil.getCallerClass(2)); - } - private static Class<?> callerClass(final Class<?> clazz) { if (clazz != null) { return clazz; @@ -437,101 +427,6 @@ public class LogManager { } /** - * Returns a Logger2 using the fully qualified name of the Class as the Logger name. - * @param clazz The Class whose name should be used as the Logger name. If null it will default to the calling - * class. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code clazz} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final Class<?> clazz) { - final Class<?> cls = callerClass(clazz); - return (Logger2) getContext(cls.getClassLoader(), false).getLogger(cls.getName()); - } - - /** - * Returns a Logger2 using the fully qualified name of the Class as the Logger name. - * @param clazz The Class whose name should be used as the Logger name. If null it will default to the calling - * class. - * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change - * the logger but will log a warning if mismatched. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code clazz} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final Class<?> clazz, final MessageFactory messageFactory) { - final Class<?> cls = callerClass(clazz); - return (Logger2) getContext(cls.getClassLoader(), false).getLogger(cls.getName(), messageFactory); - } - - /** - * Returns a Logger2 with the name of the calling class. - * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change - * the logger but will log a warning if mismatched. - * @return The Logger2 for the calling class. - * @throws UnsupportedOperationException if the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final MessageFactory messageFactory) { - return (Logger2) getLogger(ReflectionUtil.getCallerClass(2), messageFactory); - } - - /** - * Returns a Logger2 using the fully qualified class name of the value as the Logger name. - * @param value The value whose class name should be used as the Logger name. If null the name of the calling - * class will be used as the logger name. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code value} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final Object value) { - return (Logger2) getLogger(value != null ? value.getClass() : ReflectionUtil.getCallerClass(2)); - } - - /** - * Returns a Logger2 using the fully qualified class name of the value as the Logger name. - * @param value The value whose class name should be used as the Logger name. If null the name of the calling - * class will be used as the logger name. - * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change - * the logger but will log a warning if mismatched. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code value} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final Object value, final MessageFactory messageFactory) { - return (Logger2) getLogger(value != null ? value.getClass() : ReflectionUtil.getCallerClass(2), - messageFactory); - } - - /** - * Returns a Logger2 with the specified name. - * - * @param name The logger name. If null the name of the calling class will be used. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code name} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final String name) { - return (Logger2) (name != null ? getContext(false).getLogger(name) : getLogger( - ReflectionUtil.getCallerClass(2))); - } - - /** - * Returns a Logger2 with the specified name. - * - * @param name The logger name. If null the name of the calling class will be used. - * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change - * the logger but will log a warning if mismatched. - * @return The Logger2. - * @throws UnsupportedOperationException if {@code name} is {@code null} and the calling class cannot be determined. - * @since 2.4 - */ - public static Logger2 getLogger2(final String name, final MessageFactory messageFactory) { - return (Logger2) (name != null ? getContext(false).getLogger(name, messageFactory) : getLogger( - ReflectionUtil.getCallerClass(2), messageFactory)); - } - - /** * Returns a Logger with the name of the calling class. * @return The Logger for the calling class. * @throws UnsupportedOperationException if the calling class cannot be determined. http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/4ca89fa7/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java b/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java index 8f9c837..5d6ada9 100644 --- a/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java +++ b/log4j-api/src/main/java/org/apache/logging/log4j/Logger.java @@ -18,6 +18,8 @@ package org.apache.logging.log4j; import org.apache.logging.log4j.message.Message; import org.apache.logging.log4j.message.MessageFactory; +import org.apache.logging.log4j.util.MessageSupplier; +import org.apache.logging.log4j.util.Supplier; /** * This is the central interface in the log4j package. Most logging operations, except configuration, are done through @@ -42,6 +44,29 @@ import org.apache.logging.log4j.message.MessageFactory; * For service provider implementations, it is recommended to extend the * {@link org.apache.logging.log4j.spi.AbstractLogger} class rather than implementing this interface directly. * </p> + * + * Since 2.4: Extends the {@code Logger} interface with support for lambda expressions. + * <p> + * This logger allows client code to lazily log messages without explicitly checking if the requested log level is + * enabled. For example, previously one would write: + * + * <pre> + * // pre-Java 8 style optimization: explicitly check the log level + * // to make sure the expensiveOperation() method is only called if necessary + * Logger logger = LogManager.getLogger(); + * if (logger.isTraceEnabled()) { + * logger.trace("Some long-running operation returned {}", expensiveOperation()); + * } + * </pre> + * <p> + * With Java 8 and the {@code Logger2} interface, one can achieve the same effect by using a lambda expression: + * + * <pre> + * // Java-8 style optimization: no need to explicitly check the log level: + * // the lambda expression is not evaluated if the TRACE level is not enabled + * Logger2 logger = LogManager.getLogger2(); + * logger.trace("Some long-running operation returned {}", () -> expensiveOperation()); + * </pre> */ public interface Logger { @@ -1175,4 +1200,692 @@ public interface Logger { * @param t the exception to log, including its stack trace. */ void warn(String message, Throwable t); + + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void debug(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack trace. + */ + void debug(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with + * the specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void debug(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void debug(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with + * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the + * {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void debug(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The + * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void debug(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level. The + * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void debug(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may + * not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void debug(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG + * DEBUG} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void debug(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG + * DEBUG} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void debug(String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void error(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack trace. + */ + void error(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with + * the specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void error(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void error(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR + * ERROR} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void error(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void error(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void error(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void error(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void error(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR + * ERROR} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void error(String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void fatal(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack trace. + */ + void fatal(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with + * the specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void fatal(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void fatal(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL + * FATAL} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void fatal(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void fatal(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void fatal(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void fatal(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void fatal(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL + * FATAL} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void fatal(String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void info(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack trace. + */ + void info(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with the + * specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void info(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void info(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO + * INFO} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void info(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void info(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void info(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void info(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void info(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO + * INFO} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void info(String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the specified level. + * + * @param level the logging level + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void log(Level level, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the specified level) including the stack log of + * the {@link Throwable} <code>t</code> passed as parameter. + * + * @param level the logging level + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack log. + */ + void log(Level level, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker. + * + * @param level the logging level + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void log(Level level, Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker and + * including the stack log of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param level the logging level + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void log(Level level, Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the specified level. + * + * @param level the logging level + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void log(Level level, Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the specified level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param level the logging level + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void log(Level level, Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the specified level) with the + * specified Marker and including the stack log of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param level the logging level + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void log(Level level, Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the specified level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param level the logging level + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void log(Level level, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the specified level) including the + * stack log of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param level the logging level + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack log. + */ + void log(Level level, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the specified level. + * + * @param level the logging level + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void log(Level level, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void trace(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack trace. + */ + void trace(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with + * the specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void trace(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void trace(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE + * TRACE} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void trace(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void trace(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the + * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void trace(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void trace(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the + * stack trace of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void trace(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE + * TRACE} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void trace(String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void warn(Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the + * stack warn of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t the exception to log, including its stack warn. + */ + void warn(Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with the + * specified Marker. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + */ + void warn(Marker marker, Supplier<?> msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the + * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the + * message factory. + * @param t A Throwable or null. + */ + void warn(Marker marker, Supplier<?> msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN + * WARN} level. + * + * @param marker the marker data specific to this log statement + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void warn(Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with + * the specified Marker. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void warn(Marker marker, MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the + * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param marker the marker data specific to this log statement + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t A Throwable or null. + */ + void warn(Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + */ + void warn(MessageSupplier msgSupplier); + + /** + * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the + * stack warn of the {@link Throwable} <code>t</code> passed as parameter. + * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. + * + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack warn. + */ + void warn(MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN + * WARN} level. + * + * @param message the message to log; the format depends on the message factory. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void warn(String message, Supplier<?>... paramSuppliers); + } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/4ca89fa7/log4j-api/src/main/java/org/apache/logging/log4j/Logger2.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/Logger2.java b/log4j-api/src/main/java/org/apache/logging/log4j/Logger2.java deleted file mode 100644 index fb00fda..0000000 --- a/log4j-api/src/main/java/org/apache/logging/log4j/Logger2.java +++ /dev/null @@ -1,738 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You 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.apache.logging.log4j; - -import org.apache.logging.log4j.message.MessageFactory; -import org.apache.logging.log4j.util.MessageSupplier; -import org.apache.logging.log4j.util.Supplier; - -/** - * Extends the {@code Logger} interface with support for lambda expressions. - * <p> - * This logger allows client code to lazily log messages without explicitly checking if the requested log level is - * enabled. For example, previously one would write: - * - * <pre> - * // pre-Java 8 style optimization: explicitly check the log level - * // to make sure the expensiveOperation() method is only called if necessary - * Logger logger = LogManager.getLogger(); - * if (logger.isTraceEnabled()) { - * logger.trace("Some long-running operation returned {}", expensiveOperation()); - * } - * </pre> - * <p> - * With Java 8 and the {@code Logger2} interface, one can achieve the same effect by using a lambda expression: - * - * <pre> - * // Java-8 style optimization: no need to explicitly check the log level: - * // the lambda expression is not evaluated if the TRACE level is not enabled - * Logger2 logger = LogManager.getLogger2(); - * logger.trace("Some long-running operation returned {}", () -> expensiveOperation()); - * </pre> - * - * @since 2.4 - */ -public interface Logger2 extends Logger { - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void debug(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack trace. - */ - void debug(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with - * the specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void debug(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void debug(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with - * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the - * {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void debug(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The - * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void debug(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level. The - * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void debug(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may - * not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack trace. - */ - void debug(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG - * DEBUG} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void debug(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG - * DEBUG} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void debug(String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void error(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack trace. - */ - void error(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with - * the specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void error(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void error(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR - * ERROR} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void error(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void error(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void error(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void error(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack trace. - */ - void error(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR - * ERROR} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void error(String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void fatal(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack trace. - */ - void fatal(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with - * the specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void fatal(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void fatal(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL - * FATAL} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void fatal(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void fatal(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void fatal(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void fatal(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack trace. - */ - void fatal(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL - * FATAL} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void fatal(String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void info(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack trace. - */ - void info(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with the - * specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void info(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void info(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO - * INFO} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void info(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void info(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void info(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void info(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack trace. - */ - void info(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO - * INFO} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void info(String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the specified level. - * - * @param level the logging level - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void log(Level level, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the specified level) including the stack log of - * the {@link Throwable} <code>t</code> passed as parameter. - * - * @param level the logging level - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack log. - */ - void log(Level level, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker. - * - * @param level the logging level - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void log(Level level, Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker and - * including the stack log of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param level the logging level - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void log(Level level, Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the specified level. - * - * @param level the logging level - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void log(Level level, Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the specified level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param level the logging level - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void log(Level level, Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the specified level) with the - * specified Marker and including the stack log of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param level the logging level - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void log(Level level, Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the specified level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param level the logging level - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void log(Level level, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the specified level) including the - * stack log of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param level the logging level - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack log. - */ - void log(Level level, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the specified level. - * - * @param level the logging level - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void log(Level level, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void trace(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack trace. - */ - void trace(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with - * the specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void trace(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void trace(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE - * TRACE} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void trace(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void trace(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the - * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void trace(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void trace(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the - * stack trace of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack trace. - */ - void trace(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE - * TRACE} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void trace(String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void warn(Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the - * stack warn of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t the exception to log, including its stack warn. - */ - void warn(Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with the - * specified Marker. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - */ - void warn(Marker marker, Supplier<?> msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the - * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the - * message factory. - * @param t A Throwable or null. - */ - void warn(Marker marker, Supplier<?> msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN - * WARN} level. - * - * @param marker the marker data specific to this log statement - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void warn(Marker marker, String message, Supplier<?>... paramSuppliers); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with - * the specified Marker. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void warn(Marker marker, MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the - * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param marker the marker data specific to this log statement - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t A Throwable or null. - */ - void warn(Marker marker, MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - */ - void warn(MessageSupplier msgSupplier); - - /** - * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the - * stack warn of the {@link Throwable} <code>t</code> passed as parameter. - * The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}. - * - * @param msgSupplier A function, which when called, produces the desired log message. - * @param t the exception to log, including its stack warn. - */ - void warn(MessageSupplier msgSupplier, Throwable t); - - /** - * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN - * WARN} level. - * - * @param message the message to log; the format depends on the message factory. - * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. - */ - void warn(String message, Supplier<?>... paramSuppliers); - -} http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/4ca89fa7/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java b/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java index 641e36b..c4772a0 100644 --- a/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java +++ b/log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java @@ -33,7 +33,7 @@ import org.apache.logging.log4j.util.Supplier; /** * Base implementation of a Logger. It is highly recommended that any Logger implementation extend this class. */ -public abstract class AbstractLogger implements ExtendedLogger2, Serializable { +public abstract class AbstractLogger implements ExtendedLogger, Serializable { private static final long serialVersionUID = 2L; http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/4ca89fa7/log4j-api/src/main/java/org/apache/logging/log4j/spi/ExtendedLogger.java ---------------------------------------------------------------------- diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/spi/ExtendedLogger.java b/log4j-api/src/main/java/org/apache/logging/log4j/spi/ExtendedLogger.java index 8a36c57..4fe916d 100644 --- a/log4j-api/src/main/java/org/apache/logging/log4j/spi/ExtendedLogger.java +++ b/log4j-api/src/main/java/org/apache/logging/log4j/spi/ExtendedLogger.java @@ -20,6 +20,8 @@ import org.apache.logging.log4j.Level; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Marker; import org.apache.logging.log4j.message.Message; +import org.apache.logging.log4j.util.MessageSupplier; +import org.apache.logging.log4j.util.Supplier; /** * Extends the {@code Logger} interface with methods that facilitate implementing or extending {@code Logger}s. Users @@ -152,4 +154,41 @@ public interface ExtendedLogger extends Logger { * @param t the exception to log, including its stack trace. */ void logMessage(String fqcn, Level level, Marker marker, Message message, Throwable t); + + /** + * Logs a message which is only to be constructed if the specified level is active. + * + * @param fqcn The fully qualified class name of the logger entry point, used to determine the caller class and + * method when location information needs to be logged. + * @param level The logging Level to check. + * @param marker A Marker or null. + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void logIfEnabled(String fqcn, Level level, Marker marker, MessageSupplier msgSupplier, Throwable t); + + /** + * Logs a message whose parameters are only to be constructed if the specified level is active. + * + * @param fqcn The fully qualified class name of the logger entry point, used to determine the caller class and + * method when location information needs to be logged. + * @param level The logging Level to check. + * @param marker A Marker or null. + * @param message The message format. + * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters. + */ + void logIfEnabled(String fqcn, Level level, Marker marker, String message, Supplier<?>... paramSuppliers); + + /** + * Logs a message which is only to be constructed if the specified level is active. + * + * @param fqcn The fully qualified class name of the logger entry point, used to determine the caller class and + * method when location information needs to be logged. + * @param level The logging Level to check. + * @param marker A Marker or null. + * @param msgSupplier A function, which when called, produces the desired log message. + * @param t the exception to log, including its stack trace. + */ + void logIfEnabled(String fqcn, Level level, Marker marker, Supplier<?> msgSupplier, Throwable t); + }
