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