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