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  
22  /**
23   * This is the central interface in the log4j package. Most logging operations, except configuration, are done through
24   * this interface.
25   *
26   * <p>
27   * The canonical way to obtain a Logger for a class is through {@link LogManager#getLogger()}. Typically, each class
28   * gets its own Logger named after its fully qualified class name (the default Logger name when obtained through the
29   * {@link LogManager#getLogger()} method). Thus, the simplest way to use this would be like so:
30   * </p>
31   * <pre>
32   *     public class MyClass {
33   *         private static final Logger LOGGER = LogManager.getLogger();
34   *         // ...
35   *     }
36   * </pre>
37   * <p>
38   * For ease of filtering, searching, sorting, etc., it is generally a good idea to create Loggers for each class rather
39   * than sharing Loggers. Instead, {@link Marker Markers} should be used for shared, filterable identification.
40   * </p>
41   * <p>
42   * For service provider implementations, it is recommended to extend the
43   * {@link org.apache.logging.log4j.spi.AbstractLogger} class rather than implementing this interface directly.
44   * </p>
45   */
46  public interface Logger {
47  
48      /**
49       * Logs an exception or error that has been caught to a specific logging level.
50       *
51       * @param level The logging Level.
52       * @param t The Throwable.
53       */
54      void catching(Level level, Throwable t);
55  
56      /**
57       * Logs an exception or error that has been caught. Normally, one may wish to provide additional information with
58       * an exception while logging it; in these cases, one would not use this method. In other cases where simply
59       * logging the fact that an exception was swallowed somewhere (e.g., at the top of the stack trace in a
60       * {@code main()} method), this method is ideal for it.
61       *
62       * @param t The Throwable.
63       */
64      void catching(Throwable t);
65  
66      /**
67       * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
68       *
69       * @param marker the marker data specific to this log statement
70       * @param msg the message string to be logged
71       */
72      void debug(Marker marker, Message msg);
73  
74      /**
75       * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
76       *
77       * @param marker the marker data specific to this log statement
78       * @param msg the message string to be logged
79       * @param t A Throwable or null.
80       */
81      void debug(Marker marker, Message msg, Throwable t);
82  
83      /**
84       * Logs a message object with the {@link Level#DEBUG DEBUG} level.
85       *
86       * @param marker the marker data specific to this log statement
87       * @param message the message object to log.
88       */
89      void debug(Marker marker, Object message);
90  
91      /**
92       * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
93       * <code>t</code> passed as parameter.
94       *
95       * @param marker the marker data specific to this log statement
96       * @param message the message to log.
97       * @param t the exception to log, including its stack trace.
98       */
99      void debug(Marker marker, Object message, Throwable t);
100 
101     /**
102      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
103      *
104      * @param marker the marker data specific to this log statement
105      * @param message the message object to log.
106      */
107     void debug(Marker marker, String message);
108 
109     /**
110      * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
111      *
112      * @param marker the marker data specific to this log statement
113      * @param message the message to log; the format depends on the message factory.
114      * @param params parameters to the message.
115      * @see #getMessageFactory()
116      */
117     void debug(Marker marker, String message, Object... params);
118 
119     /**
120      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
121      * <code>t</code> passed as parameter.
122      *
123      * @param marker the marker data specific to this log statement
124      * @param message the message to log.
125      * @param t the exception to log, including its stack trace.
126      */
127     void debug(Marker marker, String message, Throwable t);
128 
129     /**
130      * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
131      *
132      * @param msg the message string to be logged
133      */
134     void debug(Message msg);
135 
136     /**
137      * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
138      *
139      * @param msg the message string to be logged
140      * @param t A Throwable or null.
141      */
142     void debug(Message msg, Throwable t);
143 
144     /**
145      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
146      *
147      * @param message the message object to log.
148      */
149     void debug(Object message);
150 
151     /**
152      * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
153      * <code>t</code> passed as parameter.
154      *
155      * @param message the message to log.
156      * @param t the exception to log, including its stack trace.
157      */
158     void debug(Object message, Throwable t);
159 
160     /**
161      * Logs a message object with the {@link Level#DEBUG DEBUG} level.
162      *
163      * @param message the message object to log.
164      */
165     void debug(String message);
166 
167     /**
168      * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level.
169      *
170      * @param message the message to log; the format depends on the message factory.
171      * @param params parameters to the message.
172      * @see #getMessageFactory()
173      */
174     void debug(String message, Object... params);
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 message the message to log.
181      * @param t the exception to log, including its stack trace.
182      */
183     void debug(String message, Throwable t);
184 
185     /**
186      * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be
187      * logged.
188      */
189     void entry();
190 
191     /**
192      * Logs entry to a method along with its parameters. For example,
193      * <pre>
194      *     public void doSomething(String foo, int bar) {
195      *         LOGGER.entry(foo, bar);
196      *         // do something
197      *     }
198      * </pre>
199      * <p>The use of methods such as this are more effective when combined with aspect-oriented programming or other
200      * bytecode manipulation tools. It can be rather tedious (and messy) to use this type of method manually.</p>
201      *
202      * @param params The parameters to the method.
203      * TODO Use of varargs results in array creation which can be a substantial portion of no-op case. LogMF/LogSF
204      *        provides several overrides to avoid vararg except in edge cases. (RG) LogMF and LogSF implement these in
205      *        LogXF which calls logger.callAppenders. callAppenders is part of the implementation and cannot be used by
206      *        the API. Adding more methods here and in AbstractLogger is sufficient.
207      */
208     void entry(Object... params);
209 
210     /**
211      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
212      *
213      * @param marker the marker data specific to this log statement
214      * @param msg the message string to be logged
215      */
216     void error(Marker marker, Message msg);
217 
218     /**
219      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
220      *
221      * @param marker the marker data specific to this log statement
222      * @param msg the message string to be logged
223      * @param t A Throwable or null.
224      */
225     void error(Marker marker, Message msg, Throwable t);
226 
227     /**
228      * Logs a message object with the {@link Level#ERROR ERROR} level.
229      *
230      * @param marker the marker data specific to this log statement.
231      * @param message the message object to log.
232      */
233     void error(Marker marker, Object message);
234 
235     /**
236      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
237      * <code>t</code> passed as parameter.
238      *
239      * @param marker the marker data specific to this log statement.
240      * @param message the message object to log.
241      * @param t the exception to log, including its stack trace.
242      */
243     void error(Marker marker, Object message, Throwable t);
244 
245     /**
246      * Logs a message object with the {@link Level#ERROR ERROR} level.
247      *
248      * @param marker the marker data specific to this log statement.
249      * @param message the message object to log.
250      */
251     void error(Marker marker, String message);
252 
253     /**
254      * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
255      *
256      * @param marker the marker data specific to this log statement.
257      * @param message the message to log; the format depends on the message factory.
258      * @param params parameters to the message.
259      * @see #getMessageFactory()
260      *
261      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
262      *        array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be
263      *        misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for
264      *        1, 2 or 3 parameters.
265      */
266     void error(Marker marker, String message, Object... params);
267 
268     /**
269      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
270      * <code>t</code> passed as parameter.
271      *
272      * @param marker the marker data specific to this log statement.
273      * @param message the message object to log.
274      * @param t the exception to log, including its stack trace.
275      */
276     void error(Marker marker, String message, Throwable t);
277 
278     /**
279      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
280      *
281      * @param msg the message string to be logged
282      */
283     void error(Message msg);
284 
285     /**
286      * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level.
287      *
288      * @param msg the message string to be logged
289      * @param t A Throwable or null.
290      */
291     void error(Message msg, Throwable t);
292 
293     /**
294      * Logs a message object with the {@link Level#ERROR ERROR} level.
295      *
296      * @param message the message object to log.
297      */
298     void error(Object message);
299 
300     /**
301      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
302      * <code>t</code> passed as parameter.
303      *
304      * @param message the message object to log.
305      * @param t the exception to log, including its stack trace.
306      */
307     void error(Object message, Throwable t);
308 
309     /**
310      * Logs a message object with the {@link Level#ERROR ERROR} level.
311      *
312      * @param message the message object to log.
313      */
314     void error(String message);
315 
316     /**
317      * Logs a message with parameters at the {@link Level#ERROR ERROR} level.
318      *
319      * @param message the message to log; the format depends on the message factory.
320      * @param params parameters to the message.
321      * @see #getMessageFactory()
322      *
323      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
324      *        array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be
325      *        misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for
326      *        1, 2 or 3 parameters.
327      */
328     void error(String message, Object... params);
329 
330     /**
331      * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable}
332      * <code>t</code> passed as parameter.
333      *
334      * @param message the message object to log.
335      * @param t the exception to log, including its stack trace.
336      */
337     void error(String message, Throwable t);
338 
339     /**
340      * Logs exit from a method. Used for methods that do not return anything.
341      */
342     void exit();
343 
344     /**
345      * Logs exiting from a method with the result. This may be coded as:
346      * <pre>
347      *     return LOGGER.exit(myResult);
348      * </pre>
349      *
350      * @param <R> The type of the parameter and object being returned.
351      * @param result The result being returned from the method call.
352      * @return the result.
353      */
354     <R> R exit(R result);
355 
356     /**
357      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
358      *
359      * @param marker the marker data specific to this log statement
360      * @param msg the message string to be logged
361      */
362     void fatal(Marker marker, Message msg);
363 
364     /**
365      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
366      *
367      * @param marker the marker data specific to this log statement
368      * @param msg the message string to be logged
369      * @param t A Throwable or null.
370      */
371     void fatal(Marker marker, Message msg, Throwable t);
372 
373     /**
374      * Logs a message object with the {@link Level#FATAL FATAL} level.
375      *
376      * @param marker The marker data specific to this log statement.
377      * @param message the message object to log.
378      */
379     void fatal(Marker marker, Object message);
380 
381     /**
382      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
383      * <code>t</code> passed as parameter.
384      *
385      * @param marker The marker data specific to this log statement.
386      * @param message the message object to log.
387      * @param t the exception to log, including its stack trace.
388      */
389     void fatal(Marker marker, Object message, Throwable t);
390 
391     /**
392      * Logs a message object with the {@link Level#FATAL FATAL} level.
393      *
394      * @param marker The marker data specific to this log statement.
395      * @param message the message object to log.
396      */
397     void fatal(Marker marker, String message);
398 
399     /**
400      * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
401      *
402      * @param marker The marker data specific to this log statement.
403      * @param message the message to log; the format depends on the message factory.
404      * @param params parameters to the message.
405      * @see #getMessageFactory()
406      *
407      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
408      *        array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be
409      *        misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for
410      *        1, 2 or 3 parameters.
411      */
412     void fatal(Marker marker, String message, Object... params);
413 
414     /**
415      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
416      * <code>t</code> passed as parameter.
417      *
418      * @param marker The marker data specific to this log statement.
419      * @param message the message object to log.
420      * @param t the exception to log, including its stack trace.
421      */
422     void fatal(Marker marker, String message, Throwable t);
423 
424     /**
425      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
426      *
427      * @param msg the message string to be logged
428      */
429     void fatal(Message msg);
430 
431     /**
432      * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level.
433      *
434      * @param msg the message string to be logged
435      * @param t A Throwable or null.
436      */
437     void fatal(Message msg, Throwable t);
438 
439     /**
440      * Logs a message object with the {@link Level#FATAL FATAL} level.
441      *
442      * @param message the message object to log.
443      */
444     void fatal(Object message);
445 
446     /**
447      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
448      * <code>t</code> passed as parameter.
449      *
450      * @param message the message object to log.
451      * @param t the exception to log, including its stack trace.
452      */
453     void fatal(Object message, Throwable t);
454 
455     /**
456      * Logs a message object with the {@link Level#FATAL FATAL} level.
457      *
458      * @param message the message object to log.
459      */
460     void fatal(String message);
461 
462     /**
463      * Logs a message with parameters at the {@link Level#FATAL FATAL} level.
464      *
465      * @param message the message to log; the format depends on the message factory.
466      * @param params parameters to the message.
467      * @see #getMessageFactory()
468      *
469      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
470      *        array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be
471      *        misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for
472      *        1, 2 or 3 parameters.
473      */
474     void fatal(String message, Object... params);
475 
476     /**
477      * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable}
478      * <code>t</code> passed as parameter.
479      *
480      * @param message the message object to log.
481      * @param t the exception to log, including its stack trace.
482      */
483     void fatal(String message, Throwable t);
484 
485     /**
486      * Gets the Level associated with the Logger.
487      *
488      * @return the Level associate with the Logger.
489      */
490     Level getLevel();
491 
492     /**
493      * Gets the message factory used to convert message Objects and Strings into actual log Messages.
494      *
495      * @return the message factory.
496      */
497     MessageFactory getMessageFactory();
498 
499     /**
500      * Gets the logger name.
501      *
502      * @return the logger name.
503      */
504     String getName();
505 
506     /**
507      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
508      *
509      * @param marker the marker data specific to this log statement
510      * @param msg the message string to be logged
511      */
512     void info(Marker marker, Message msg);
513 
514     /**
515      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
516      *
517      * @param marker the marker data specific to this log statement
518      * @param msg the message string to be logged
519      * @param t A Throwable or null.
520      */
521     void info(Marker marker, Message msg, Throwable t);
522 
523     /**
524      * Logs a message object with the {@link Level#INFO INFO} level.
525      *
526      * @param marker the marker data specific to this log statement
527      * @param message the message object to log.
528      */
529     void info(Marker marker, Object message);
530 
531     /**
532      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
533      * <code>t</code> passed as parameter.
534      *
535      * @param marker the marker data specific to this log statement
536      * @param message the message object to log.
537      * @param t the exception to log, including its stack trace.
538      */
539     void info(Marker marker, Object message, Throwable t);
540 
541     /**
542      * Logs a message object with the {@link Level#INFO INFO} level.
543      *
544      * @param marker the marker data specific to this log statement
545      * @param message the message object to log.
546      */
547     void info(Marker marker, String message);
548 
549     /**
550      * Logs a message with parameters at the {@link Level#INFO INFO} level.
551      *
552      * @param marker the marker data specific to this log statement
553      * @param message the message to log; the format depends on the message factory.
554      * @param params parameters to the message.
555      * @see #getMessageFactory()
556      *
557      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
558      *        array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method
559      *        is for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters.
560      */
561     void info(Marker marker, String message, Object... params);
562 
563     /**
564      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
565      * <code>t</code> passed as parameter.
566      *
567      * @param marker the marker data specific to this log statement
568      * @param message the message object to log.
569      * @param t the exception to log, including its stack trace.
570      */
571     void info(Marker marker, String message, Throwable t);
572 
573     /**
574      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
575      *
576      * @param msg the message string to be logged
577      */
578     void info(Message msg);
579 
580     /**
581      * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
582      *
583      * @param msg the message string to be logged
584      * @param t A Throwable or null.
585      */
586     void info(Message msg, Throwable t);
587 
588     /**
589      * Logs a message object with the {@link Level#INFO INFO} level.
590      *
591      * @param message the message object to log.
592      */
593     void info(Object message);
594 
595     /**
596      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
597      * <code>t</code> passed as parameter.
598      *
599      * @param message the message object to log.
600      * @param t the exception to log, including its stack trace.
601      */
602     void info(Object message, Throwable t);
603 
604     /**
605      * Logs a message object with the {@link Level#INFO INFO} level.
606      *
607      * @param message the message object to log.
608      */
609     void info(String message);
610 
611     /**
612      * Logs a message with parameters at the {@link Level#INFO INFO} level.
613      *
614      * @param message the message to log; the format depends on the message factory.
615      * @param params parameters to the message.
616      * @see #getMessageFactory()
617      *
618      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
619      *        array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method
620      *        is for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters.
621      */
622     void info(String message, Object... params);
623 
624     /**
625      * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable}
626      * <code>t</code> passed as parameter.
627      *
628      * @param message the message object to log.
629      * @param t the exception to log, including its stack trace.
630      */
631     void info(String message, Throwable t);
632 
633     /**
634      * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
635      *
636      * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise.
637      */
638     boolean isDebugEnabled();
639 
640     /**
641      * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
642      *
643      * @param marker The marker data specific to this log statement.
644      * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise.
645      */
646     boolean isDebugEnabled(Marker marker);
647 
648     /**
649      * Checks whether this Logger is enabled for the the given Level.
650      * <p>
651      * Note that passing in {@link Level#OFF OFF} always returns {@code true}.
652      * </p>
653      *
654      * @param level the level to check
655      * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise.
656      */
657     boolean isEnabled(Level level);
658 
659     /**
660      * Checks whether this logger is enabled at the specified level and an optional Marker.
661      *
662      * @param level The Level to check.
663      * @param marker The marker data specific to this log statement.
664      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
665      *         otherwise.
666      */
667     boolean isEnabled(Level level, Marker marker);
668 
669     /**
670      * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
671      *
672      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false}
673      *         otherwise.
674      */
675     boolean isErrorEnabled();
676 
677     /**
678      * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
679      *
680      * @param marker The marker data specific to this log statement.
681      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false}
682      *         otherwise.
683      */
684     boolean isErrorEnabled(Marker marker);
685 
686     /**
687      * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
688      *
689      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false}
690      *         otherwise.
691      */
692     boolean isFatalEnabled();
693 
694     /**
695      * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
696      *
697      * @param marker The marker data specific to this log statement.
698      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false}
699      *         otherwise.
700      */
701     boolean isFatalEnabled(Marker marker);
702 
703     /**
704      * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
705      *
706      * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise.
707      */
708     boolean isInfoEnabled();
709 
710     /**
711      * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
712      *
713      * @param marker The marker data specific to this log statement.
714      * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise.
715      */
716     boolean isInfoEnabled(Marker marker);
717 
718     /**
719      * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
720      *
721      * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise.
722      */
723     boolean isTraceEnabled();
724 
725     /**
726      * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
727      *
728      * @param marker The marker data specific to this log statement.
729      * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise.
730      */
731     boolean isTraceEnabled(Marker marker);
732 
733     /**
734      * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
735      *
736      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
737      *         otherwise.
738      */
739     boolean isWarnEnabled();
740 
741     /**
742      * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
743      *
744      * @param marker The marker data specific to this log statement.
745      * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false}
746      *         otherwise.
747      */
748     boolean isWarnEnabled(Marker marker);
749 
750     /**
751      * Logs a message with the specific Marker at the given level.
752      *
753      * @param level the logging level
754      * @param marker the marker data specific to this log statement
755      * @param msg the message string to be logged
756      */
757     void log(Level level, Marker marker, Message msg);
758 
759     /**
760      * Logs a message with the specific Marker at the given level.
761      *
762      * @param level the logging level
763      * @param marker the marker data specific to this log statement
764      * @param msg the message string to be logged
765      * @param t A Throwable or null.
766      */
767     void log(Level level, Marker marker, Message msg, Throwable t);
768 
769     /**
770      * Logs a message object with the given level.
771      *
772      * @param level the logging level
773      * @param marker the marker data specific to this log statement
774      * @param message the message object to log.
775      */
776     void log(Level level, Marker marker, Object message);
777 
778     /**
779      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
780      * parameter.
781      *
782      * @param level the logging level
783      * @param marker the marker data specific to this log statement
784      * @param message the message to log.
785      * @param t the exception to log, including its stack trace.
786      */
787     void log(Level level, Marker marker, Object message, Throwable t);
788 
789     /**
790      * Logs a message object with the given level.
791      *
792      * @param level the logging level
793      * @param marker the marker data specific to this log statement
794      * @param message the message object to log.
795      */
796     void log(Level level, Marker marker, String message);
797 
798     /**
799      * Logs a message with parameters at the given level.
800      *
801      * @param level the logging level
802      * @param marker the marker data specific to this log statement
803      * @param message the message to log; the format depends on the message factory.
804      * @param params parameters to the message.
805      * @see #getMessageFactory()
806      */
807     void log(Level level, Marker marker, String message, Object... params);
808 
809     /**
810      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
811      * parameter.
812      *
813      * @param level the logging level
814      * @param marker the marker data specific to this log statement
815      * @param message the message to log.
816      * @param t the exception to log, including its stack trace.
817      */
818     void log(Level level, Marker marker, String message, Throwable t);
819 
820     /**
821      * Logs a message with the specific Marker at the given level.
822      *
823      * @param level the logging level
824      * @param msg the message string to be logged
825      */
826     void log(Level level, Message msg);
827 
828     /**
829      * Logs a message with the specific Marker at the given level.
830      *
831      * @param level the logging level
832      * @param msg the message string to be logged
833      * @param t A Throwable or null.
834      */
835     void log(Level level, Message msg, Throwable t);
836 
837     /**
838      * Logs a message object with the given level.
839      *
840      * @param level the logging level
841      * @param message the message object to log.
842      */
843     void log(Level level, Object message);
844 
845     /**
846      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
847      * parameter.
848      *
849      * @param level the logging level
850      * @param message the message to log.
851      * @param t the exception to log, including its stack trace.
852      */
853     void log(Level level, Object message, Throwable t);
854 
855     /**
856      * Logs a message object with the given level.
857      *
858      * @param level the logging level
859      * @param message the message object to log.
860      */
861     void log(Level level, String message);
862 
863     /**
864      * Logs a message with parameters at the given level.
865      *
866      * @param level the logging level
867      * @param message the message to log; the format depends on the message factory.
868      * @param params parameters to the message.
869      * @see #getMessageFactory()
870      */
871     void log(Level level, String message, Object... params);
872 
873     /**
874      * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as
875      * parameter.
876      *
877      * @param level the logging level
878      * @param message the message to log.
879      * @param t the exception to log, including its stack trace.
880      */
881     void log(Level level, String message, Throwable t);
882 
883     /**
884      * Logs a formatted message using the specified format string and arguments.
885      *
886      * @param level The logging Level.
887      * @param marker the marker data specific to this log statement.
888      * @param format The format String.
889      * @param params Arguments specified by the format.
890      */
891     void printf(Level level, Marker marker, String format, Object... params);
892 
893     /**
894      * Logs a formatted message using the specified format string and arguments.
895      *
896      * @param level The logging Level.
897      * @param format The format String.
898      * @param params Arguments specified by the format.
899      */
900     void printf(Level level, String format, Object... params);
901 
902     /**
903      * Logs an exception or error to be thrown. This may be coded as:
904      * <pre>
905      *     throw logger.throwing(Level.DEBUG, myException);
906      * </pre>
907      *
908      * @param <T> the Throwable type.
909      * @param level The logging Level.
910      * @param t The Throwable.
911      * @return the Throwable.
912      */
913     <T extends Throwable> T throwing(Level level, T t);
914 
915     /**
916      * Logs an exception or error to be thrown. This may be coded as:
917      * <pre>
918      *     throw logger.throwing(myException);
919      * </pre>
920      *
921      * @param <T> the Throwable type.
922      * @param t The Throwable.
923      * @return the Throwable.
924      */
925     <T extends Throwable> T throwing(T t);
926 
927     /**
928      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
929      *
930      * @param marker the marker data specific to this log statement
931      * @param msg the message string to be logged
932      */
933     void trace(Marker marker, Message msg);
934 
935     /**
936      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
937      *
938      * @param marker the marker data specific to this log statement
939      * @param msg the message string to be logged
940      * @param t A Throwable or null.
941      */
942     void trace(Marker marker, Message msg, Throwable t);
943 
944     /**
945      * Logs a message object with the {@link Level#TRACE TRACE} level.
946      *
947      * @param marker the marker data specific to this log statement
948      * @param message the message object to log.
949      */
950     void trace(Marker marker, Object message);
951 
952     /**
953      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
954      * <code>t</code> passed as parameter.
955      *
956      * @param marker the marker data specific to this log statement
957      * @param message the message object to log.
958      * @param t the exception to log, including its stack trace.
959      * @see #debug(String)
960      */
961     void trace(Marker marker, Object message, Throwable t);
962 
963     /**
964      * Logs a message object with the {@link Level#TRACE TRACE} level.
965      *
966      * @param marker the marker data specific to this log statement
967      * @param message the message object to log.
968      */
969     void trace(Marker marker, String message);
970 
971     /**
972      * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
973      *
974      * @param marker the marker data specific to this log statement
975      * @param message the message to log; the format depends on the message factory.
976      * @param params parameters to the message.
977      * @see #getMessageFactory()
978      */
979     void trace(Marker marker, String message, Object... params);
980 
981     /**
982      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
983      * <code>t</code> passed as parameter.
984      *
985      * @param marker the marker data specific to this log statement
986      * @param message the message object to log.
987      * @param t the exception to log, including its stack trace.
988      * @see #debug(String)
989      */
990     void trace(Marker marker, String message, Throwable t);
991 
992     /**
993      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
994      *
995      * @param msg the message string to be logged
996      */
997     void trace(Message msg);
998 
999     /**
1000      * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
1001      *
1002      * @param msg the message string to be logged
1003      * @param t A Throwable or null.
1004      */
1005     void trace(Message msg, Throwable t);
1006 
1007     /**
1008      * Logs a message object with the {@link Level#TRACE TRACE} level.
1009      *
1010      * @param message the message object to log.
1011      */
1012     void trace(Object message);
1013 
1014     /**
1015      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1016      * <code>t</code> passed as parameter.
1017      *
1018      * @param message the message object to log.
1019      * @param t the exception to log, including its stack trace.
1020      * @see #debug(String)
1021      */
1022     void trace(Object message, Throwable t);
1023 
1024     /**
1025      * Logs a message object with the {@link Level#TRACE TRACE} level.
1026      *
1027      * @param message the message object to log.
1028      */
1029     void trace(String message);
1030 
1031     /**
1032      * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
1033      *
1034      * @param message the message to log; the format depends on the message factory.
1035      * @param params parameters to the message.
1036      * @see #getMessageFactory()
1037      */
1038     void trace(String message, Object... params);
1039 
1040     /**
1041      * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable}
1042      * <code>t</code> passed as parameter.
1043      *
1044      * @param message the message object to log.
1045      * @param t the exception to log, including its stack trace.
1046      * @see #debug(String)
1047      */
1048     void trace(String message, Throwable t);
1049 
1050     /**
1051      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1052      *
1053      * @param marker the marker data specific to this log statement
1054      * @param msg the message string to be logged
1055      */
1056     void warn(Marker marker, Message msg);
1057 
1058     /**
1059      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1060      *
1061      * @param marker the marker data specific to this log statement
1062      * @param msg the message string to be logged
1063      * @param t A Throwable or null.
1064      */
1065     void warn(Marker marker, Message msg, Throwable t);
1066 
1067     /**
1068      * Logs a message object with the {@link Level#WARN WARN} level.
1069      *
1070      * @param marker the marker data specific to this log statement
1071      * @param message the message object to log.
1072      */
1073     void warn(Marker marker, Object message);
1074 
1075     /**
1076      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1077      * <code>t</code> passed as parameter.
1078      *
1079      * @param marker the marker data specific to this log statement
1080      * @param message the message object to log.
1081      * @param t the exception to log, including its stack trace.
1082      */
1083     void warn(Marker marker, Object message, Throwable t);
1084 
1085     /**
1086      * Logs a message object with the {@link Level#WARN WARN} level.
1087      *
1088      * @param marker the marker data specific to this log statement
1089      * @param message the message object to log.
1090      */
1091     void warn(Marker marker, String message);
1092 
1093     /**
1094      * Logs a message with parameters at the {@link Level#WARN WARN} level.
1095      *
1096      * @param marker the marker data specific to this log statement.
1097      * @param message the message to log; the format depends on the message factory.
1098      * @param params parameters to the message.
1099      * @see #getMessageFactory()
1100      *
1101      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
1102      *        array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be
1103      *        misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for
1104      *        1, 2 or 3 parameters.
1105      */
1106     void warn(Marker marker, String message, Object... params);
1107 
1108     /**
1109      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1110      * <code>t</code> passed as parameter.
1111      *
1112      * @param marker the marker data specific to this log statement
1113      * @param message the message object to log.
1114      * @param t the exception to log, including its stack trace.
1115      */
1116     void warn(Marker marker, String message, Throwable t);
1117 
1118     /**
1119      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1120      *
1121      * @param msg the message string to be logged
1122      */
1123     void warn(Message msg);
1124 
1125     /**
1126      * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
1127      *
1128      * @param msg the message string to be logged
1129      * @param t A Throwable or null.
1130      */
1131     void warn(Message msg, Throwable t);
1132 
1133     /**
1134      * Logs a message object with the {@link Level#WARN WARN} level.
1135      *
1136      * @param message the message object to log.
1137      */
1138     void warn(Object message);
1139 
1140     /**
1141      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1142      * <code>t</code> passed as parameter.
1143      *
1144      * @param message the message object to log.
1145      * @param t the exception to log, including its stack trace.
1146      */
1147     void warn(Object message, Throwable t);
1148 
1149     /**
1150      * Logs a message object with the {@link Level#WARN WARN} level.
1151      *
1152      * @param message the message object to log.
1153      */
1154     void warn(String message);
1155 
1156     /**
1157      * Logs a message with parameters at the {@link Level#WARN WARN} level.
1158      *
1159      * @param message the message to log; the format depends on the message factory.
1160      * @param params parameters to the message.
1161      * @see #getMessageFactory()
1162      *
1163      * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs
1164      *        array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be
1165      *        misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for
1166      *        1, 2 or 3 parameters.
1167      */
1168     void warn(String message, Object... params);
1169 
1170     /**
1171      * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable}
1172      * <code>t</code> passed as parameter.
1173      *
1174      * @param message the message object to log.
1175      * @param t the exception to log, including its stack trace.
1176      */
1177     void warn(String message, Throwable t);
1178 }