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 logger name.
449       *
450       * @return the logger name.
451       */
452        String getName();
453    
454      /**
455       * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
456       *
457       * @param marker the marker data specific to this log statement
458       * @param msg    the message string to be logged
459       */
460      void info(Marker marker, Message msg);
461    
462      /**
463       * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
464       *
465       * @param marker the marker data specific to this log statement
466       * @param msg    the message string to be logged
467       * @param t      A Throwable or null.
468       */
469      void info(Marker marker, Message msg, Throwable t);
470      /**
471       * Logs a message object with the {@link Level#INFO INFO} level.
472       *
473       * @param marker the marker data specific to this log statement
474       * @param message the message object to log.
475       */
476      void info(Marker marker, Object message);
477    
478      /**
479       * Logs a message at the {@link Level#INFO INFO} level including the
480       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
481       *
482       * @param marker the marker data specific to this log statement
483       * @param message the message object to log.
484       * @param t       the exception to log, including its stack trace.
485       */
486      void info(Marker marker, Object message, Throwable t);
487    
488      /**
489       * Logs a message object with the {@link Level#INFO INFO} level.
490       *
491       * @param marker the marker data specific to this log statement
492       * @param message the message object to log.
493       */
494      void info(Marker marker, String message);
495    
496      /**
497       * Logs a message with parameters at the {@link Level#INFO INFO} level.
498       *
499       * @param marker the marker data specific to this log statement
500       * @param message the message to log; the format depends on the message factory.
501       * @param params parameters to the message.
502       * @see #getMessageFactory()
503       *
504       * @doubt Likely to misinterpret existing log4j client code that intended to call
505       * info(Object,Throwable). Incurs array creation expense on every call. (RG) It isn't
506       * possible to be misinterpreted as the previous method is for that signature. Methods
507       * should be added to avoid varargs for 1, 2 or 3 parameters.
508       */
509      void info(Marker marker, String message, Object... params);
510    
511      /**
512       * Logs a message at the {@link Level#INFO INFO} level including the
513       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
514       *
515       * @param marker the marker data specific to this log statement
516       * @param message the message object to log.
517       * @param t       the exception to log, including its stack trace.
518       */
519      void info(Marker marker, String message, Throwable t);
520    
521      /**
522       * Logs a message with the specific Marker at the TRACE level.
523       *
524       * @param msg the message string to be logged
525       */
526      void info(Message msg);
527    
528      /**
529       * Logs a message with the specific Marker at the {@link Level#INFO INFO} level.
530       *
531       * @param msg the message string to be logged
532       * @param t   A Throwable or null.
533       */
534      void info(Message msg, Throwable t);
535    
536      /**
537       * Logs a message object with the {@link Level#INFO INFO} level.
538       *
539       * @param message the message object to log.
540       */
541      void info(Object message);
542    
543      /**
544       * Logs a message at the {@link Level#INFO INFO} level including the
545       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
546       *
547       * @param message the message object to log.
548       * @param t       the exception to log, including its stack trace.
549       */
550      void info(Object message, Throwable t);
551    
552      /**
553       * Logs a message object with the {@link Level#INFO INFO} level.
554       *
555       * @param message the message object to log.
556       */
557      void info(String message);
558    
559     /**
560       * Logs a message with parameters at the {@link Level#INFO INFO} level.
561       *
562       * @param message the message to log; the format depends on the message factory.
563       * @param params parameters to the message.
564       * @see #getMessageFactory()
565       *
566       * @doubt Likely to misinterpret existing log4j client code that intended to call
567       * info(Object,Throwable). Incurs array creation expense on every call. (RG) It isn't
568       * possible to be misinterpreted as the previous method is for that signature. Methods
569       * should be added to avoid varargs for 1, 2 or 3 parameters.
570       */
571      void info(String message, Object... params);
572    
573      /**
574       * Logs a message at the {@link Level#INFO INFO} level including the
575       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
576       *
577       * @param message the message object to log.
578       * @param t       the exception to log, including its stack trace.
579       */
580      void info(String message, Throwable t);
581    
582      /**
583       * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
584       *
585       * @return boolean - {@code true} if this Logger is enabled for level
586       *         DEBUG, {@code false} otherwise.
587       */
588      boolean isDebugEnabled();
589    
590      /**
591       * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level.
592       *
593       * @param marker The marker data specific to this log statement.
594       * @return boolean - {@code true} if this Logger is enabled for level
595       *         DEBUG, {@code false} otherwise.
596       */
597      boolean isDebugEnabled(Marker marker);
598    
599      /**
600       * Checks whether this Logger is enabled for the the given Level.
601       * <p>
602       * Note that passing in {@link Level#OFF OFF} always returns {@code true}.
603       * </p>
604       * @param level the level to check
605       * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise.
606       */
607      boolean isEnabled(Level level);
608    
609      /**
610       * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
611       *
612       * @return boolean - {@code true} if this Logger is enabled for level
613       *         {@link Level#ERROR ERROR}, {@code false} otherwise.
614       */
615      boolean isErrorEnabled();
616    
617      /**
618       * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level.
619       *
620       * @param marker The marker data specific to this log statement.
621       * @return boolean - {@code true} if this Logger is enabled for level
622       *         {@link Level#ERROR ERROR}, {@code false} otherwise.
623       */
624      boolean isErrorEnabled(Marker marker);
625    
626      /**
627       * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
628       *
629       * @return boolean - {@code true} if this Logger is enabled for level
630       *         {@link Level#FATAL FATAL}, {@code false} otherwise.
631       */
632      boolean isFatalEnabled();
633    
634      /**
635       * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level.
636       *
637       * @param marker The marker data specific to this log statement.
638       * @return boolean - {@code true} if this Logger is enabled for level
639       *         {@link Level#FATAL FATAL}, {@code false} otherwise.
640       */
641      boolean isFatalEnabled(Marker marker);
642    
643      /**
644       * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
645       *
646       * @return boolean - {@code true} if this Logger is enabled for level
647       *         INFO, {@code false} otherwise.
648       */
649      boolean isInfoEnabled();
650    
651      /**
652       * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level.
653       *
654       * @param marker The marker data specific to this log statement.
655       * @return boolean - {@code true} if this Logger is enabled for level
656       *         INFO, {@code false} otherwise.
657       */
658      boolean isInfoEnabled(Marker marker);
659    
660      /**
661       * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
662       *
663       * @return boolean - {@code true} if this Logger is enabled for level
664       *         TRACE, {@code false} otherwise.
665       */
666      boolean isTraceEnabled();
667    
668      /**
669       * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level.
670       *
671       * @param marker The marker data specific to this log statement.
672       * @return boolean - {@code true} if this Logger is enabled for level
673       *         TRACE, {@code false} otherwise.
674       */
675      boolean isTraceEnabled(Marker marker);
676    
677      /**
678       * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
679       *
680       * @return boolean - {@code true} if this Logger is enabled for level
681       *         {@link Level#WARN WARN}, {@code false} otherwise.
682       */
683      boolean isWarnEnabled();
684    
685      /**
686       * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level.
687       *
688       * @param marker The marker data specific to this log statement.
689       * @return boolean - {@code true} if this Logger is enabled for level
690       *         {@link Level#WARN WARN}, {@code false} otherwise.
691       */
692      boolean isWarnEnabled(Marker marker);
693    
694      /**
695       * Logs an exception or error to be thrown. This may be coded as <br />
696       *    throw logger.throwing(debug, myException);
697       * @param <T> the Throwable type.
698       * @param level The logging Level.
699       * @param t The Throwable.
700       * @return the Throwable.
701       */
702      <T extends Throwable> T throwing(Level level, T t);
703    
704      /**
705       * Logs an exception or error to be thrown. This may be coded as <br />
706       *    throw logger.throwing(myException);
707       *
708       * @param <T> the Throwable type.
709       * @param t The Throwable.
710       * @return the Throwable.
711       */
712      <T extends Throwable> T throwing(T t);
713    
714      /**
715       * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
716       *
717       * @param marker the marker data specific to this log statement
718       * @param msg    the message string to be logged
719       */
720      void trace(Marker marker, Message msg);
721    
722      /**
723       * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
724       *
725       * @param marker the marker data specific to this log statement
726       * @param msg    the message string to be logged
727       * @param t      A Throwable or null.
728       */
729      void trace(Marker marker, Message msg, Throwable t);
730    
731      /**
732       * Logs a message object with the {@link Level#TRACE TRACE} level.
733       *
734       * @param marker the marker data specific to this log statement
735       * @param message the message object to log.
736       */
737      void trace(Marker marker, Object message);
738    
739      /**
740       * Logs a message at the {@link Level#TRACE TRACE} level including the
741       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
742       * <p/>
743       * <p>
744       * See {@link #debug(String)} form for more detailed information.
745       * </p>
746       *
747       * @param marker the marker data specific to this log statement
748       * @param message the message object to log.
749       * @param t       the exception to log, including its stack trace.
750       */
751      void trace(Marker marker, Object message, Throwable t);
752    
753      /**
754       * Logs a message object with the {@link Level#TRACE TRACE} level.
755       *
756       * @param marker the marker data specific to this log statement
757       * @param message the message object to log.
758       */
759      void trace(Marker marker, String message);
760    
761      /**
762       * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
763       *
764       * @param marker the marker data specific to this log statement
765       * @param message the message to log; the format depends on the message factory.
766       * @param params parameters to the message.
767       * @see #getMessageFactory()
768       */
769      void trace(Marker marker, String message, Object... params);
770    
771      /**
772       * Logs a message at the {@link Level#TRACE TRACE} level including the
773       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
774       * <p/>
775       * <p>
776       * See {@link #debug(String)} form for more detailed information.
777       * </p>
778       *
779       * @param marker the marker data specific to this log statement
780       * @param message the message object to log.
781       * @param t       the exception to log, including its stack trace.
782       */
783      void trace(Marker marker, String message, Throwable t);
784    
785      /**
786       * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
787       *
788       * @param msg the message string to be logged
789       */
790      void trace(Message msg);
791    
792      /**
793       * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level.
794       *
795       * @param msg the message string to be logged
796       * @param t   A Throwable or null.
797       */
798      void trace(Message msg, Throwable t);
799    
800      /**
801       * Logs a message object with the {@link Level#TRACE TRACE} level.
802       *
803       * @param message the message object to log.
804       */
805      void trace(Object message);
806    
807      /**
808       * Logs a message at the {@link Level#TRACE TRACE} level including the
809       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
810       * <p/>
811       * <p>
812       * See {@link #debug(String)} form for more detailed information.
813       * </p>
814       *
815       * @param message the message object to log.
816       * @param t       the exception to log, including its stack trace.
817       */
818      void trace(Object message, Throwable t);
819    
820      /**
821       * Logs a message object with the {@link Level#TRACE TRACE} level.
822       *
823       * @param message the message object to log.
824       */
825      void trace(String message);
826    
827      /**
828       * Logs a message with parameters at the {@link Level#TRACE TRACE} level.
829       * @param message the message to log; the format depends on the message factory.
830       * @param params parameters to the message.
831       * @see #getMessageFactory()
832       */
833      void trace(String message, Object... params);
834    
835      /**
836       * Logs a message at the {@link Level#TRACE TRACE} level including the
837       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
838       * <p/>
839       * <p>
840       * See {@link #debug(String)} form for more detailed information.
841       * </p>
842       *
843       * @param message the message object to log.
844       * @param t       the exception to log, including its stack trace.
845       */
846      void trace(String message, Throwable t);
847    
848      /**
849       * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
850       *
851       * @param marker the marker data specific to this log statement
852       * @param msg    the message string to be logged
853       */
854      void warn(Marker marker, Message msg);
855    
856    
857      /**
858       * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
859       *
860       * @param marker the marker data specific to this log statement
861       * @param msg    the message string to be logged
862       * @param t      A Throwable or null.
863       */
864      void warn(Marker marker, Message msg, Throwable t);
865    
866      /**
867       * Logs a message object with the {@link Level#WARN WARN} level.
868       *
869       * @param marker the marker data specific to this log statement
870       * @param message the message object to log.
871       */
872      void warn(Marker marker, Object message);
873    
874      /**
875       * Logs a message at the {@link Level#WARN WARN} level including the
876       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
877       *
878       * @param marker the marker data specific to this log statement
879       * @param message the message object to log.
880       * @param t       the exception to log, including its stack trace.
881       */
882      void warn(Marker marker, Object message, Throwable t);
883    
884      /**
885       * Logs a message object with the {@link Level#WARN WARN} level.
886       *
887       * @param marker the marker data specific to this log statement
888       * @param message the message object to log.
889       */
890      void warn(Marker marker, String message);
891    
892      /**
893       * Logs a message with parameters at the {@link Level#WARN WARN} level.
894       *
895       * @param marker the marker data specific to this log statement.
896       * @param message the message to log; the format depends on the message factory.
897       * @param params parameters to the message.
898       * @see #getMessageFactory()
899       *
900       * @doubt Likely to misinterpret existing log4j client code that intended to call
901       * info(Object,Throwable). Incurs array creation expense on every call. (RG) I assume you
902       * meant warn, not info. It isn't possible to be misinterpreted as the previous method
903       * is for that signature.Methods should be added to avoid varargs for 1, 2 or 3 parameters.
904       */
905      void warn(Marker marker, String message, Object... params);
906    
907      /**
908       * Logs a message at the {@link Level#WARN WARN} level including the
909       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
910       *
911       * @param marker the marker data specific to this log statement
912       * @param message the message object to log.
913       * @param t       the exception to log, including its stack trace.
914       */
915      void warn(Marker marker, String message, Throwable t);
916    
917      /**
918       * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
919       *
920       * @param msg the message string to be logged
921       */
922      void warn(Message msg);
923    
924      /**
925       * Logs a message with the specific Marker at the {@link Level#WARN WARN} level.
926       *
927       * @param msg the message string to be logged
928       * @param t   A Throwable or null.
929       */
930      void warn(Message msg, Throwable t);
931    
932      /**
933       * Logs a message object with the {@link Level#WARN WARN} level.
934       *
935       * @param message the message object to log.
936       */
937      void warn(Object message);
938    
939      /**
940       * Logs a message at the {@link Level#WARN WARN} level including the
941       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
942       *
943       * @param message the message object to log.
944       * @param t       the exception to log, including its stack trace.
945       */
946      void warn(Object message, Throwable t);
947    
948      /**
949       * Logs a message object with the {@link Level#WARN WARN} level.
950       *
951       * @param message the message object to log.
952       */
953      void warn(String message);
954    
955      /**
956       * Logs a message with parameters at the {@link Level#WARN WARN} level.
957       * @param message the message to log; the format depends on the message factory.
958       * @param params parameters to the message.
959       * @see #getMessageFactory()
960       *
961       * @doubt Likely to misinterpret existing log4j client code that intended to call
962       * info(Object,Throwable). Incurs array creation expense on every call. (RG) I assume you
963       * meant warn, not info. It isn't possible to be misinterpreted as the previous method
964       * is for that signature.Methods should be added to avoid varargs for 1, 2 or 3 parameters.
965       */
966      void warn(String message, Object... params);
967    
968      /**
969       * Logs a message at the {@link Level#WARN WARN} level including the
970       * stack trace of the {@link Throwable} <code>t</code> passed as parameter.
971       *
972       * @param message the message object to log.
973       * @param t       the exception to log, including its stack trace.
974       */
975      void warn(String message, Throwable t);
976    
977      /**
978       * Gets the message factory used to convert message Objects and Strings into actual log Messages.
979       *
980       * @return the message factory.
981       */
982      MessageFactory getMessageFactory();
983    }