logging-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject svn commit: r1460506 [2/2] - /logging/log4j/log4j2/trunk/api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java
Date Mon, 25 Mar 2013 02:20:35 GMT

Modified: logging/log4j/log4j2/trunk/api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java
URL: http://svn.apache.org/viewvc/logging/log4j/log4j2/trunk/api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java?rev=1460506&r1=1460505&r2=1460506&view=diff
==============================================================================
--- logging/log4j/log4j2/trunk/api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java (original)
+++ logging/log4j/log4j2/trunk/api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java Mon Mar 25 02:20:35 2013
@@ -72,6 +72,35 @@ public abstract class AbstractLogger imp
 
     private static final String CATCHING = "catching";
 
+    /**
+     * Checks that the message factory a logger was created with is the same as the given messageFactory. If they are
+     * different log a warning to the {@linkplain StatusLogger}. A null MessageFactory translates to the default
+     * MessageFactory {@link #DEFAULT_MESSAGE_FACTORY_CLASS}.
+     *
+     * @param logger
+     *            The logger to check
+     * @param messageFactory
+     *            The message factory to check.
+     */
+    public static void checkMessageFactory(final Logger logger, final MessageFactory messageFactory) {
+        final String name = logger.getName();
+        final MessageFactory loggerMessageFactory = logger.getMessageFactory();
+        if (messageFactory != null && !loggerMessageFactory.equals(messageFactory)) {
+            StatusLogger
+                    .getLogger()
+                    .warn("The Logger {} was created with the message factory {} and is now requested with the " +
+                        "message factory {}, which may create log events with unexpected formatting.",
+                            name, loggerMessageFactory, messageFactory);
+        } else if (messageFactory == null
+                && !loggerMessageFactory.getClass().equals(DEFAULT_MESSAGE_FACTORY_CLASS)) {
+            StatusLogger
+                    .getLogger()
+                    .warn("The Logger {} was created with the message factory {} and is now requested with a null " +
+                        "message factory (defaults to {}), which may create log events with unexpected formatting.",
+                            name, loggerMessageFactory, DEFAULT_MESSAGE_FACTORY_CLASS.getName());
+        }
+    }
+
     private final String name;
 
     private final MessageFactory messageFactory;
@@ -106,31 +135,25 @@ public abstract class AbstractLogger imp
     }
 
     /**
-     * Checks that the message factory a logger was created with is the same as the given messageFactory. If they are
-     * different log a warning to the {@linkplain StatusLogger}. A null MessageFactory translates to the default
-     * MessageFactory {@link #DEFAULT_MESSAGE_FACTORY_CLASS}.
+     * Logs a Throwable that has been caught.
      *
-     * @param logger
-     *            The logger to check
-     * @param messageFactory
-     *            The message factory to check.
+     * @param level The logging Level.
+     * @param t     The Throwable.
      */
