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