View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements. See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache license, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License. You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the license for the specific language governing permissions and
15   * limitations under the license.
16   */
17  package org.apache.logging.log4j;
18  
19  import org.apache.logging.log4j.message.Message;
20  import org.apache.logging.log4j.message.MessageFactory;
21  import org.apache.logging.log4j.util.MessageSupplier;
22  import org.apache.logging.log4j.util.Supplier;
23  
24  /**
25   * This is the central interface in the log4j package. Most logging operations, except configuration, are done through
26   * this interface.
27   *
28   * <p>
29   * The canonical way to obtain a Logger for a class is through {@link LogManager#getLogger()}. Typically, each class
30   * gets its own Logger named after its fully qualified class name (the default Logger name when obtained through the
31   * {@link LogManager#getLogger()} method). Thus, the simplest way to use this would be like so:
32   * </p>
33   * 
34   * <pre>
35   * public class MyClass {
36   *     private static final Logger LOGGER = LogManager.getLogger();
37   *     // ...
38   * }
39   * </pre>
40   * <p>
41   * For ease of filtering, searching, sorting, etc., it is generally a good idea to create Loggers for each class rather
42   * than sharing Loggers. Instead, {@link Marker Markers} should be used for shared, filterable identification.
43   * </p>
44   * <p>
45   * For service provider implementations, it is recommended to extend the
46   * {@link org.apache.logging.log4j.spi.AbstractLogger} class rather than implementing this interface directly.
47   * </p>
48   *
49   * Since 2.4, methods have been added to the {@code Logger} interface to support lambda expressions. The new methods
50   * allow client code to lazily log messages without explicitly checking if the requested log level is enabled. For
51   * example, previously one would write:
52   * 
53   * <pre>
54   * // pre-Java 8 style optimization: explicitly check the log level
55   * // to make sure the expensiveOperation() method is only called if necessary
56   * if (logger.isTraceEnabled()) {
57   *     logger.trace(&quot;Some long-running operation returned {}&quot;, expensiveOperation());
58   * }
59   * </pre>
60   * <p>
61   * With Java 8, the same effect can be achieved with a lambda expression:
62   * 
63   * <pre>
64   * // Java-8 style optimization: no need to explicitly check the log level:
65   * // the lambda expression is not evaluated if the TRACE level is not enabled
66   * logger.trace(&quot;Some long-running operation returned {}&quot;, () -&gt; expensiveOperation());
67   * </pre>
68   */
69  public interface Logger {
70  
71      /**
72       * Logs an exception or error that has been caught to a specific logging level.
73       *
74       * @param level The logging Level.
75       * @param t The Throwable.
76       */
77      void catching(Level level, Throwable t);
78  
79      /**
80       * Logs an exception or error that has been caught. Normally, one may wish to provide additional information with an
81       * exception while logging it; in these cases, one would not use this method. In other cases where simply logging
82       * the fact that an exception was swallowed somewhere (e.g., at the top of the stack trace in a {@code main()}
83       * method), this method is ideal for it.
84       *
85       * @param t The Throwable.
86       */
87      void catching(Throwable t);
88  
89      /**
90       * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
91       *
92       * @param marker the marker data specific to this log statement
93       * @param msg the message string to be logged
94       */
95      void debug(Marker marker, Message msg);
96  
97      /**
98       * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
99       *
100      * @param marker the marker data specific to this log statement
101      * @param msg the message string to be logged
102      * @param t A Throwable or null.
103      */
104     void debug(Marker marker, Message msg, Throwable t);
105 
106     /**
107      * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with
108      * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
109      * {@code Message}.
110      *
111      * @param marker the marker data specific to this log statement
112      * @param msgSupplier A function, which when called, produces the desired log message.
113      * @since 2.4
114      */
115     void debug(Marker marker, MessageSupplier msgSupplier);
116 
117     /**
118      * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the
119      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The
120      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
121      *
122      * @param marker the marker data specific to this log statement
123      * @param msgSupplier A function, which when called, produces the desired log message.
124      * @param t A Throwable or null.
125      * @since 2.4
126      */
127     void debug(Marker marker, MessageSupplier msgSupplier, Throwable t);
128 
129     /**
130      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
131      *
132      * @param marker the marker data specific to this log statement
133      * @param message the message object to log.
134      */
135     void debug(Marker marker, Object message);
136 
137     /**
138      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
139      * <code>t</code> passed as parameter.
140      *
141      * @param marker the marker data specific to this log statement
142      * @param message the message to log.
143      * @param t the exception to log, including its stack trace.
144      */
145     void debug(Marker marker, Object message, Throwable t);
146 
147     /**
148      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
149      *
150      * @param marker the marker data specific to this log statement
151      * @param message the message object to log.
152      */
153     void debug(Marker marker, String message);
154 
155     /**
156      * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
157      *
158      * @param marker the marker data specific to this log statement
159      * @param message the message to log; the format depends on the message factory.
160      * @param params parameters to the message.
161      * @see #getMessageFactory()
162      */
163     void debug(Marker marker, String message, Object... params);
164 
165     /**
166      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG
167      * DEBUG} level.
168      *
169      * @param marker the marker data specific to this log statement
170      * @param message the message to log; the format depends on the message factory.
171      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
172      * @since 2.4
173      */
174     void debug(Marker marker, String message, Supplier<?>... paramSuppliers);
175 
176     /**
177      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
178      * <code>t</code> passed as parameter.
179      *
180      * @param marker the marker data specific to this log statement
181      * @param message the message to log.
182      * @param t the exception to log, including its stack trace.
183      */
184     void debug(Marker marker, String message, Throwable t);
185 
186     /**
187      * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level with
188      * the specified Marker.
189      *
190      * @param marker the marker data specific to this log statement
191      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
192      *            message factory.
193      * @since 2.4
194      */
195     void debug(Marker marker, Supplier<?> msgSupplier);
196 
197     /**
198      * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) with the
199      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter.
200      *
201      * @param marker the marker data specific to this log statement
202      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
203      *            message factory.
204      * @param t A Throwable or null.
205      * @since 2.4
206      */
207     void debug(Marker marker, Supplier<?> msgSupplier, Throwable t);
208 
209     /**
210      * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
211      *
212      * @param msg the message string to be logged
213      */
214     void debug(Message msg);
215 
216     /**
217      * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
218      *
219      * @param msg the message string to be logged
220      * @param t A Throwable or null.
221      */
222     void debug(Message msg, Throwable t);
223 
224     /**
225      * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level. The
226      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
227      *
228      * @param msgSupplier A function, which when called, produces the desired log message.
229      * @since 2.4
230      */
231     void debug(MessageSupplier msgSupplier);
232 
233     /**
234      * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the
235      * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
236      * not use the {@link MessageFactory} to construct the {@code Message}.
237      *
238      * @param msgSupplier A function, which when called, produces the desired log message.
239      * @param t the exception to log, including its stack trace.
240      * @since 2.4
241      */
242     void debug(MessageSupplier msgSupplier, Throwable t);
243 
244     /**
245      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
246      *
247      * @param message the message object to log.
248      */
249     void debug(Object message);
250 
251     /**
252      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
253      * <code>t</code> passed as parameter.
254      *
255      * @param message the message to log.
256      * @param t the exception to log, including its stack trace.
257      */
258     void debug(Object message, Throwable t);
259 
260     /**
261      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
262      *
263      * @param message the message string to log.
264      */
265     void debug(String message);
266 
267     /**
268      * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
269      *
270      * @param message the message to log; the format depends on the message factory.
271      * @param params parameters to the message.
272      * @see #getMessageFactory()
273      */
274     void debug(String message, Object... params);
275 
276     /**
277      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#DEBUG
278      * DEBUG} level.
279      *
280      * @param message the message to log; the format depends on the message factory.
281      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
282      * @since 2.4
283      */
284     void debug(String message, Supplier<?>... paramSuppliers);
285 
286     /**
287      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
288      * <code>t</code> passed as parameter.
289      *
290      * @param message the message to log.
291      * @param t the exception to log, including its stack trace.
292      */
293     void debug(String message, Throwable t);
294 
295     /**
296      * Logs a message which is only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level.
297      *
298      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
299      *            message factory.
300      * @since 2.4
301      */
302     void debug(Supplier<?> msgSupplier);
303 
304     /**
305      * Logs a message (only to be constructed if the logging level is the {@link Level#DEBUG DEBUG} level) including the
306      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
307      *
308      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
309      *            message factory.
310      * @param t the exception to log, including its stack trace.
311      * @since 2.4
312      */
313     void debug(Supplier<?> msgSupplier, Throwable t);
314 
315     /**
316      * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be
317      * logged.
318      */
319     void entry();
320 
321     /**
322      * Logs entry to a method along with its parameters. For example,
323      * 
324      * <pre>
325      * public void doSomething(String foo, int bar) {
326      *     LOGGER.entry(foo, bar);
327      *     // do something
328      * }
329      * </pre>
330      * <p>
331      * The use of methods such as this are more effective when combined with aspect-oriented programming or other
332      * bytecode manipulation tools. It can be rather tedious (and messy) to use this type of method manually.
333      * </p>
334      *
335      * @param params The parameters to the method. TODO Use of varargs results in array creation which can be a
336      *            substantial portion of no-op case. LogMF/LogSF provides several overrides to avoid vararg except in
337      *            edge cases. (RG) LogMF and LogSF implement these in LogXF which calls logger.callAppenders.
338      *            callAppenders is part of the implementation and cannot be used by the API. Adding more methods here
339      *            and in AbstractLogger is sufficient.
340      */
341     void entry(Object... params);
342 
343     /**
344      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
345      *
346      * @param marker the marker data specific to this log statement
347      * @param msg the message string to be logged
348      */
349     void error(Marker marker, Message msg);
350 
351     /**
352      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
353      *
354      * @param marker the marker data specific to this log statement
355      * @param msg the message string to be logged
356      * @param t A Throwable or null.
357      */
358     void error(Marker marker, Message msg, Throwable t);
359 
360     /**
361      * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with
362      * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
363      * {@code Message}.
364      *
365      * @param marker the marker data specific to this log statement
366      * @param msgSupplier A function, which when called, produces the desired log message.
367      * @since 2.4
368      */
369     void error(Marker marker, MessageSupplier msgSupplier);
370 
371     /**
372      * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the
373      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The
374      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
375      *
376      * @param marker the marker data specific to this log statement
377      * @param msgSupplier A function, which when called, produces the desired log message.
378      * @param t A Throwable or null.
379      * @since 2.4
380      */
381     void error(Marker marker, MessageSupplier msgSupplier, Throwable t);
382 
383     /**
384      * Logs a message object with the {@link Level#ERROR ERROR} level.
385      *
386      * @param marker the marker data specific to this log statement.
387      * @param message the message object to log.
388      */
389     void error(Marker marker, Object message);
390 
391     /**
392      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
393      * <code>t</code> passed as parameter.
394      *
395      * @param marker the marker data specific to this log statement.
396      * @param message the message object to log.
397      * @param t the exception to log, including its stack trace.
398      */
399     void error(Marker marker, Object message, Throwable t);
400 
401     /**
402      * Logs a message object with the {@link Level#ERROR ERROR} level.
403      *
404      * @param marker the marker data specific to this log statement.
405      * @param message the message object to log.
406      */
407     void error(Marker marker, String message);
408 
409     /**
410      * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
411      *
412      * @param marker the marker data specific to this log statement.
413      * @param message the message to log; the format depends on the message factory.
414      * @param params parameters to the message.
415      * @see #getMessageFactory()
416      *
417      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
418      *      array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be
419      *      misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 1,
420      *      2 or 3 parameters.
421      */
422     void error(Marker marker, String message, Object... params);
423 
424     /**
425      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR
426      * ERROR} level.
427      *
428      * @param marker the marker data specific to this log statement
429      * @param message the message to log; the format depends on the message factory.
430      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
431      * @since 2.4
432      */
433     void error(Marker marker, String message, Supplier<?>... paramSuppliers);
434 
435     /**
436      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
437      * <code>t</code> passed as parameter.
438      *
439      * @param marker the marker data specific to this log statement.
440      * @param message the message object to log.
441      * @param t the exception to log, including its stack trace.
442      */
443     void error(Marker marker, String message, Throwable t);
444 
445     /**
446      * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level with
447      * the specified Marker.
448      *
449      * @param marker the marker data specific to this log statement
450      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
451      *            message factory.
452      * @since 2.4
453      */
454     void error(Marker marker, Supplier<?> msgSupplier);
455 
456     /**
457      * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) with the
458      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter.
459      *
460      * @param marker the marker data specific to this log statement
461      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
462      *            message factory.
463      * @param t A Throwable or null.
464      * @since 2.4
465      */
466     void error(Marker marker, Supplier<?> msgSupplier, Throwable t);
467 
468     /**
469      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
470      *
471      * @param msg the message string to be logged
472      */
473     void error(Message msg);
474 
475     /**
476      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
477      *
478      * @param msg the message string to be logged
479      * @param t A Throwable or null.
480      */
481     void error(Message msg, Throwable t);
482 
483     /**
484      * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level. The
485      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
486      *
487      * @param msgSupplier A function, which when called, produces the desired log message.
488      * @since 2.4
489      */
490     void error(MessageSupplier msgSupplier);
491 
492     /**
493      * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the
494      * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
495      * not use the {@link MessageFactory} to construct the {@code Message}.
496      *
497      * @param msgSupplier A function, which when called, produces the desired log message.
498      * @param t the exception to log, including its stack trace.
499      * @since 2.4
500      */
501     void error(MessageSupplier msgSupplier, Throwable t);
502 
503     /**
504      * Logs a message object with the {@link Level#ERROR ERROR} level.
505      *
506      * @param message the message object to log.
507      */
508     void error(Object message);
509 
510     /**
511      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
512      * <code>t</code> passed as parameter.
513      *
514      * @param message the message object to log.
515      * @param t the exception to log, including its stack trace.
516      */
517     void error(Object message, Throwable t);
518 
519     /**
520      * Logs a message object with the {@link Level#ERROR ERROR} level.
521      *
522      * @param message the message string to log.
523      */
524     void error(String message);
525 
526     /**
527      * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
528      *
529      * @param message the message to log; the format depends on the message factory.
530      * @param params parameters to the message.
531      * @see #getMessageFactory()
532      *
533      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
534      *      array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be
535      *      misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 1,
536      *      2 or 3 parameters.
537      */
538     void error(String message, Object... params);
539 
540     /**
541      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#ERROR
542      * ERROR} level.
543      *
544      * @param message the message to log; the format depends on the message factory.
545      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
546      * @since 2.4
547      */
548     void error(String message, Supplier<?>... paramSuppliers);
549 
550     /**
551      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
552      * <code>t</code> passed as parameter.
553      *
554      * @param message the message object to log.
555      * @param t the exception to log, including its stack trace.
556      */
557     void error(String message, Throwable t);
558 
559     /**
560      * Logs a message which is only to be constructed if the logging level is the {@link Level#ERROR ERROR} level.
561      *
562      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
563      *            message factory.
564      * @since 2.4
565      */
566     void error(Supplier<?> msgSupplier);
567 
568     /**
569      * Logs a message (only to be constructed if the logging level is the {@link Level#ERROR ERROR} level) including the
570      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
571      *
572      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
573      *            message factory.
574      * @param t the exception to log, including its stack trace.
575      * @since 2.4
576      */
577     void error(Supplier<?> msgSupplier, Throwable t);
578 
579     /**
580      * Logs exit from a method. Used for methods that do not return anything.
581      */
582     void exit();
583 
584     /**
585      * Logs exiting from a method with the result. This may be coded as:
586      * 
587      * <pre>
588      * return LOGGER.exit(myResult);
589      * </pre>
590      *
591      * @param <R> The type of the parameter and object being returned.
592      * @param result The result being returned from the method call.
593      * @return the result.
594      */
595     <R> R exit(R result);
596 
597     /**
598      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
599      *
600      * @param marker the marker data specific to this log statement
601      * @param msg the message string to be logged
602      */
603     void fatal(Marker marker, Message msg);
604 
605     /**
606      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
607      *
608      * @param marker the marker data specific to this log statement
609      * @param msg the message string to be logged
610      * @param t A Throwable or null.
611      */
612     void fatal(Marker marker, Message msg, Throwable t);
613 
614     /**
615      * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with
616      * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
617      * {@code Message}.
618      *
619      * @param marker the marker data specific to this log statement
620      * @param msgSupplier A function, which when called, produces the desired log message.
621      * @since 2.4
622      */
623     void fatal(Marker marker, MessageSupplier msgSupplier);
624 
625     /**
626      * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the
627      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The
628      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
629      *
630      * @param marker the marker data specific to this log statement
631      * @param msgSupplier A function, which when called, produces the desired log message.
632      * @param t A Throwable or null.
633      * @since 2.4
634      */
635     void fatal(Marker marker, MessageSupplier msgSupplier, Throwable t);
636 
637     /**
638      * Logs a message object with the {@link Level#FATAL FATAL} level.
639      *
640      * @param marker The marker data specific to this log statement.
641      * @param message the message object to log.
642      */
643     void fatal(Marker marker, Object message);
644 
645     /**
646      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
647      * <code>t</code> passed as parameter.
648      *
649      * @param marker The marker data specific to this log statement.
650      * @param message the message object to log.
651      * @param t the exception to log, including its stack trace.
652      */
653     void fatal(Marker marker, Object message, Throwable t);
654 
655     /**
656      * Logs a message object with the {@link Level#FATAL FATAL} level.
657      *
658      * @param marker The marker data specific to this log statement.
659      * @param message the message object to log.
660      */
661     void fatal(Marker marker, String message);
662 
663     /**
664      * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
665      *
666      * @param marker The marker data specific to this log statement.
667      * @param message the message to log; the format depends on the message factory.
668      * @param params parameters to the message.
669      * @see #getMessageFactory()
670      *
671      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
672      *      array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be
673      *      misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 1,
674      *      2 or 3 parameters.
675      */
676     void fatal(Marker marker, String message, Object... params);
677 
678     /**
679      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL
680      * FATAL} level.
681      *
682      * @param marker the marker data specific to this log statement
683      * @param message the message to log; the format depends on the message factory.
684      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
685      * @since 2.4
686      */
687     void fatal(Marker marker, String message, Supplier<?>... paramSuppliers);
688 
689     /**
690      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
691      * <code>t</code> passed as parameter.
692      *
693      * @param marker The marker data specific to this log statement.
694      * @param message the message object to log.
695      * @param t the exception to log, including its stack trace.
696      */
697     void fatal(Marker marker, String message, Throwable t);
698 
699     /**
700      * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level with
701      * the specified Marker.
702      *
703      * @param marker the marker data specific to this log statement
704      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
705      *            message factory.
706      * @since 2.4
707      */
708     void fatal(Marker marker, Supplier<?> msgSupplier);
709 
710     /**
711      * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) with the
712      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter.
713      *
714      * @param marker the marker data specific to this log statement
715      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
716      *            message factory.
717      * @param t A Throwable or null.
718      * @since 2.4
719      */
720     void fatal(Marker marker, Supplier<?> msgSupplier, Throwable t);
721 
722     /**
723      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
724      *
725      * @param msg the message string to be logged
726      */
727     void fatal(Message msg);
728 
729     /**
730      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
731      *
732      * @param msg the message string to be logged
733      * @param t A Throwable or null.
734      */
735     void fatal(Message msg, Throwable t);
736 
737     /**
738      * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level. The
739      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
740      *
741      * @param msgSupplier A function, which when called, produces the desired log message.
742      * @since 2.4
743      */
744     void fatal(MessageSupplier msgSupplier);
745 
746     /**
747      * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the
748      * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
749      * not use the {@link MessageFactory} to construct the {@code Message}.
750      *
751      * @param msgSupplier A function, which when called, produces the desired log message.
752      * @param t the exception to log, including its stack trace.
753      * @since 2.4
754      */
755     void fatal(MessageSupplier msgSupplier, Throwable t);
756 
757     /**
758      * Logs a message object with the {@link Level#FATAL FATAL} level.
759      *
760      * @param message the message object to log.
761      */
762     void fatal(Object message);
763 
764     /**
765      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
766      * <code>t</code> passed as parameter.
767      *
768      * @param message the message object to log.
769      * @param t the exception to log, including its stack trace.
770      */
771     void fatal(Object message, Throwable t);
772 
773     /**
774      * Logs a message object with the {@link Level#FATAL FATAL} level.
775      *
776      * @param message the message string to log.
777      */
778     void fatal(String message);
779 
780     /**
781      * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
782      *
783      * @param message the message to log; the format depends on the message factory.
784      * @param params parameters to the message.
785      * @see #getMessageFactory()
786      *
787      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
788      *      array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be
789      *      misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 1,
790      *      2 or 3 parameters.
791      */
792     void fatal(String message, Object... params);
793 
794     /**
795      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#FATAL
796      * FATAL} level.
797      *
798      * @param message the message to log; the format depends on the message factory.
799      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
800      * @since 2.4
801      */
802     void fatal(String message, Supplier<?>... paramSuppliers);
803 
804     /**
805      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
806      * <code>t</code> passed as parameter.
807      *
808      * @param message the message object to log.
809      * @param t the exception to log, including its stack trace.
810      */
811     void fatal(String message, Throwable t);
812 
813     /**
814      * Logs a message which is only to be constructed if the logging level is the {@link Level#FATAL FATAL} level.
815      *
816      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
817      *            message factory.
818      * @since 2.4
819      */
820     void fatal(Supplier<?> msgSupplier);
821 
822     /**
823      * Logs a message (only to be constructed if the logging level is the {@link Level#FATAL FATAL} level) including the
824      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
825      *
826      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
827      *            message factory.
828      * @param t the exception to log, including its stack trace.
829      * @since 2.4
830      */
831     void fatal(Supplier<?> msgSupplier, Throwable t);
832 
833     /**
834      * Gets the Level associated with the Logger.
835      *
836      * @return the Level associate with the Logger.
837      */
838     Level getLevel();
839 
840     /**
841      * Gets the message factory used to convert message Objects and Strings into actual log Messages.
842      *
843      * @return the message factory.
844      */
845     MessageFactory getMessageFactory();
846 
847     /**
848      * Gets the logger name.
849      *
850      * @return the logger name.
851      */
852     String getName();
853 
854     /**
855      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
856      *
857      * @param marker the marker data specific to this log statement
858      * @param msg the message string to be logged
859      */
860     void info(Marker marker, Message msg);
861 
862     /**
863      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
864      *
865      * @param marker the marker data specific to this log statement
866      * @param msg the message string to be logged
867      * @param t A Throwable or null.
868      */
869     void info(Marker marker, Message msg, Throwable t);
870 
871     /**
872      * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with the
873      * specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
874      * {@code Message}.
875      *
876      * @param marker the marker data specific to this log statement
877      * @param msgSupplier A function, which when called, produces the desired log message.
878      * @since 2.4
879      */
880     void info(Marker marker, MessageSupplier msgSupplier);
881 
882     /**
883      * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the
884      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The
885      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
886      *
887      * @param marker the marker data specific to this log statement
888      * @param msgSupplier A function, which when called, produces the desired log message.
889      * @param t A Throwable or null.
890      * @since 2.4
891      */
892     void info(Marker marker, MessageSupplier msgSupplier, Throwable t);
893 
894     /**
895      * Logs a message object with the {@link Level#INFO INFO} level.
896      *
897      * @param marker the marker data specific to this log statement
898      * @param message the message object to log.
899      */
900     void info(Marker marker, Object message);
901 
902     /**
903      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
904      * <code>t</code> passed as parameter.
905      *
906      * @param marker the marker data specific to this log statement
907      * @param message the message object to log.
908      * @param t the exception to log, including its stack trace.
909      */
910     void info(Marker marker, Object message, Throwable t);
911 
912     /**
913      * Logs a message object with the {@link Level#INFO INFO} level.
914      *
915      * @param marker the marker data specific to this log statement
916      * @param message the message object to log.
917      */
918     void info(Marker marker, String message);
919 
920     /**
921      * Logs a message with parameters at the {@link Level#INFO INFO} level.
922      *
923      * @param marker the marker data specific to this log statement
924      * @param message the message to log; the format depends on the message factory.
925      * @param params parameters to the message.
926      * @see #getMessageFactory()
927      *
928      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
929      *      array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method is
930      *      for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters.
931      */
932     void info(Marker marker, String message, Object... params);
933 
934     /**
935      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO
936      * INFO} level.
937      *
938      * @param marker the marker data specific to this log statement
939      * @param message the message to log; the format depends on the message factory.
940      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
941      * @since 2.4
942      */
943     void info(Marker marker, String message, Supplier<?>... paramSuppliers);
944 
945     /**
946      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
947      * <code>t</code> passed as parameter.
948      *
949      * @param marker the marker data specific to this log statement
950      * @param message the message object to log.
951      * @param t the exception to log, including its stack trace.
952      */
953     void info(Marker marker, String message, Throwable t);
954 
955     /**
956      * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level with the
957      * specified Marker.
958      *
959      * @param marker the marker data specific to this log statement
960      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
961      *            message factory.
962      * @since 2.4
963      */
964     void info(Marker marker, Supplier<?> msgSupplier);
965 
966     /**
967      * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) with the
968      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter.
969      *
970      * @param marker the marker data specific to this log statement
971      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
972      *            message factory.
973      * @param t A Throwable or null.
974      * @since 2.4
975      */
976     void info(Marker marker, Supplier<?> msgSupplier, Throwable t);
977 
978     /**
979      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
980      *
981      * @param msg the message string to be logged
982      */
983     void info(Message msg);
984 
985     /**
986      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
987      *
988      * @param msg the message string to be logged
989      * @param t A Throwable or null.
990      */
991     void info(Message msg, Throwable t);
992 
993     /**
994      * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level. The
995      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
996      *
997      * @param msgSupplier A function, which when called, produces the desired log message.
998      * @since 2.4
999      */
1000     void info(MessageSupplier msgSupplier);
1001 
1002     /**
1003      * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the
1004      * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
1005      * not use the {@link MessageFactory} to construct the {@code Message}.
1006      *
1007      * @param msgSupplier A function, which when called, produces the desired log message.
1008      * @param t the exception to log, including its stack trace.
1009      * @since 2.4
1010      */
1011     void info(MessageSupplier msgSupplier, Throwable t);
1012 
1013     /**
1014      * Logs a message object with the {@link Level#INFO INFO} level.
1015      *
1016      * @param message the message object to log.
1017      */
1018     void info(Object message);
1019 
1020     /**
1021      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
1022      * <code>t</code> passed as parameter.
1023      *
1024      * @param message the message object to log.
1025      * @param t the exception to log, including its stack trace.
1026      */
1027     void info(Object message, Throwable t);
1028 
1029     /**
1030      * Logs a message object with the {@link Level#INFO INFO} level.
1031      *
1032      * @param message the message string to log.
1033      */
1034     void info(String message);
1035 
1036     /**
1037      * Logs a message with parameters at the {@link Level#INFO INFO} level.
1038      *
1039      * @param message the message to log; the format depends on the message factory.
1040      * @param params parameters to the message.
1041      * @see #getMessageFactory()
1042      *
1043      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
1044      *      array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method is
1045      *      for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters.
1046      */
1047     void info(String message, Object... params);
1048 
1049     /**
1050      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#INFO
1051      * INFO} level.
1052      *
1053      * @param message the message to log; the format depends on the message factory.
1054      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1055      * @since 2.4
1056      */
1057     void info(String message, Supplier<?>... paramSuppliers);
1058 
1059     /**
1060      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
1061      * <code>t</code> passed as parameter.
1062      *
1063      * @param message the message object to log.
1064      * @param t the exception to log, including its stack trace.
1065      */
1066     void info(String message, Throwable t);
1067 
1068     /**
1069      * Logs a message which is only to be constructed if the logging level is the {@link Level#INFO INFO} level.
1070      *
1071      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1072      *            message factory.
1073      * @since 2.4
1074      */
1075     void info(Supplier<?> msgSupplier);
1076 
1077     /**
1078      * Logs a message (only to be constructed if the logging level is the {@link Level#INFO INFO} level) including the
1079      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
1080      *
1081      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1082      *            message factory.
1083      * @param t the exception to log, including its stack trace.
1084      * @since 2.4
1085      */
1086     void info(Supplier<?> msgSupplier, Throwable t);
1087 
1088     /**
1089      * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
1090      *
1091      * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise.
1092      */
1093     boolean isDebugEnabled();
1094 
1095     /**
1096      * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
1097      *
1098      * @param marker The marker data specific to this log statement.
1099      * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise.
1100      */
1101     boolean isDebugEnabled(Marker marker);
1102 
1103     /**
1104      * Checks whether this Logger is enabled for the the given Level.
1105      * <p>
1106      * Note that passing in {@link Level#OFF OFF} always returns {@code true}.
1107      * </p>
1108      *
1109      * @param level the level to check
1110      * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise.
1111      */
1112     boolean isEnabled(Level level);
1113 
1114     /**
1115      * Checks whether this logger is enabled at the specified level and an optional Marker.
1116      *
1117      * @param level The Level to check.
1118      * @param marker The marker data specific to this log statement.
1119      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
1120      *         otherwise.
1121      */
1122     boolean isEnabled(Level level, Marker marker);
1123 
1124     /**
1125      * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
1126      *
1127      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false}
1128      *         otherwise.
1129      */
1130     boolean isErrorEnabled();
1131 
1132     /**
1133      * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
1134      *
1135      * @param marker The marker data specific to this log statement.
1136      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false}
1137      *         otherwise.
1138      */
1139     boolean isErrorEnabled(Marker marker);
1140 
1141     /**
1142      * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
1143      *
1144      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false}
1145      *         otherwise.
1146      */
1147     boolean isFatalEnabled();
1148 
1149     /**
1150      * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
1151      *
1152      * @param marker The marker data specific to this log statement.
1153      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false}
1154      *         otherwise.
1155      */
1156     boolean isFatalEnabled(Marker marker);
1157 
1158     /**
1159      * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
1160      *
1161      * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise.
1162      */
1163     boolean isInfoEnabled();
1164 
1165     /**
1166      * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
1167      *
1168      * @param marker The marker data specific to this log statement.
1169      * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise.
1170      */
1171     boolean isInfoEnabled(Marker marker);
1172 
1173     /**
1174      * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
1175      *
1176      * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise.
1177      */
1178     boolean isTraceEnabled();
1179 
1180     /**
1181      * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
1182      *
1183      * @param marker The marker data specific to this log statement.
1184      * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise.
1185      */
1186     boolean isTraceEnabled(Marker marker);
1187 
1188     /**
1189      * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
1190      *
1191      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
1192      *         otherwise.
1193      */
1194     boolean isWarnEnabled();
1195 
1196     /**
1197      * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
1198      *
1199      * @param marker The marker data specific to this log statement.
1200      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
1201      *         otherwise.
1202      */
1203     boolean isWarnEnabled(Marker marker);
1204 
1205     /**
1206      * Logs a message with the specific Marker at the given level.
1207      *
1208      * @param level the logging level
1209      * @param marker the marker data specific to this log statement
1210      * @param msg the message string to be logged
1211      */
1212     void log(Level level, Marker marker, Message msg);
1213 
1214     /**
1215      * Logs a message with the specific Marker at the given level.
1216      *
1217      * @param level the logging level
1218      * @param marker the marker data specific to this log statement
1219      * @param msg the message string to be logged
1220      * @param t A Throwable or null.
1221      */
1222     void log(Level level, Marker marker, Message msg, Throwable t);
1223 
1224     /**
1225      * Logs a message which is only to be constructed if the logging level is the specified level with the specified
1226      * Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
1227      * {@code Message}.
1228      *
1229      * @param level the logging level
1230      * @param marker the marker data specific to this log statement
1231      * @param msgSupplier A function, which when called, produces the desired log message.
1232      * @since 2.4
1233      */
1234     void log(Level level, Marker marker, MessageSupplier msgSupplier);
1235 
1236     /**
1237      * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker and
1238      * including the stack log of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier}
1239      * may or may not use the {@link MessageFactory} to construct the {@code Message}.
1240      *
1241      * @param level the logging level
1242      * @param marker the marker data specific to this log statement
1243      * @param msgSupplier A function, which when called, produces the desired log message.
1244      * @param t A Throwable or null.
1245      * @since 2.4
1246      */
1247     void log(Level level, Marker marker, MessageSupplier msgSupplier, Throwable t);
1248 
1249     /**
1250      * Logs a message object with the given level.
1251      *
1252      * @param level the logging level
1253      * @param marker the marker data specific to this log statement
1254      * @param message the message object to log.
1255      */
1256     void log(Level level, Marker marker, Object message);
1257 
1258     /**
1259      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
1260      * parameter.
1261      *
1262      * @param level the logging level
1263      * @param marker the marker data specific to this log statement
1264      * @param message the message to log.
1265      * @param t the exception to log, including its stack trace.
1266      */
1267     void log(Level level, Marker marker, Object message, Throwable t);
1268 
1269     /**
1270      * Logs a message object with the given level.
1271      *
1272      * @param level the logging level
1273      * @param marker the marker data specific to this log statement
1274      * @param message the message object to log.
1275      */
1276     void log(Level level, Marker marker, String message);
1277 
1278     /**
1279      * Logs a message with parameters at the given level.
1280      *
1281      * @param level the logging level
1282      * @param marker the marker data specific to this log statement
1283      * @param message the message to log; the format depends on the message factory.
1284      * @param params parameters to the message.
1285      * @see #getMessageFactory()
1286      */
1287     void log(Level level, Marker marker, String message, Object... params);
1288 
1289     /**
1290      * Logs a message with parameters which are only to be constructed if the logging level is the specified level.
1291      *
1292      * @param level the logging level
1293      * @param marker the marker data specific to this log statement
1294      * @param message the message to log; the format depends on the message factory.
1295      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1296      * @since 2.4
1297      */
1298     void log(Level level, Marker marker, String message, Supplier<?>... paramSuppliers);
1299 
1300     /**
1301      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
1302      * parameter.
1303      *
1304      * @param level the logging level
1305      * @param marker the marker data specific to this log statement
1306      * @param message the message to log.
1307      * @param t the exception to log, including its stack trace.
1308      */
1309     void log(Level level, Marker marker, String message, Throwable t);
1310 
1311     /**
1312      * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker.
1313      *
1314      * @param level the logging level
1315      * @param marker the marker data specific to this log statement
1316      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1317      *            message factory.
1318      * @since 2.4
1319      */
1320     void log(Level level, Marker marker, Supplier<?> msgSupplier);
1321 
1322     /**
1323      * Logs a message (only to be constructed if the logging level is the specified level) with the specified Marker and
1324      * including the stack log of the {@link Throwable} <code>t</code> passed as parameter.
1325      *
1326      * @param level the logging level
1327      * @param marker the marker data specific to this log statement
1328      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1329      *            message factory.
1330      * @param t A Throwable or null.
1331      * @since 2.4
1332      */
1333     void log(Level level, Marker marker, Supplier<?> msgSupplier, Throwable t);
1334 
1335     /**
1336      * Logs a message with the specific Marker at the given level.
1337      *
1338      * @param level the logging level
1339      * @param msg the message string to be logged
1340      */
1341     void log(Level level, Message msg);
1342 
1343     /**
1344      * Logs a message with the specific Marker at the given level.
1345      *
1346      * @param level the logging level
1347      * @param msg the message string to be logged
1348      * @param t A Throwable or null.
1349      */
1350     void log(Level level, Message msg, Throwable t);
1351 
1352     /**
1353      * Logs a message which is only to be constructed if the logging level is the specified level. The
1354      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
1355      *
1356      * @param level the logging level
1357      * @param msgSupplier A function, which when called, produces the desired log message.
1358      * @since 2.4
1359      */
1360     void log(Level level, MessageSupplier msgSupplier);
1361 
1362     /**
1363      * Logs a message (only to be constructed if the logging level is the specified level) including the stack log of
1364      * the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may not use the
1365      * {@link MessageFactory} to construct the {@code Message}.
1366      *
1367      * @param level the logging level
1368      * @param msgSupplier A function, which when called, produces the desired log message.
1369      * @param t the exception to log, including its stack log.
1370      * @since 2.4
1371      */
1372     void log(Level level, MessageSupplier msgSupplier, Throwable t);
1373 
1374     /**
1375      * Logs a message object with the given level.
1376      *
1377      * @param level the logging level
1378      * @param message the message object to log.
1379      */
1380     void log(Level level, Object message);
1381 
1382     /**
1383      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
1384      * parameter.
1385      *
1386      * @param level the logging level
1387      * @param message the message to log.
1388      * @param t the exception to log, including its stack trace.
1389      */
1390     void log(Level level, Object message, Throwable t);
1391 
1392     /**
1393      * Logs a message object with the given level.
1394      *
1395      * @param level the logging level
1396      * @param message the message string to log.
1397      */
1398     void log(Level level, String message);
1399 
1400     /**
1401      * Logs a message with parameters at the given level.
1402      *
1403      * @param level the logging level
1404      * @param message the message to log; the format depends on the message factory.
1405      * @param params parameters to the message.
1406      * @see #getMessageFactory()
1407      */
1408     void log(Level level, String message, Object... params);
1409 
1410     /**
1411      * Logs a message with parameters which are only to be constructed if the logging level is the specified level.
1412      *
1413      * @param level the logging level
1414      * @param message the message to log; the format depends on the message factory.
1415      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1416      * @since 2.4
1417      */
1418     void log(Level level, String message, Supplier<?>... paramSuppliers);
1419 
1420     /**
1421      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
1422      * parameter.
1423      *
1424      * @param level the logging level
1425      * @param message the message to log.
1426      * @param t the exception to log, including its stack trace.
1427      */
1428     void log(Level level, String message, Throwable t);
1429 
1430     /**
1431      * Logs a message which is only to be constructed if the logging level is the specified level.
1432      *
1433      * @param level the logging level
1434      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1435      *            message factory.
1436      * @since 2.4
1437      */
1438     void log(Level level, Supplier<?> msgSupplier);
1439 
1440     /**
1441      * Logs a message (only to be constructed if the logging level is the specified level) including the stack log of
1442      * the {@link Throwable} <code>t</code> passed as parameter.
1443      *
1444      * @param level the logging level
1445      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1446      *            message factory.
1447      * @param t the exception to log, including its stack log.
1448      * @since 2.4
1449      */
1450     void log(Level level, Supplier<?> msgSupplier, Throwable t);
1451 
1452     /**
1453      * Logs a formatted message using the specified format string and arguments.
1454      *
1455      * @param level The logging Level.
1456      * @param marker the marker data specific to this log statement.
1457      * @param format The format String.
1458      * @param params Arguments specified by the format.
1459      */
1460     void printf(Level level, Marker marker, String format, Object... params);
1461 
1462     /**
1463      * Logs a formatted message using the specified format string and arguments.
1464      *
1465      * @param level The logging Level.
1466      * @param format The format String.
1467      * @param params Arguments specified by the format.
1468      */
1469     void printf(Level level, String format, Object... params);
1470 
1471     /**
1472      * Logs an exception or error to be thrown. This may be coded as:
1473      * 
1474      * <pre>
1475      * throw logger.throwing(Level.DEBUG, myException);
1476      * </pre>
1477      *
1478      * @param <T> the Throwable type.
1479      * @param level The logging Level.
1480      * @param t The Throwable.
1481      * @return the Throwable.
1482      */
1483     <T extends Throwable> T throwing(Level level, T t);
1484 
1485     /**
1486      * Logs an exception or error to be thrown. This may be coded as:
1487      * 
1488      * <pre>
1489      * throw logger.throwing(myException);
1490      * </pre>
1491      *
1492      * @param <T> the Throwable type.
1493      * @param t The Throwable.
1494      * @return the Throwable.
1495      */
1496     <T extends Throwable> T throwing(T t);
1497 
1498     /**
1499      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
1500      *
1501      * @param marker the marker data specific to this log statement
1502      * @param msg the message string to be logged
1503      */
1504     void trace(Marker marker, Message msg);
1505 
1506     /**
1507      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
1508      *
1509      * @param marker the marker data specific to this log statement
1510      * @param msg the message string to be logged
1511      * @param t A Throwable or null.
1512      */
1513     void trace(Marker marker, Message msg, Throwable t);
1514 
1515     /**
1516      * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with
1517      * the specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
1518      * {@code Message}.
1519      *
1520      * @param marker the marker data specific to this log statement
1521      * @param msgSupplier A function, which when called, produces the desired log message.
1522      * @since 2.4
1523      */
1524     void trace(Marker marker, MessageSupplier msgSupplier);
1525 
1526     /**
1527      * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the
1528      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter. The
1529      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
1530      *
1531      * @param marker the marker data specific to this log statement
1532      * @param msgSupplier A function, which when called, produces the desired log message.
1533      * @param t A Throwable or null.
1534      * @since 2.4
1535      */
1536     void trace(Marker marker, MessageSupplier msgSupplier, Throwable t);
1537 
1538     /**
1539      * Logs a message object with the {@link Level#TRACE TRACE} level.
1540      *
1541      * @param marker the marker data specific to this log statement
1542      * @param message the message object to log.
1543      */
1544     void trace(Marker marker, Object message);
1545 
1546     /**
1547      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1548      * <code>t</code> passed as parameter.
1549      *
1550      * @param marker the marker data specific to this log statement
1551      * @param message the message object to log.
1552      * @param t the exception to log, including its stack trace.
1553      * @see #debug(String)
1554      */
1555     void trace(Marker marker, Object message, Throwable t);
1556 
1557     /**
1558      * Logs a message object with the {@link Level#TRACE TRACE} level.
1559      *
1560      * @param marker the marker data specific to this log statement
1561      * @param message the message string to log.
1562      */
1563     void trace(Marker marker, String message);
1564 
1565     /**
1566      * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
1567      *
1568      * @param marker the marker data specific to this log statement
1569      * @param message the message to log; the format depends on the message factory.
1570      * @param params parameters to the message.
1571      * @see #getMessageFactory()
1572      */
1573     void trace(Marker marker, String message, Object... params);
1574 
1575     /**
1576      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE
1577      * TRACE} level.
1578      *
1579      * @param marker the marker data specific to this log statement
1580      * @param message the message to log; the format depends on the message factory.
1581      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1582      * @since 2.4
1583      */
1584     void trace(Marker marker, String message, Supplier<?>... paramSuppliers);
1585 
1586     /**
1587      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1588      * <code>t</code> passed as parameter.
1589      *
1590      * @param marker the marker data specific to this log statement
1591      * @param message the message object to log.
1592      * @param t the exception to log, including its stack trace.
1593      * @see #debug(String)
1594      */
1595     void trace(Marker marker, String message, Throwable t);
1596 
1597     /**
1598      * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level with
1599      * the specified Marker.
1600      *
1601      * @param marker the marker data specific to this log statement
1602      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1603      *            message factory.
1604      * @since 2.4
1605      */
1606     void trace(Marker marker, Supplier<?> msgSupplier);
1607 
1608     /**
1609      * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) with the
1610      * specified Marker and including the stack trace of the {@link Throwable} <code>t</code> passed as parameter.
1611      *
1612      * @param marker the marker data specific to this log statement
1613      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1614      *            message factory.
1615      * @param t A Throwable or null.
1616      * @since 2.4
1617      */
1618     void trace(Marker marker, Supplier<?> msgSupplier, Throwable t);
1619 
1620     /**
1621      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
1622      *
1623      * @param msg the message string to be logged
1624      */
1625     void trace(Message msg);
1626 
1627     /**
1628      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
1629      *
1630      * @param msg the message string to be logged
1631      * @param t A Throwable or null.
1632      */
1633     void trace(Message msg, Throwable t);
1634 
1635     /**
1636      * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level. The
1637      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
1638      *
1639      * @param msgSupplier A function, which when called, produces the desired log message.
1640      * @since 2.4
1641      */
1642     void trace(MessageSupplier msgSupplier);
1643 
1644     /**
1645      * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the
1646      * stack trace of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
1647      * not use the {@link MessageFactory} to construct the {@code Message}.
1648      *
1649      * @param msgSupplier A function, which when called, produces the desired log message.
1650      * @param t the exception to log, including its stack trace.
1651      * @since 2.4
1652      */
1653     void trace(MessageSupplier msgSupplier, Throwable t);
1654 
1655     /**
1656      * Logs a message object with the {@link Level#TRACE TRACE} level.
1657      *
1658      * @param message the message object to log.
1659      */
1660     void trace(Object message);
1661 
1662     /**
1663      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1664      * <code>t</code> passed as parameter.
1665      *
1666      * @param message the message object to log.
1667      * @param t the exception to log, including its stack trace.
1668      * @see #debug(String)
1669      */
1670     void trace(Object message, Throwable t);
1671 
1672     /**
1673      * Logs a message object with the {@link Level#TRACE TRACE} level.
1674      *
1675      * @param message the message string to log.
1676      */
1677     void trace(String message);
1678 
1679     /**
1680      * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
1681      *
1682      * @param message the message to log; the format depends on the message factory.
1683      * @param params parameters to the message.
1684      * @see #getMessageFactory()
1685      */
1686     void trace(String message, Object... params);
1687 
1688     /**
1689      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#TRACE
1690      * TRACE} level.
1691      *
1692      * @param message the message to log; the format depends on the message factory.
1693      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1694      * @since 2.4
1695      */
1696     void trace(String message, Supplier<?>... paramSuppliers);
1697 
1698     /**
1699      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1700      * <code>t</code> passed as parameter.
1701      *
1702      * @param message the message object to log.
1703      * @param t the exception to log, including its stack trace.
1704      * @see #debug(String)
1705      */
1706     void trace(String message, Throwable t);
1707 
1708     /**
1709      * Logs a message which is only to be constructed if the logging level is the {@link Level#TRACE TRACE} level.
1710      *
1711      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1712      *            message factory.
1713      * @since 2.4
1714      */
1715     void trace(Supplier<?> msgSupplier);
1716 
1717     /**
1718      * Logs a message (only to be constructed if the logging level is the {@link Level#TRACE TRACE} level) including the
1719      * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
1720      *
1721      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1722      *            message factory.
1723      * @param t the exception to log, including its stack trace.
1724      * @since 2.4
1725      */
1726     void trace(Supplier<?> msgSupplier, Throwable t);
1727 
1728     /**
1729      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1730      *
1731      * @param marker the marker data specific to this log statement
1732      * @param msg the message string to be logged
1733      */
1734     void warn(Marker marker, Message msg);
1735 
1736     /**
1737      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1738      *
1739      * @param marker the marker data specific to this log statement
1740      * @param msg the message string to be logged
1741      * @param t A Throwable or null.
1742      */
1743     void warn(Marker marker, Message msg, Throwable t);
1744 
1745     /**
1746      * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with the
1747      * specified Marker. The {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the
1748      * {@code Message}.
1749      *
1750      * @param marker the marker data specific to this log statement
1751      * @param msgSupplier A function, which when called, produces the desired log message.
1752      * @since 2.4
1753      */
1754     void warn(Marker marker, MessageSupplier msgSupplier);
1755 
1756     /**
1757      * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the
1758      * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter. The
1759      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
1760      *
1761      * @param marker the marker data specific to this log statement
1762      * @param msgSupplier A function, which when called, produces the desired log message.
1763      * @param t A Throwable or null.
1764      * @since 2.4
1765      */
1766     void warn(Marker marker, MessageSupplier msgSupplier, Throwable t);
1767 
1768     /**
1769      * Logs a message object with the {@link Level#WARN WARN} level.
1770      *
1771      * @param marker the marker data specific to this log statement
1772      * @param message the message object to log.
1773      */
1774     void warn(Marker marker, Object message);
1775 
1776     /**
1777      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1778      * <code>t</code> passed as parameter.
1779      *
1780      * @param marker the marker data specific to this log statement
1781      * @param message the message object to log.
1782      * @param t the exception to log, including its stack trace.
1783      */
1784     void warn(Marker marker, Object message, Throwable t);
1785 
1786     /**
1787      * Logs a message object with the {@link Level#WARN WARN} level.
1788      *
1789      * @param marker the marker data specific to this log statement
1790      * @param message the message object to log.
1791      */
1792     void warn(Marker marker, String message);
1793 
1794     /**
1795      * Logs a message with parameters at the {@link Level#WARN WARN} level.
1796      *
1797      * @param marker the marker data specific to this log statement.
1798      * @param message the message to log; the format depends on the message factory.
1799      * @param params parameters to the message.
1800      * @see #getMessageFactory()
1801      *
1802      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
1803      *      array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be
1804      *      misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for 1,
1805      *      2 or 3 parameters.
1806      */
1807     void warn(Marker marker, String message, Object... params);
1808 
1809     /**
1810      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN
1811      * WARN} level.
1812      *
1813      * @param marker the marker data specific to this log statement
1814      * @param message the message to log; the format depends on the message factory.
1815      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1816      * @since 2.4
1817      */
1818     void warn(Marker marker, String message, Supplier<?>... paramSuppliers);
1819 
1820     /**
1821      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1822      * <code>t</code> passed as parameter.
1823      *
1824      * @param marker the marker data specific to this log statement
1825      * @param message the message object to log.
1826      * @param t the exception to log, including its stack trace.
1827      */
1828     void warn(Marker marker, String message, Throwable t);
1829 
1830     /**
1831      * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level with the
1832      * specified Marker.
1833      *
1834      * @param marker the marker data specific to this log statement
1835      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1836      *            message factory.
1837      * @since 2.4
1838      */
1839     void warn(Marker marker, Supplier<?> msgSupplier);
1840 
1841     /**
1842      * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) with the
1843      * specified Marker and including the stack warn of the {@link Throwable} <code>t</code> passed as parameter.
1844      *
1845      * @param marker the marker data specific to this log statement
1846      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1847      *            message factory.
1848      * @param t A Throwable or null.
1849      * @since 2.4
1850      */
1851     void warn(Marker marker, Supplier<?> msgSupplier, Throwable t);
1852 
1853     /**
1854      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1855      *
1856      * @param msg the message string to be logged
1857      */
1858     void warn(Message msg);
1859 
1860     /**
1861      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1862      *
1863      * @param msg the message string to be logged
1864      * @param t A Throwable or null.
1865      */
1866     void warn(Message msg, Throwable t);
1867 
1868     /**
1869      * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level. The
1870      * {@code MessageSupplier} may or may not use the {@link MessageFactory} to construct the {@code Message}.
1871      *
1872      * @param msgSupplier A function, which when called, produces the desired log message.
1873      * @since 2.4
1874      */
1875     void warn(MessageSupplier msgSupplier);
1876 
1877     /**
1878      * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the
1879      * stack warn of the {@link Throwable} <code>t</code> passed as parameter. The {@code MessageSupplier} may or may
1880      * not use the {@link MessageFactory} to construct the {@code Message}.
1881      *
1882      * @param msgSupplier A function, which when called, produces the desired log message.
1883      * @param t the exception to log, including its stack warn.
1884      * @since 2.4
1885      */
1886     void warn(MessageSupplier msgSupplier, Throwable t);
1887 
1888     /**
1889      * Logs a message object with the {@link Level#WARN WARN} level.
1890      *
1891      * @param message the message object to log.
1892      */
1893     void warn(Object message);
1894 
1895     /**
1896      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1897      * <code>t</code> passed as parameter.
1898      *
1899      * @param message the message object to log.
1900      * @param t the exception to log, including its stack trace.
1901      */
1902     void warn(Object message, Throwable t);
1903 
1904     /**
1905      * Logs a message object with the {@link Level#WARN WARN} level.
1906      *
1907      * @param message the message string to log.
1908      */
1909     void warn(String message);
1910 
1911     /**
1912      * Logs a message with parameters at the {@link Level#WARN WARN} level.
1913      *
1914      * @param message the message to log; the format depends on the message factory.
1915      * @param params parameters to the message.
1916      * @see #getMessageFactory()
1917      *
1918      *      TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
1919      *      array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be
1920      *      misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for 1,
1921      *      2 or 3 parameters.
1922      */
1923     void warn(String message, Object... params);
1924 
1925     /**
1926      * Logs a message with parameters which are only to be constructed if the logging level is the {@link Level#WARN
1927      * WARN} level.
1928      *
1929      * @param message the message to log; the format depends on the message factory.
1930      * @param paramSuppliers An array of functions, which when called, produce the desired log message parameters.
1931      * @since 2.4
1932      */
1933     void warn(String message, Supplier<?>... paramSuppliers);
1934 
1935     /**
1936      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1937      * <code>t</code> passed as parameter.
1938      *
1939      * @param message the message object to log.
1940      * @param t the exception to log, including its stack trace.
1941      */
1942     void warn(String message, Throwable t);
1943 
1944     /**
1945      * Logs a message which is only to be constructed if the logging level is the {@link Level#WARN WARN} level.
1946      *
1947      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1948      *            message factory.
1949      * @since 2.4
1950      */
1951     void warn(Supplier<?> msgSupplier);
1952 
1953     /**
1954      * Logs a message (only to be constructed if the logging level is the {@link Level#WARN WARN} level) including the
1955      * stack warn of the {@link Throwable} <code>t</code> passed as parameter.
1956      *
1957      * @param msgSupplier A function, which when called, produces the desired log message; the format depends on the
1958      *            message factory.
1959      * @param t the exception to log, including its stack warn.
1960      * @since 2.4
1961      */
1962     void warn(Supplier<?> msgSupplier, Throwable t);
1963 
1964 }