-    public static void checkMessageFactory(final Logger logger, final MessageFactory messageFactory) {
-        final String name = logger.getName();
-        final MessageFactory loggerMessageFactory = logger.getMessageFactory();
-        if (messageFactory != null && !loggerMessageFactory.equals(messageFactory)) {
-            StatusLogger
-                    .getLogger()
-                    .warn("The Logger {} was created with the message factory {} and is now requested with the " +
-                        "message factory {}, which may create log events with unexpected formatting.",
-                            name, loggerMessageFactory, messageFactory);
-        } else if (messageFactory == null
-                && !loggerMessageFactory.getClass().equals(DEFAULT_MESSAGE_FACTORY_CLASS)) {
-            StatusLogger
-                    .getLogger()
-                    .warn("The Logger {} was created with the message factory {} and is now requested with a null " +
-                        "message factory (defaults to {}), which may create log events with unexpected formatting.",
-                            name, loggerMessageFactory, DEFAULT_MESSAGE_FACTORY_CLASS.getName());
+    public void catching(final Level level, final Throwable t) {
+        if (isEnabled(level, CATCHING_MARKER, (Object) null, null)) {
+            log(CATCHING_MARKER, FQCN, level, messageFactory.newMessage(CATCHING), t);
+        }
+    }
+
+    /**
+     * Logs a Throwable at the {@link Level#ERROR ERROR} level..
+     *
+     * @param t The Throwable.
+     */
+    public void catching(final Throwable t) {
+        if (isEnabled(Level.ERROR, CATCHING_MARKER, (Object) null, null)) {
+            log(CATCHING_MARKER, FQCN, Level.ERROR, messageFactory.newMessage(CATCHING), t);
         }
     }
 
@@ -145,677 +168,608 @@ public abstract class AbstractLogger imp
     }
 
     /**
-     * Logs entry to a method.
+     * Logs a message with the specific Marker at the DEBUG level.
+     *
+     * @param marker the marker data specific to this log statement
+     * @param msg    the message string to be logged
      */
-    public void entry() {
-        if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
-            log(ENTRY_MARKER, FQCN, Level.TRACE, messageFactory.newMessage(" entry"), null);
+    public void debug(final Marker marker, final Message msg) {
+        if (isEnabled(Level.DEBUG, marker, msg, null)) {
+            log(marker, FQCN, Level.DEBUG, msg, null);
         }
     }
 
     /**
-     * Logs entry to a method.
+     * Logs a message with the specific Marker at the DEBUG level.
      *
-     * @param params The parameters to the method.
+     * @param marker the marker data specific to this log statement.
+     * @param msg    the message string to be logged
+     * @param t      A Throwable or null.
      */
-    public void entry(final Object... params) {
-        if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
-            log(ENTRY_MARKER, FQCN, Level.TRACE, entryMsg(params.length, params), null);
+    public void debug(final Marker marker, final Message msg, final Throwable t) {
+        if (isEnabled(Level.DEBUG, marker, msg, t)) {
+            log(marker, FQCN, Level.DEBUG, msg, t);
         }
     }
 
     /**
-     * Logs exit from a method.
+     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
+     *
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
      */
-    public void exit() {
-        if (isEnabled(Level.TRACE, EXIT_MARKER, (Object) null, null)) {
-            log(EXIT_MARKER, FQCN, Level.TRACE, toExitMsg(null), null);
+    public void debug(final Marker marker, final Object message) {
+        if (isEnabled(Level.DEBUG, marker, message, null)) {
+            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
         }
     }
 
+
     /**
-     * Logs exiting from a method with the result.
+     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
-     * @param <R> The type of the parameter and object being returned.
-     * @param result The result being returned from the method call.
-     * @return the Throwable.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public <R> R exit(final R result) {
-        if (isEnabled(Level.TRACE, EXIT_MARKER, (Object) null, null)) {
-            log(EXIT_MARKER, FQCN, Level.TRACE, toExitMsg(result), null);
+    public void debug(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.DEBUG, marker, message, t)) {
+            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
         }
-        return result;
     }
 
     /**
-     * Logs a Throwable to be thrown.
+     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
      *
-     * @param <T> the type of the Throwable.
-     * @param t The Throwable.
-     * @return the Throwable.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
      */
-    public <T extends Throwable> T throwing(final T t) {
-        if (isEnabled(Level.ERROR, THROWING_MARKER, (Object) null, null)) {
-            log(THROWING_MARKER, FQCN, Level.ERROR, messageFactory.newMessage(THROWING), t);
+    public void debug(final Marker marker, final String message) {
+        if (isEnabled(Level.DEBUG, marker, message)) {
+            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
         }
-        return t;
     }
 
-
     /**
-     * Logs a Throwable to be thrown.
+     * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
      *
-     * @param <T> the type of the Throwable.
-     * @param level The logging Level.
-     * @param t     The Throwable.
-     * @return the Throwable.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public <T extends Throwable> T throwing(final Level level, final T t) {
-        if (isEnabled(level, THROWING_MARKER, (Object) null, null)) {
-            log(THROWING_MARKER, FQCN, level, messageFactory.newMessage(THROWING), t);
+    public void debug(final Marker marker, final String message, final Object... params) {
+        if (isEnabled(Level.DEBUG, marker, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(marker, FQCN, Level.DEBUG, msg, msg.getThrowable());
         }
-        return t;
     }
 
     /**
-     * Logs a Throwable at the {@link Level#ERROR ERROR} level..
+     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
-     * @param t The Throwable.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void catching(final Throwable t) {
-        if (isEnabled(Level.ERROR, CATCHING_MARKER, (Object) null, null)) {
-            log(CATCHING_MARKER, FQCN, Level.ERROR, messageFactory.newMessage(CATCHING), t);
+    public void debug(final Marker marker, final String message, final Throwable t) {
+        if (isEnabled(Level.DEBUG, marker, message, t)) {
+            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a Throwable that has been caught.
+     * Logs a message with the specific Marker at the DEBUG level.
      *
-     * @param level The logging Level.
-     * @param t     The Throwable.
+     * @param msg the message string to be logged
      */
-    public void catching(final Level level, final Throwable t) {
-        if (isEnabled(level, CATCHING_MARKER, (Object) null, null)) {
-            log(CATCHING_MARKER, FQCN, level, messageFactory.newMessage(CATCHING), t);
+    public void debug(final Message msg) {
+        if (isEnabled(Level.DEBUG, null, msg, null)) {
+            log(null, FQCN, Level.DEBUG, msg, null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#TRACE TRACE} level.
+     * Logs a message with the specific Marker at the DEBUG level.
      *
-     * @param message the message object to log.
+     * @param msg the message string to be logged
+     * @param t   A Throwable or null.
      */
-    public void trace(final String message) {
-        if (isEnabled(Level.TRACE, null, message)) {
-            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
+    public void debug(final Message msg, final Throwable t) {
+        if (isEnabled(Level.DEBUG, null, msg, t)) {
+            log(null, FQCN, Level.DEBUG, msg, t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#TRACE TRACE} level.
+     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
      *
-     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      */
-    public void trace(final Marker marker, final String message) {
-        if (isEnabled(Level.TRACE, marker, message)) {
-            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
+    public void debug(final Object message) {
+        if (isEnabled(Level.DEBUG, null, message, null)) {
+            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#TRACE TRACE} level including the
+     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
-     * <p/>
-     * <p>
-     * See {@link #debug(String)} form for more detailed information.
-     * </p>
      *
-     * @param message the message object to log.
+     * @param message the message to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void trace(final String message, final Throwable t) {
-        if (isEnabled(Level.TRACE, null, message, t)) {
-            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
+    public void debug(final Object message, final Throwable t) {
+        if (isEnabled(Level.DEBUG, null, message, t)) {
+            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#TRACE TRACE} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
-     * <p/>
-     * <p>
-     * See {@link #debug(String)} form for more detailed information.
-     * </p>
+     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
      *
-     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
      */
-    public void trace(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.TRACE, marker, message, t)) {
-            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
+    public void debug(final String message) {
+        if (isEnabled(Level.DEBUG, null, message)) {
+            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#TRACE TRACE} level.
+     * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
      *
-     * @param message the message object to log.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void trace(final Object message) {
-        if (isEnabled(Level.TRACE, null, message, null)) {
-            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
+    public void debug(final String message, final Object... params) {
+        if (isEnabled(Level.DEBUG, null, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(null, FQCN, Level.DEBUG, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#TRACE TRACE} level.
+     * Logs a message at the {@link Level#DEBUG DEBUG} level 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 message the message object to log.
+     * @param message the message to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void trace(final Marker marker, final Object message) {
-        if (isEnabled(Level.TRACE, marker, message, null)) {
-            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
+    public void debug(final String message, final Throwable t) {
+        if (isEnabled(Level.DEBUG, null, message, t)) {
+            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#TRACE TRACE} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
-     * <p/>
-     * <p>
-     * See {@link #debug(String)} form for more detailed information.
-     * </p>
-     *
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * Logs entry to a method.
      */
-    public void trace(final Object message, final Throwable t) {
-        if (isEnabled(Level.TRACE, null, message, t)) {
-            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
+    public void entry() {
+        if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
+            log(ENTRY_MARKER, FQCN, Level.TRACE, messageFactory.newMessage(" entry"), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#TRACE TRACE} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
-     * <p/>
-     * <p>
-     * See {@link #debug(String)} form for more detailed information.
-     * </p>
+     * Logs entry to a method.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param params The parameters to the method.
      */
-    public void trace(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.TRACE, marker, message, t)) {
-            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
+    public void entry(final Object... params) {
+        if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
+            log(ENTRY_MARKER, FQCN, Level.TRACE, entryMsg(params.length, params), null);
         }
     }
 
-    /**
-     * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
-     *
-     * @param message the message to log.
-     * @param params  parameters to the message.
-     */
-    public void trace(final String message, final Object... params) {
-        if (isEnabled(Level.TRACE, null, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.TRACE, msg, msg.getThrowable());
+    private Message entryMsg(final int count, final Object... params) {
+        if (count == 0) {
+            return messageFactory.newMessage(" entry");
+        }
+        final StringBuilder sb = new StringBuilder(" entry parms(");
+        int i = 0;
+        for (final Object parm : params) {
+            if (parm != null) {
+                sb.append(parm.toString());
+            } else {
+                sb.append("null");
+            }
+            if (++i < params.length) {
+                sb.append(", ");
+            }
         }
+        sb.append(")");
+        return messageFactory.newMessage(sb.toString());
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
+     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param marker the marker data specific to this log statement
+     * @param msg    the message string to be logged
      */
-    public void trace(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.TRACE, marker, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.TRACE, msg, msg.getThrowable());
+    public void error(final Marker marker, final Message msg) {
+        if (isEnabled(Level.ERROR, marker, msg, null)) {
+            log(marker, FQCN, Level.ERROR, msg, null);
         }
     }
 
     /**
-     * Checks whether this Logger is enabled for the TRACE  Level.
+     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
      *
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         TRACE, {@code false} otherwise.
+     * @param marker the marker data specific to this log statement
+     * @param msg    the message string to be logged
+     * @param t      A Throwable or null.
      */
-    public boolean isTraceEnabled() {
-        return isEnabled(Level.TRACE, null, (Object) null, null);
+    public void error(final Marker marker, final Message msg, final Throwable t) {
+        if (isEnabled(Level.ERROR, marker, msg, t)) {
+            log(marker, FQCN, Level.ERROR, msg, t);
+        }
     }
 
     /**
-     * Checks whether this Logger is enabled for the TRACE  Level.
+     * Logs a message object with the {@link Level#ERROR ERROR} level.
      *
-     * @param marker The marker data.
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         TRACE, {@code false} otherwise.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
      */
-    public boolean isTraceEnabled(final Marker marker) {
-        return isEnabled(Level.TRACE, marker, (Object) null, null);
+    public void error(final Marker marker, final Object message) {
+        if (isEnabled(Level.ERROR, marker, message, null)) {
+            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
+        }
     }
 
     /**
-     * Logs a message with the specific Marker at the TRACE level.
+     * Logs a message at the {@link Level#ERROR ERROR} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
-     * @param msg the message string to be logged
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void trace(final Message msg) {
-        if (isEnabled(Level.TRACE, null, msg, null)) {
-            log(null, FQCN, Level.TRACE, msg, null);
+    public void error(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.ERROR, marker, message, t)) {
+            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the TRACE level.
+     * Logs a message object with the {@link Level#ERROR ERROR} level.
      *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
      */
-    public void trace(final Message msg, final Throwable t) {
-        if (isEnabled(Level.TRACE, null, msg, t)) {
-            log(null, FQCN, Level.TRACE, msg, t);
+    public void error(final Marker marker, final String message) {
+        if (isEnabled(Level.ERROR, marker, message)) {
+            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the TRACE level.
+     * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
      *
      * @param marker the marker data specific to this log statement.
-     * @param msg    the message string to be logged
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void trace(final Marker marker, final Message msg) {
-        if (isEnabled(Level.TRACE, marker, msg, null)) {
-            log(marker, FQCN, Level.TRACE, msg, null);
+    public void error(final Marker marker, final String message, final Object... params) {
+        if (isEnabled(Level.ERROR, marker, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(marker, FQCN, Level.ERROR, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the TRACE level.
+     * Logs a message at the {@link Level#ERROR ERROR} level 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 msg    the message string to be logged
-     * @param t      A Throwable or null.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void trace(final Marker marker, final Message msg, final Throwable t) {
-        if (isEnabled(Level.TRACE, marker, msg, t)) {
-            log(marker, FQCN, Level.TRACE, msg, t);
+    public void error(final Marker marker, final String message, final Throwable t) {
+        if (isEnabled(Level.ERROR, marker, message, t)) {
+            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
+     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
      *
-     * @param message the message object to log.
+     * @param msg the message string to be logged
      */
-    public void debug(final String message) {
-        if (isEnabled(Level.DEBUG, null, message)) {
-            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
+    public void error(final Message msg) {
+        if (isEnabled(Level.ERROR, null, msg, null)) {
+            log(null, FQCN, Level.ERROR, msg, null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
+     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @param msg the message string to be logged
+     * @param t   A Throwable or null.
      */
-    public void debug(final Marker marker, final String message) {
-        if (isEnabled(Level.DEBUG, marker, message)) {
-            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
+    public void error(final Message msg, final Throwable t) {
+        if (isEnabled(Level.ERROR, null, msg, t)) {
+            log(null, FQCN, Level.ERROR, msg, t);
         }
     }
-
     /**
-     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message object with the {@link Level#ERROR ERROR} level.
      *
-     * @param message the message to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param message the message object to log.
      */
-    public void debug(final String message, final Throwable t) {
-        if (isEnabled(Level.DEBUG, null, message, t)) {
-            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
+    public void error(final Object message) {
+        if (isEnabled(Level.ERROR, null, message, null)) {
+            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
+     * Logs a message at the {@link Level#ERROR ERROR} level 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 message the message to log.
+     * @param message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void debug(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.DEBUG, marker, message, t)) {
-            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
+    public void error(final Object message, final Throwable t) {
+        if (isEnabled(Level.ERROR, null, message, t)) {
+            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
         }
     }
+
     /**
-     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
+     * Logs a message object with the {@link Level#ERROR ERROR} level.
      *
      * @param message the message object to log.
      */
-    public void debug(final Object message) {
-        if (isEnabled(Level.DEBUG, null, message, null)) {
-            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
+    public void error(final String message) {
+        if (isEnabled(Level.ERROR, null, message)) {
+            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
+     * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void debug(final Marker marker, final Object message) {
-        if (isEnabled(Level.DEBUG, marker, message, null)) {
-            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), null);
+    public void error(final String message, final Object... params) {
+        if (isEnabled(Level.ERROR, null, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(null, FQCN, Level.ERROR, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message at the {@link Level#DEBUG DEBUG} level including the
+     * Logs a message at the {@link Level#ERROR ERROR} level including the
      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
-     * @param message the message to log.
+     * @param message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void debug(final Object message, final Throwable t) {
-        if (isEnabled(Level.DEBUG, null, message, t)) {
-            log(null, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
+    public void error(final String message, final Throwable t) {
+        if (isEnabled(Level.ERROR, null, message, t)) {
+            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#DEBUG DEBUG} level 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 message the message to log.
-     * @param t       the exception to log, including its stack trace.
+     * Logs exit from a method.
      */
-    public void debug(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.DEBUG, marker, message, t)) {
-            log(marker, FQCN, Level.DEBUG, messageFactory.newMessage(message), t);
+    public void exit() {
+        if (isEnabled(Level.TRACE, EXIT_MARKER, (Object) null, null)) {
+            log(EXIT_MARKER, FQCN, Level.TRACE, toExitMsg(null), null);
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
+     * Logs exiting from a method with the result.
      *
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param <R> The type of the parameter and object being returned.
+     * @param result The result being returned from the method call.
+     * @return the Throwable.
      */
-    public void debug(final String message, final Object... params) {
-        if (isEnabled(Level.DEBUG, null, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.DEBUG, msg, msg.getThrowable());
+    public <R> R exit(final R result) {
+        if (isEnabled(Level.TRACE, EXIT_MARKER, (Object) null, null)) {
+            log(EXIT_MARKER, FQCN, Level.TRACE, toExitMsg(result), null);
         }
+        return result;
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
+     * Logs a message with the specific Marker at the FATAL level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message to log.
-     * @param params  parameters to the message.
-     */
-    public void debug(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.DEBUG, marker, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.DEBUG, msg, msg.getThrowable());
-        }
-    }
-
-    /**
-     * Checks whether this Logger is enabled for the DEBUG Level.
-     *
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         DEBUG, {@code false} otherwise.
-     */
-    public boolean isDebugEnabled() {
-        return isEnabled(Level.DEBUG, null, null);
-    }
-
-    /**
-     * Checks whether this Logger is enabled for the DEBUG Level.
-     *
-     * @param marker The marker data.
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         DEBUG, {@code false} otherwise.
-     */
-    public boolean isDebugEnabled(final Marker marker) {
-        return isEnabled(Level.DEBUG, marker, (Object) null, null);
-    }
-
-    /**
-     * Logs a message with the specific Marker at the DEBUG level.
-     *
-     * @param msg the message string to be logged
-     */
-    public void debug(final Message msg) {
-        if (isEnabled(Level.DEBUG, null, msg, null)) {
-            log(null, FQCN, Level.DEBUG, msg, null);
-        }
-    }
-
-    /**
-     * Logs a message with the specific Marker at the DEBUG level.
-     *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+     * @param marker the marker data specific to this log statement
+     * @param msg    the message string to be logged
      */
-    public void debug(final Message msg, final Throwable t) {
-        if (isEnabled(Level.DEBUG, null, msg, t)) {
-            log(null, FQCN, Level.DEBUG, msg, t);
+    public void fatal(final Marker marker, final Message msg) {
+        if (isEnabled(Level.FATAL, marker, msg, null)) {
+            log(marker, FQCN, Level.FATAL, msg, null);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the DEBUG level.
+     * Logs a message with the specific Marker at the FATAL level.
      *
      * @param marker the marker data specific to this log statement
      * @param msg    the message string to be logged
+     * @param t      A Throwable or null.
      */
-    public void debug(final Marker marker, final Message msg) {
-        if (isEnabled(Level.DEBUG, marker, msg, null)) {
-            log(marker, FQCN, Level.DEBUG, msg, null);
+    public void fatal(final Marker marker, final Message msg, final Throwable t) {
+        if (isEnabled(Level.FATAL, marker, msg, t)) {
+            log(marker, FQCN, Level.FATAL, msg, t);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the DEBUG level.
+     * Logs a message object with the {@link Level#FATAL FATAL} level.
      *
      * @param marker the marker data specific to this log statement.
-     * @param msg    the message string to be logged
-     * @param t      A Throwable or null.
+     * @param message the message object to log.
      */
-    public void debug(final Marker marker, final Message msg, final Throwable t) {
-        if (isEnabled(Level.DEBUG, marker, msg, t)) {
-            log(marker, FQCN, Level.DEBUG, msg, t);
+    public void fatal(final Marker marker, final Object message) {
+        if (isEnabled(Level.FATAL, marker, message, null)) {
+            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#INFO INFO} level.
+     * Logs a message at the {@link Level#FATAL FATAL} level 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 message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void info(final String message) {
-        if (isEnabled(Level.INFO, null, message)) {
-            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), null);
+    public void fatal(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.FATAL, marker, message, t)) {
+            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#INFO INFO} level.
+     * Logs a message object with the {@link Level#FATAL FATAL} level.
      *
      * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      */
-    public void info(final Marker marker, final String message) {
-        if (isEnabled(Level.INFO, marker, message)) {
-            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), null);
+    public void fatal(final Marker marker, final String message) {
+        if (isEnabled(Level.FATAL, marker, message)) {
+            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#INFO INFO} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
      *
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void info(final String message, final Throwable t) {
-        if (isEnabled(Level.INFO, null, message, t)) {
-            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), t);
+    public void fatal(final Marker marker, final String message, final Object... params) {
+        if (isEnabled(Level.FATAL, marker, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(marker, FQCN, Level.FATAL, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message at the {@link Level#INFO INFO} level including the
+     * Logs a message at the {@link Level#FATAL FATAL} level 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 message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void info(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.INFO, marker, message, t)) {
-            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), t);
+    public void fatal(final Marker marker, final String message, final Throwable t) {
+        if (isEnabled(Level.FATAL, marker, message, t)) {
+            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#INFO INFO} level.
+     * Logs a message with the specific Marker at the FATAL level.
      *
-     * @param message the message object to log.
+     * @param msg the message string to be logged
      */
-    public void info(final Object message) {
-        if (isEnabled(Level.INFO, null, message, null)) {
-            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), null);
+    public void fatal(final Message msg) {
+        if (isEnabled(Level.FATAL, null, msg, null)) {
+            log(null, FQCN, Level.FATAL, msg, null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#INFO INFO} level.
+     * Logs a message with the specific Marker at the FATAL level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @param msg the message string to be logged
+     * @param t   A Throwable or null.
      */
-    public void info(final Marker marker, final Object message) {
-        if (isEnabled(Level.INFO, marker, message, null)) {
-            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), null);
+    public void fatal(final Message msg, final Throwable t) {
+        if (isEnabled(Level.FATAL, null, msg, t)) {
+            log(null, FQCN, Level.FATAL, msg, t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#INFO INFO} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message object with the {@link Level#FATAL FATAL} level.
      *
      * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
      */
-    public void info(final Object message, final Throwable t) {
-        if (isEnabled(Level.INFO, null, message, t)) {
-            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), t);
+    public void fatal(final Object message) {
+        if (isEnabled(Level.FATAL, null, message, null)) {
+            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
         }
     }
 
-
     /**
-     * Logs a message at the {@link Level#INFO INFO} level including the
+     * Logs a message at the {@link Level#FATAL FATAL} level 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 message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void info(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.INFO, marker, message, t)) {
-            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), t);
+    public void fatal(final Object message, final Throwable t) {
+        if (isEnabled(Level.FATAL, null, message, t)) {
+            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#INFO INFO} level.
+     * Logs a message object with the {@link Level#FATAL FATAL} level.
      *
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param message the message object to log.
      */
-    public void info(final String message, final Object... params) {
-        if (isEnabled(Level.INFO, null, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.INFO, msg, msg.getThrowable());
+    public void fatal(final String message) {
+        if (isEnabled(Level.FATAL, null, message)) {
+            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
         }
     }
 
+
     /**
-     * Logs a message with parameters at the {@link Level#INFO INFO} level.
+     * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
      *
-     * @param marker the marker data specific to this log statement.
      * @param message the message to log.
      * @param params  parameters to the message.
      */
-    public void info(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.INFO, marker, message, params)) {
+    public void fatal(final String message, final Object... params) {
+        if (isEnabled(Level.FATAL, null, message, params)) {
             final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.INFO, msg, msg.getThrowable());
+            log(null, FQCN, Level.FATAL, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Checks whether this Logger is enabled for the INFO Level.
+     * Logs a message at the {@link Level#FATAL FATAL} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         INFO, {@code false} otherwise.
-     */
-    public boolean isInfoEnabled() {
-        return isEnabled(Level.INFO, null, (Object) null, null);
-    }
-
-    /**
-     * Checks whether this Logger is enabled for the INFO Level.
-     * @param marker The marker data.
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         INFO, {@code false} otherwise.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public boolean isInfoEnabled(final Marker marker) {
-        return isEnabled(Level.INFO, marker, (Object) null, null);
+    public void fatal(final String message, final Throwable t) {
+        if (isEnabled(Level.FATAL, null, message, t)) {
+            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
+        }
     }
 
     /**
-     * Logs a message with the specific Marker at the TRACE level.
+     * Gets the message factory.
      *
-     * @param msg the message string to be logged
+     * @return the message factory.
      */
-    public void info(final Message msg) {
-        if (isEnabled(Level.INFO, null, msg, null)) {
-            log(null, FQCN, Level.INFO, msg, null);
-        }
+    public MessageFactory getMessageFactory() {
+        return messageFactory;
     }
 
-    /**
-     * Logs a message with the specific Marker at the INFO level.
-     *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+    /* (non-Javadoc)
+     * @see org.apache.logging.log4j.Logger#getName()
      */
-    public void info(final Message msg, final Throwable t) {
-        if (isEnabled(Level.INFO, null, msg, t)) {
-            log(null, FQCN, Level.INFO, msg, t);
-        }
+    public String getName() {
+        return name;
     }
 
     /**
@@ -844,606 +798,627 @@ public abstract class AbstractLogger imp
     }
 
     /**
-     * Logs a message object with the {@link Level#WARN WARN} level.
+     * Logs a message object with the {@link Level#INFO INFO} level.
      *
+     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      */
-    public void warn(final String message) {
-        if (isEnabled(Level.WARN, null, message)) {
-            log(null, FQCN, Level.WARN, messageFactory.newMessage(message), null);
+    public void info(final Marker marker, final Object message) {
+        if (isEnabled(Level.INFO, marker, message, null)) {
+            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#WARN WARN} level.
+     * Logs a message at the {@link Level#INFO INFO} level 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 message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final Marker marker, final String message) {
-        if (isEnabled(Level.WARN, marker, message)) {
-            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), null);
+    public void info(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.INFO, marker, message, t)) {
+            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#WARN WARN} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message object with the {@link Level#INFO INFO} level.
      *
+     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final String message, final Throwable t) {
-        if (isEnabled(Level.WARN, null, message, t)) {
-            log(null, FQCN, Level.WARN, messageFactory.newMessage(message), t);
+    public void info(final Marker marker, final String message) {
+        if (isEnabled(Level.INFO, marker, message)) {
+            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#WARN WARN} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message with parameters at the {@link Level#INFO INFO} level.
      *
      * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void warn(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.WARN, marker, message, t)) {
-            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), t);
+    public void info(final Marker marker, final String message, final Object... params) {
+        if (isEnabled(Level.INFO, marker, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(marker, FQCN, Level.INFO, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#WARN WARN} level.
+     * Logs a message at the {@link Level#INFO INFO} level 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 message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final Marker marker, final Object message) {
-        if (isEnabled(Level.WARN, marker, message, null)) {
-            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), null);
+    public void info(final Marker marker, final String message, final Throwable t) {
+        if (isEnabled(Level.INFO, marker, message, t)) {
+            log(marker, FQCN, Level.INFO, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#WARN WARN} level.
+     * Logs a message with the specific Marker at the TRACE level.
+     *
+     * @param msg the message string to be logged
+     */
+    public void info(final Message msg) {
+        if (isEnabled(Level.INFO, null, msg, null)) {
+            log(null, FQCN, Level.INFO, msg, null);
+        }
+    }
+
+    /**
+     * Logs a message with the specific Marker at the INFO level.
+     *
+     * @param msg the message string to be logged
+     * @param t   A Throwable or null.
+     */
+    public void info(final Message msg, final Throwable t) {
+        if (isEnabled(Level.INFO, null, msg, t)) {
+            log(null, FQCN, Level.INFO, msg, t);
+        }
+    }
+
+    /**
+     * Logs a message object with the {@link Level#INFO INFO} level.
      *
      * @param message the message object to log.
      */
-    public void warn(final Object message) {
-        if (isEnabled(Level.WARN, null, message, null)) {
-            log(null, FQCN, Level.WARN, messageFactory.newMessage(message), null);
+    public void info(final Object message) {
+        if (isEnabled(Level.INFO, null, message, null)) {
+            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#WARN WARN} level including the
+     * Logs a message at the {@link Level#INFO INFO} level including the
      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
      *
      * @param message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final Object message, final Throwable t) {
-        if (isEnabled(Level.WARN, null, message, t)) {
-            log(null, FQCN, Level.WARN, messageFactory.newMessage(message), t);
+    public void info(final Object message, final Throwable t) {
+        if (isEnabled(Level.INFO, null, message, t)) {
+            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#WARN WARN} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message object with the {@link Level#INFO INFO} level.
      *
-     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.WARN, marker, message, t)) {
-            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), t);
+    public void info(final String message) {
+        if (isEnabled(Level.INFO, null, message)) {
+            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#WARN WARN} level.
+     * Logs a message with parameters at the {@link Level#INFO INFO} level.
      *
      * @param message the message to log.
      * @param params  parameters to the message.
      */
-    public void warn(final String message, final Object... params) {
-        if (isEnabled(Level.WARN, null, message, params)) {
+    public void info(final String message, final Object... params) {
+        if (isEnabled(Level.INFO, null, message, params)) {
             final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.WARN, msg, msg.getThrowable());
+            log(null, FQCN, Level.INFO, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#WARN WARN} level.
+     * Logs a message at the {@link Level#INFO INFO} level 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 message the message to log.
-     * @param params  parameters to the message.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void warn(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.WARN, marker, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.WARN, msg, msg.getThrowable());
+    public void info(final String message, final Throwable t) {
+        if (isEnabled(Level.INFO, null, message, t)) {
+            log(null, FQCN, Level.INFO, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Checks whether this Logger is enabled for the WARN Level.
+     * Checks whether this Logger is enabled for the DEBUG Level.
      *
      * @return boolean - {@code true} if this Logger is enabled for level
-     *         WARN, {@code false} otherwise.
+     *         DEBUG, {@code false} otherwise.
      */
-    public boolean isWarnEnabled() {
-        return isEnabled(Level.WARN, null, (Object) null, null);
+    public boolean isDebugEnabled() {
+        return isEnabled(Level.DEBUG, null, null);
     }
 
-
     /**
-     * Checks whether this Logger is enabled for the WARN Level.
+     * Checks whether this Logger is enabled for the DEBUG Level.
      *
      * @param marker The marker data.
      * @return boolean - {@code true} if this Logger is enabled for level
-     *         WARN, {@code false} otherwise.
+     *         DEBUG, {@code false} otherwise.
      */
-    public boolean isWarnEnabled(final Marker marker) {
-        return isEnabled(Level.WARN, marker, (Object) null, null);
+    public boolean isDebugEnabled(final Marker marker) {
+        return isEnabled(Level.DEBUG, marker, (Object) null, null);
     }
 
+
     /**
-     * Logs a message with the specific Marker at the WARN level.
-     *
-     * @param msg the message string to be logged
+     * Checks whether this Logger is enabled for the the given Level.
+     * <p>
+     * Note that passing in {@link Level#OFF OFF} always returns {@code true}.
+     * </p>
+     * @param level the level to check
+     * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise.
      */
-    public void warn(final Message msg) {
-        if (isEnabled(Level.WARN, null, msg, null)) {
-            log(null, FQCN, Level.WARN, msg, null);
-        }
+    public boolean isEnabled(final Level level) {
+        return isEnabled(level, null, (Object) null, null);
     }
 
     /**
-     * Logs a message with the specific Marker at the WARN level.
-     *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+     * Determine if logging is enabled.
+     * @param level The logging Level to check.
+     * @param marker A Marker or null.
+     * @param data The Message.
+     * @param t A Throwable.
+     * @return True if logging is enabled, false otherwise.
      */
-    public void warn(final Message msg, final Throwable t) {
-        if (isEnabled(Level.WARN, null, msg, t)) {
-            log(null, FQCN, Level.WARN, msg, t);
-        }
-    }
+    protected abstract boolean isEnabled(Level level, Marker marker, Message data, Throwable t);
 
     /**
-     * Logs a message with the specific Marker at the WARN level.
-     *
-     * @param marker the marker data specific to this log statement
-     * @param msg    the message string to be logged
+     * Determine if logging is enabled.
+     * @param level The logging Level to check.
+     * @param marker A Marker or null.
+     * @param data The message.
+     * @param t A Throwable.
+     * @return True if logging is enabled, false otherwise.
      */
-    public void warn(final Marker marker, final Message msg) {
-        if (isEnabled(Level.WARN, marker, msg, null)) {
-            log(marker, FQCN, Level.WARN, msg, null);
-        }
-    }
+    protected abstract boolean isEnabled(Level level, Marker marker, Object data, Throwable t);
 
     /**
-     * Logs a message with the specific Marker at the WARN level.
-     *
-     * @param marker the marker data specific to this log statement
-     * @param msg    the message string to be logged
-     * @param t      A Throwable or null.
+     * Determine if logging is enabled.
+     * @param level The logging Level to check.
+     * @param marker A Marker or null.
+     * @param data The message.
+     * @return True if logging is enabled, false otherwise.
      */
-    public void warn(final Marker marker, final Message msg, final Throwable t) {
-        if (isEnabled(Level.WARN, marker, msg, t)) {
-            log(marker, FQCN, Level.WARN, msg, t);
-        }
-    }
+    protected abstract boolean isEnabled(Level level, Marker marker, String data);
 
     /**
-     * Logs a message object with the {@link Level#ERROR ERROR} level.
-     *
-     * @param message the message object to log.
+     * Determine if logging is enabled.
+     * @param level The logging Level to check.
+     * @param marker A Marker or null.
+     * @param data The message.
+     * @param p1 The parameters.
+     * @return True if logging is enabled, false otherwise.
      */
-    public void error(final String message) {
-        if (isEnabled(Level.ERROR, null, message)) {
-            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
-        }
-    }
+    protected abstract boolean isEnabled(Level level, Marker marker, String data, Object... p1);
 
     /**
-     * Logs a message object with the {@link Level#ERROR ERROR} level.
+     * Determine if logging is enabled.
+     * @param level The logging Level to check.
+     * @param marker A Marker or null.
+     * @param data The message.
+     * @param t A Throwable.
+     * @return True if logging is enabled, false otherwise.
+     */
+    protected abstract boolean isEnabled(Level level, Marker marker, String data, Throwable t);
+
+    /**
+     * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         {@link Level#ERROR ERROR}, {@code false} otherwise.
      */
-    public void error(final Marker marker, final String message) {
-        if (isEnabled(Level.ERROR, marker, message)) {
-            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
-        }
+    public boolean isErrorEnabled() {
+        return isEnabled(Level.ERROR, null, (Object) null, null);
     }
 
     /**
-     * Logs a message at the {@link Level#ERROR ERROR} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
      *
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param marker The marker data.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         {@link Level#ERROR ERROR}, {@code false} otherwise.
      */
-    public void error(final String message, final Throwable t) {
-        if (isEnabled(Level.ERROR, null, message, t)) {
-            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
-        }
+    public boolean isErrorEnabled(final Marker marker) {
+        return isEnabled(Level.ERROR, marker, (Object) null, null);
     }
 
     /**
-     * Logs a message at the {@link Level#ERROR ERROR} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Checks whether this Logger is enabled for the FATAL Level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         FATAL, {@code false} otherwise.
      */
-    public void error(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.ERROR, marker, message, t)) {
-            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
-        }
+    public boolean isFatalEnabled() {
+        return isEnabled(Level.FATAL, null, (Object) null, null);
     }
 
     /**
-     * Logs a message object with the {@link Level#ERROR ERROR} level.
+     * Checks whether this Logger is enabled for the FATAL Level.
      *
-     * @param message the message object to log.
+     * @param marker The marker data.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         FATAL, {@code false} otherwise.
      */
-    public void error(final Object message) {
-        if (isEnabled(Level.ERROR, null, message, null)) {
-            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
-        }
+    public boolean isFatalEnabled(final Marker marker) {
+        return isEnabled(Level.FATAL, marker, (Object) null, null);
     }
 
     /**
-     * Logs a message object with the {@link Level#ERROR ERROR} level.
+     * Checks whether this Logger is enabled for the INFO Level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         INFO, {@code false} otherwise.
      */
-    public void error(final Marker marker, final Object message) {
-        if (isEnabled(Level.ERROR, marker, message, null)) {
-            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), null);
-        }
+    public boolean isInfoEnabled() {
+        return isEnabled(Level.INFO, null, (Object) null, null);
     }
 
     /**
-     * Logs a message at the {@link Level#ERROR ERROR} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
-     *
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * Checks whether this Logger is enabled for the INFO Level.
+     * @param marker The marker data.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         INFO, {@code false} otherwise.
      */
-    public void error(final Object message, final Throwable t) {
-        if (isEnabled(Level.ERROR, null, message, t)) {
-            log(null, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
-        }
+    public boolean isInfoEnabled(final Marker marker) {
+        return isEnabled(Level.INFO, marker, (Object) null, null);
     }
 
     /**
-     * Logs a message at the {@link Level#ERROR ERROR} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Checks whether this Logger is enabled for the TRACE  Level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         TRACE, {@code false} otherwise.
      */
-    public void error(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.ERROR, marker, message, t)) {
-            log(marker, FQCN, Level.ERROR, messageFactory.newMessage(message), t);
-        }
+    public boolean isTraceEnabled() {
+        return isEnabled(Level.TRACE, null, (Object) null, null);
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
+     * Checks whether this Logger is enabled for the TRACE  Level.
      *
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param marker The marker data.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         TRACE, {@code false} otherwise.
      */
-    public void error(final String message, final Object... params) {
-        if (isEnabled(Level.ERROR, null, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.ERROR, msg, msg.getThrowable());
-        }
+    public boolean isTraceEnabled(final Marker marker) {
+        return isEnabled(Level.TRACE, marker, (Object) null, null);
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
+     * Checks whether this Logger is enabled for the WARN Level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @return boolean - {@code true} if this Logger is enabled for level
+     *         WARN, {@code false} otherwise.
      */
-    public void error(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.ERROR, marker, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.ERROR, msg, msg.getThrowable());
-        }
+    public boolean isWarnEnabled() {
+        return isEnabled(Level.WARN, null, (Object) null, null);
     }
 
 
     /**
-     * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
+     * Checks whether this Logger is enabled for the WARN Level.
      *
+     * @param marker The marker data.
      * @return boolean - {@code true} if this Logger is enabled for level
-     *         {@link Level#ERROR ERROR}, {@code false} otherwise.
+     *         WARN, {@code false} otherwise.
      */
-    public boolean isErrorEnabled() {
-        return isEnabled(Level.ERROR, null, (Object) null, null);
+    public boolean isWarnEnabled(final Marker marker) {
+        return isEnabled(Level.WARN, marker, (Object) null, null);
     }
 
     /**
-     * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
+     * Logs a message with location information.
      *
-     * @param marker The marker data.
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         {@link Level#ERROR ERROR}, {@code false} otherwise.
+     * @param marker The Marker
+     * @param fqcn   The fully qualified class name of the <b>caller</b>
+     * @param level  The logging level
+     * @param data   The Message.
+     * @param t      A Throwable or null.
      */
-    public boolean isErrorEnabled(final Marker marker) {
-        return isEnabled(Level.ERROR, marker, (Object) null, null);
-    }
+    protected abstract void log(Marker marker, String fqcn, Level level, Message data, Throwable t);
 
     /**
-     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
+     * Logs a Throwable to be thrown.
      *
-     * @param msg the message string to be logged
+     * @param <T> the type of the Throwable.
+     * @param level The logging Level.
+     * @param t     The Throwable.
+     * @return the Throwable.
      */
-    public void error(final Message msg) {
-        if (isEnabled(Level.ERROR, null, msg, null)) {
-            log(null, FQCN, Level.ERROR, msg, null);
+    public <T extends Throwable> T throwing(final Level level, final T t) {
+        if (isEnabled(level, THROWING_MARKER, (Object) null, null)) {
+            log(THROWING_MARKER, FQCN, level, messageFactory.newMessage(THROWING), t);
         }
+        return t;
     }
 
     /**
-     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
+     * Logs a Throwable to be thrown.
      *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+     * @param <T> the type of the Throwable.
+     * @param t The Throwable.
+     * @return the Throwable.
      */
-    public void error(final Message msg, final Throwable t) {
-        if (isEnabled(Level.ERROR, null, msg, t)) {
-            log(null, FQCN, Level.ERROR, msg, t);
+    public <T extends Throwable> T throwing(final T t) {
+        if (isEnabled(Level.ERROR, THROWING_MARKER, (Object) null, null)) {
+            log(THROWING_MARKER, FQCN, Level.ERROR, messageFactory.newMessage(THROWING), t);
         }
+        return t;
     }
 
-    /**
-     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
-     *
-     * @param marker the marker data specific to this log statement
-     * @param msg    the message string to be logged
-     */
-    public void error(final Marker marker, final Message msg) {
-        if (isEnabled(Level.ERROR, marker, msg, null)) {
-            log(marker, FQCN, Level.ERROR, msg, null);
+    private Message toExitMsg(final Object result) {
+        if (result == null) {
+            return messageFactory.newMessage(" exit");
         }
+        return messageFactory.newMessage(" exit with (" + result + ")");
     }
 
     /**
-     * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
-     *
-     * @param marker the marker data specific to this log statement
-     * @param msg    the message string to be logged
-     * @param t      A Throwable or null.
+     * Returns a String representation of this instance in the form {@code "name"}.
+     * @return A String describing this Logger instance.
      */
-    public void error(final Marker marker, final Message msg, final Throwable t) {
-        if (isEnabled(Level.ERROR, marker, msg, t)) {
-            log(marker, FQCN, Level.ERROR, msg, t);
-        }
+    @Override
+    public String toString() {
+        return name;
     }
 
     /**
-     * Logs a message object with the {@link Level#FATAL FATAL} level.
+     * Logs a message with the specific Marker at the TRACE level.
      *
-     * @param message the message object to log.
+     * @param marker the marker data specific to this log statement.
+     * @param msg    the message string to be logged
      */
-    public void fatal(final String message) {
-        if (isEnabled(Level.FATAL, null, message)) {
-            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
+    public void trace(final Marker marker, final Message msg) {
+        if (isEnabled(Level.TRACE, marker, msg, null)) {
+            log(marker, FQCN, Level.TRACE, msg, null);
         }
     }
 
 
     /**
-     * Logs a message object with the {@link Level#FATAL FATAL} level.
+     * Logs a message with the specific Marker at the TRACE level.
      *
      * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @param msg    the message string to be logged
+     * @param t      A Throwable or null.
      */
-    public void fatal(final Marker marker, final String message) {
-        if (isEnabled(Level.FATAL, marker, message)) {
-            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
+    public void trace(final Marker marker, final Message msg, final Throwable t) {
+        if (isEnabled(Level.TRACE, marker, msg, t)) {
+            log(marker, FQCN, Level.TRACE, msg, t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#FATAL FATAL} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message object with the {@link Level#TRACE TRACE} level.
      *
+     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
      */
-    public void fatal(final String message, final Throwable t) {
-        if (isEnabled(Level.FATAL, null, message, t)) {
-            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
+    public void trace(final Marker marker, final Object message) {
+        if (isEnabled(Level.TRACE, marker, message, null)) {
+            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#FATAL FATAL} level including the
+     * Logs a message at the {@link Level#TRACE TRACE} level including the
      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * <p/>
+     * <p>
+     * See {@link #debug(String)} form for more detailed information.
+     * </p>
      *
      * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void fatal(final Marker marker, final String message, final Throwable t) {
-        if (isEnabled(Level.FATAL, marker, message, t)) {
-            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
+    public void trace(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.TRACE, marker, message, t)) {
+            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#FATAL FATAL} level.
+     * Logs a message object with the {@link Level#TRACE TRACE} level.
      *
+     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      */
-    public void fatal(final Object message) {
-        if (isEnabled(Level.FATAL, null, message, null)) {
-            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
+    public void trace(final Marker marker, final String message) {
+        if (isEnabled(Level.TRACE, marker, message)) {
+            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Logs a message object with the {@link Level#FATAL FATAL} level.
+     * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
      *
      * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void fatal(final Marker marker, final Object message) {
-        if (isEnabled(Level.FATAL, marker, message, null)) {
-            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), null);
+    public void trace(final Marker marker, final String message, final Object... params) {
+        if (isEnabled(Level.TRACE, marker, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(marker, FQCN, Level.TRACE, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message at the {@link Level#FATAL FATAL} level including the
+     * Logs a message at the {@link Level#TRACE TRACE} level including the
      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * <p/>
+     * <p>
+     * See {@link #debug(String)} form for more detailed information.
+     * </p>
      *
+     * @param marker the marker data specific to this log statement.
      * @param message the message object to log.
      * @param t       the exception to log, including its stack trace.
      */
-    public void fatal(final Object message, final Throwable t) {
-        if (isEnabled(Level.FATAL, null, message, t)) {
-            log(null, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
+    public void trace(final Marker marker, final String message, final Throwable t) {
+        if (isEnabled(Level.TRACE, marker, message, t)) {
+            log(marker, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message at the {@link Level#FATAL FATAL} level including the
-     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * Logs a message with the specific Marker at the TRACE level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message object to log.
-     * @param t       the exception to log, including its stack trace.
+     * @param msg the message string to be logged
      */
-    public void fatal(final Marker marker, final Object message, final Throwable t) {
-        if (isEnabled(Level.FATAL, marker, message, t)) {
-            log(marker, FQCN, Level.FATAL, messageFactory.newMessage(message), t);
+    public void trace(final Message msg) {
+        if (isEnabled(Level.TRACE, null, msg, null)) {
+            log(null, FQCN, Level.TRACE, msg, null);
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
+     * Logs a message with the specific Marker at the TRACE level.
      *
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param msg the message string to be logged
+     * @param t   A Throwable or null.
      */
-    public void fatal(final String message, final Object... params) {
-        if (isEnabled(Level.FATAL, null, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(null, FQCN, Level.FATAL, msg, msg.getThrowable());
+    public void trace(final Message msg, final Throwable t) {
+        if (isEnabled(Level.TRACE, null, msg, t)) {
+            log(null, FQCN, Level.TRACE, msg, t);
         }
     }
 
     /**
-     * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
+     * Logs a message object with the {@link Level#TRACE TRACE} level.
      *
-     * @param marker the marker data specific to this log statement.
-     * @param message the message to log.
-     * @param params  parameters to the message.
+     * @param message the message object to log.
      */
-    public void fatal(final Marker marker, final String message, final Object... params) {
-        if (isEnabled(Level.FATAL, marker, message, params)) {
-            final Message msg = messageFactory.newMessage(message, params);
-            log(marker, FQCN, Level.FATAL, msg, msg.getThrowable());
+    public void trace(final Object message) {
+        if (isEnabled(Level.TRACE, null, message, null)) {
+            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
         }
     }
 
     /**
-     * Checks whether this Logger is enabled for the FATAL Level.
+     * Logs a message at the {@link Level#TRACE TRACE} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * <p/>
+     * <p>
+     * See {@link #debug(String)} form for more detailed information.
+     * </p>
      *
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         FATAL, {@code false} otherwise.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public boolean isFatalEnabled() {
-        return isEnabled(Level.FATAL, null, (Object) null, null);
+    public void trace(final Object message, final Throwable t) {
+        if (isEnabled(Level.TRACE, null, message, t)) {
+            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
+        }
     }
 
     /**
-     * Checks whether this Logger is enabled for the FATAL Level.
+     * Logs a message object with the {@link Level#TRACE TRACE} level.
      *
-     * @param marker The marker data.
-     * @return boolean - {@code true} if this Logger is enabled for level
-     *         FATAL, {@code false} otherwise.
+     * @param message the message object to log.
      */
-    public boolean isFatalEnabled(final Marker marker) {
-        return isEnabled(Level.FATAL, marker, (Object) null, null);
+    public void trace(final String message) {
+        if (isEnabled(Level.TRACE, null, message)) {
+            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), null);
+        }
     }
 
     /**
-     * Logs a message with the specific Marker at the FATAL level.
+     * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
      *
-     * @param msg the message string to be logged
+     * @param message the message to log.
+     * @param params  parameters to the message.
      */
-    public void fatal(final Message msg) {
-        if (isEnabled(Level.FATAL, null, msg, null)) {
-            log(null, FQCN, Level.FATAL, msg, null);
+    public void trace(final String message, final Object... params) {
+        if (isEnabled(Level.TRACE, null, message, params)) {
+            final Message msg = messageFactory.newMessage(message, params);
+            log(null, FQCN, Level.TRACE, msg, msg.getThrowable());
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the FATAL level.
+     * Logs a message at the {@link Level#TRACE TRACE} level including the
+     * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
+     * <p/>
+     * <p>
+     * See {@link #debug(String)} form for more detailed information.
+     * </p>
      *
-     * @param msg the message string to be logged
-     * @param t   A Throwable or null.
+     * @param message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    public void fatal(final Message msg, final Throwable t) {
-        if (isEnabled(Level.FATAL, null, msg, t)) {
-            log(null, FQCN, Level.FATAL, msg, t);
+    public void trace(final String message, final Throwable t) {
+        if (isEnabled(Level.TRACE, null, message, t)) {
+            log(null, FQCN, Level.TRACE, messageFactory.newMessage(message), t);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the FATAL level.
+     * Logs a message with the specific Marker at the WARN level.
      *
      * @param marker the marker data specific to this log statement
      * @param msg    the message string to be logged
      */
-    public void fatal(final Marker marker, final Message msg) {
-        if (isEnabled(Level.FATAL, marker, msg, null)) {
-            log(marker, FQCN, Level.FATAL, msg, null);
+    public void warn(final Marker marker, final Message msg) {
+        if (isEnabled(Level.WARN, marker, msg, null)) {
+            log(marker, FQCN, Level.WARN, msg, null);
         }
     }
 
     /**
-     * Logs a message with the specific Marker at the FATAL level.
+     * Logs a message with the specific Marker at the WARN level.
      *
      * @param marker the marker data specific to this log statement
      * @param msg    the message string to be logged
      * @param t      A Throwable or null.
      */
-    public void fatal(final Marker marker, final Message msg, final Throwable t) {
-        if (isEnabled(Level.FATAL, marker, msg, t)) {
-            log(marker, FQCN, Level.FATAL, msg, t);
+    public void warn(final Marker marker, final Message msg, final Throwable t) {
+        if (isEnabled(Level.WARN, marker, msg, t)) {
+            log(marker, FQCN, Level.WARN, msg, t);
         }
     }
 
     /**
-     * Logs a message with location information.
+     * Logs a message object with the {@link Level#WARN WARN} level.
      *
-     * @param marker The Marker
-     * @param fqcn   The fully qualified class name of the <b>caller</b>
-     * @param level  The logging level
-     * @param data   The Message.
-     * @param t      A Throwable or null.
+     * @param marker the marker data specific to this log statement.
+     * @param message the message object to log.
      */
-    protected abstract void log(Marker marker, String fqcn, Level level, Message data, Throwable t);
+    public void warn(final Marker marker, final Object message) {
+        if (isEnabled(Level.WARN, marker, message, null)) {
+            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), null);
+        }
+    }
 
     /*
      * Instead of one single method with Object... declared the following methods explicitly specify
@@ -1452,116 +1427,141 @@ public abstract class AbstractLogger imp
      */
 
     /**
-     * Determine if logging is enabled.
-     * @param level The logging Level to check.
-     * @param marker A Marker or null.
-     * @param data The message.
-     * @return True if logging is enabled, false otherwise.
+     * Logs a message at the {@link Level#WARN WARN} level 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 message the message object to log.
+     * @param t       the exception to log, including its stack trace.
      */
-    protected abstract boolean isEnabled(Level level, Marker marker, String data);
+    public void warn(final Marker marker, final Object message, final Throwable t) {
+        if (isEnabled(Level.WARN, marker, message, t)) {
+            log(marker, FQCN, Level.WARN, messageFactory.newMessage(message), t);
+        }
+    }
 
     /**
-     * Determine if logging is enabled.
-     * @param level The logging Level to check.
-     * @param marker A Marker or null.
-     * @param data The message.
-     * @param t A Throwable.

[... 190 lines stripped ...]


Mime
View raw message