001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache license, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the license for the specific language governing permissions and
015 * limitations under the license.
016 */
017package org.apache.logging.log4j;
018
019import org.apache.logging.log4j.message.Message;
020import org.apache.logging.log4j.message.MessageFactory;
021
022/**
023 * This is the central interface in the log4j package. Most logging operations, except configuration, are done through
024 * this interface.
025 *
026 * <p>
027 * The canonical way to obtain a Logger for a class is through {@link LogManager#getLogger()}. Typically, each class
028 * gets its own Logger named after its fully qualified class name (the default Logger name when obtained through the
029 * {@link LogManager#getLogger()} method). Thus, the simplest way to use this would be like so:
030 * </p>
031 * <pre>
032 *     public class MyClass {
033 *         private static final Logger LOGGER = LogManager.getLogger();
034 *         // ...
035 *     }
036 * </pre>
037 * <p>
038 * For ease of filtering, searching, sorting, etc., it is generally a good idea to create Loggers for each class rather
039 * than sharing Loggers. Instead, {@link Marker Markers} should be used for shared, filterable identification.
040 * </p>
041 * <p>
042 * For service provider implementations, it is recommended to extend the
043 * {@link org.apache.logging.log4j.spi.AbstractLogger} class rather than implementing this interface directly.
044 * </p>
045 */
046public interface Logger {
047
048    /**
049     * Logs an exception or error that has been caught to a specific logging level.
050     *
051     * @param level The logging Level.
052     * @param t The Throwable.
053     */
054    void catching(Level level, Throwable t);
055
056    /**
057     * Logs an exception or error that has been caught. Normally, one may wish to provide additional information with
058     * an exception while logging it; in these cases, one would not use this method. In other cases where simply
059     * logging the fact that an exception was swallowed somewhere (e.g., at the top of the stack trace in a
060     * {@code main()} method), this method is ideal for it.
061     *
062     * @param t The Throwable.
063     */
064    void catching(Throwable t);
065
066    /**
067     * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
068     *
069     * @param marker the marker data specific to this log statement
070     * @param msg the message string to be logged
071     */
072    void debug(Marker marker, Message msg);
073
074    /**
075     * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level.
076     *
077     * @param marker the marker data specific to this log statement
078     * @param msg the message string to be logged
079     * @param t A Throwable or null.
080     */
081    void debug(Marker marker, Message msg, Throwable t);
082
083    /**
084     * Logs a message object with the {@link Level#DEBUG DEBUG} level.
085     *
086     * @param marker the marker data specific to this log statement
087     * @param message the message object to log.
088     */
089    void debug(Marker marker, Object message);
090
091    /**
092     * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable}
093     * <code>t</code> passed as parameter.
094     *
095     * @param marker the marker data specific to this log statement
096     * @param message the message to log.
097     * @param t the exception to log, including its stack trace.
098     */
099    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 string 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 string 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 string 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 string 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 string 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 string 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 string 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 string 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}