View Javadoc

1   /**
2    * Copyright (c) 2004-2011 QOS.ch
3    * All rights reserved.
4    *
5    * Permission is hereby granted, free  of charge, to any person obtaining
6    * a  copy  of this  software  and  associated  documentation files  (the
7    * "Software"), to  deal in  the Software without  restriction, including
8    * without limitation  the rights to  use, copy, modify,  merge, publish,
9    * distribute,  sublicense, and/or sell  copies of  the Software,  and to
10   * permit persons to whom the Software  is furnished to do so, subject to
11   * the following conditions:
12   *
13   * The  above  copyright  notice  and  this permission  notice  shall  be
14   * included in all copies or substantial portions of the Software.
15   *
16   * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
17   * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
18   * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
19   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20   * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21   * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
22   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23   *
24   */
25  
26  package org.slf4j;
27  
28  import static org.slf4j.event.Level.DEBUG;
29  import static org.slf4j.event.Level.ERROR;
30  import static org.slf4j.event.Level.INFO;
31  import static org.slf4j.event.Level.TRACE;
32  import static org.slf4j.event.Level.WARN;
33  
34  import org.slf4j.spi.DefaultLoggingEventBuilder;
35  import org.slf4j.spi.LoggingEventBuilder;
36  import org.slf4j.spi.NOPLoggingEventBuilder;
37  
38  /**
39   * The org.slf4j.Logger interface is the main user entry point of SLF4J API.
40   * It is expected that logging takes place through concrete implementations
41   * of this interface.
42   * 
43   * <h3>Typical usage pattern:</h3>
44   * <pre>
45   * import org.slf4j.Logger;
46   * import org.slf4j.LoggerFactory;
47   *
48   * public class Wombat {
49   *
50   *   <span style="color:green">final static Logger logger = LoggerFactory.getLogger(Wombat.class);</span>
51   *   Integer t;
52   *   Integer oldT;
53   *
54   *   public void setTemperature(Integer temperature) {
55   *     oldT = t;
56   *     t = temperature;
57   *     <span style="color:green">logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);</span>
58   *     if(temperature.intValue() &gt; 50) {
59   *       <span style="color:green">logger.info("Temperature has risen above 50 degrees.");</span>
60   *     }
61   *   }
62   * }
63   * </pre>
64   *
65   * Be sure to read the FAQ entry relating to <a href="../../../faq.html#logging_performance">parameterized
66   * logging</a>. Note that logging statements can be parameterized in
67   * <a href="../../../faq.html#paramException">presence of an exception/throwable</a>.
68   *
69   * <p>Once you are comfortable using loggers, i.e. instances of this interface, consider using
70   * <a href="MDC.html">MDC</a> as well as <a href="Marker.html">Markers</a>.
71   *
72   * @author Ceki G&uuml;lc&uuml;
73   */
74  public interface Logger {
75  
76      /**
77       * Case insensitive String constant used to retrieve the name of the root logger.
78       *
79       * @since 1.3
80       */
81      final public String ROOT_LOGGER_NAME = "ROOT";
82  
83      /**
84       * Return the name of this <code>Logger</code> instance.
85       * @return name of this logger instance 
86       */
87      public String getName();
88  
89      /**
90       * Is the logger instance enabled for the TRACE level?
91       *
92       * @return True if this Logger is enabled for the TRACE level,
93       *         false otherwise.
94       * @since 1.4
95       */
96      public boolean isTraceEnabled();
97  
98      /**
99       * Log a message at the TRACE level.
100      *
101      * @param msg the message string to be logged
102      * @since 1.4
103      */
104     public void trace(String msg);
105 
106     /**
107      * Log a message at the TRACE level according to the specified format
108      * and argument.
109      * 
110      * <p>This form avoids superfluous object creation when the logger
111      * is disabled for the TRACE level. 
112      *
113      * @param format the format string
114      * @param arg    the argument
115      * @since 1.4
116      */
117     public void trace(String format, Object arg);
118 
119     /**
120      * Log a message at the TRACE level according to the specified format
121      * and arguments.
122      * 
123      * <p>This form avoids superfluous object creation when the logger
124      * is disabled for the TRACE level. 
125      *
126      * @param format the format string
127      * @param arg1   the first argument
128      * @param arg2   the second argument
129      * @since 1.4
130      */
131     public void trace(String format, Object arg1, Object arg2);
132 
133     /**
134      * Log a message at the TRACE level according to the specified format
135      * and arguments.
136      * 
137      * <p>This form avoids superfluous string concatenation when the logger
138      * is disabled for the TRACE level. However, this variant incurs the hidden
139      * (and relatively small) cost of creating an <code>Object[]</code> before invoking the method,
140      * even if this logger is disabled for TRACE. The variants taking {@link #trace(String, Object) one} and
141      * {@link #trace(String, Object, Object) two} arguments exist solely in order to avoid this hidden cost.
142      *
143      * @param format    the format string
144      * @param arguments a list of 3 or more arguments
145      * @since 1.4
146      */
147     public void trace(String format, Object... arguments);
148 
149     /**
150      * Log an exception (throwable) at the TRACE level with an
151      * accompanying message.
152      *
153      * @param msg the message accompanying the exception
154      * @param t   the exception (throwable) to log
155      * @since 1.4
156      */
157     public void trace(String msg, Throwable t);
158 
159     /**
160      * Similar to {@link #isTraceEnabled()} method except that the
161      * marker data is also taken into account.
162      *
163      * @param marker The marker data to take into consideration
164      * @return True if this Logger is enabled for the TRACE level,
165      *         false otherwise.
166      *         
167      * @since 1.4
168      */
169     public boolean isTraceEnabled(Marker marker);
170 
171     /**
172      * Entry point for fluent-logging for {@link org.slf4j.event.Level#TRACE} level. 
173      *  
174      * @return LoggingEventBuilder instance as appropriate for level TRACE
175      */
176     default public LoggingEventBuilder atTrace() {
177     	if(isTraceEnabled()) {
178     		return new DefaultLoggingEventBuilder(this, TRACE);
179     	} else {
180     		return NOPLoggingEventBuilder.singleton();
181     	}
182     }
183     
184     /**
185      * Log a message with the specific Marker at the TRACE level.
186      *
187      * @param marker the marker data specific to this log statement
188      * @param msg    the message string to be logged
189      * @since 1.4@
190      */
191     public void trace(Marker marker, String msg);
192 
193     /**
194      * This method is similar to {@link #trace(String, Object)} method except that the
195      * marker data is also taken into consideration.
196      *
197      * @param marker the marker data specific to this log statement
198      * @param format the format string
199      * @param arg    the argument
200      * @since 1.4
201      */
202     public void trace(Marker marker, String format, Object arg);
203 
204     /**
205      * This method is similar to {@link #trace(String, Object, Object)}
206      * method except that the marker data is also taken into
207      * consideration.
208      *
209      * @param marker the marker data specific to this log statement
210      * @param format the format string
211      * @param arg1   the first argument
212      * @param arg2   the second argument
213      * @since 1.4
214      */
215     public void trace(Marker marker, String format, Object arg1, Object arg2);
216 
217     /**
218      * This method is similar to {@link #trace(String, Object...)}
219      * method except that the marker data is also taken into
220      * consideration.
221      *
222      * @param marker   the marker data specific to this log statement
223      * @param format   the format string
224      * @param argArray an array of arguments
225      * @since 1.4
226      */
227     public void trace(Marker marker, String format, Object... argArray);
228 
229     /**
230      * This method is similar to {@link #trace(String, Throwable)} method except that the
231      * marker data is also taken into consideration.
232      *
233      * @param marker the marker data specific to this log statement
234      * @param msg    the message accompanying the exception
235      * @param t      the exception (throwable) to log
236      * @since 1.4
237      */
238     public void trace(Marker marker, String msg, Throwable t);
239 
240     /**
241      * Is the logger instance enabled for the DEBUG level?
242      *
243      * @return True if this Logger is enabled for the DEBUG level,
244      *         false otherwise.
245      */
246     public boolean isDebugEnabled();
247 
248     /**
249      * Log a message at the DEBUG level.
250      *
251      * @param msg the message string to be logged
252      */
253     public void debug(String msg);
254 
255     /**
256      * Log a message at the DEBUG level according to the specified format
257      * and argument.
258      * 
259      * <p>This form avoids superfluous object creation when the logger
260      * is disabled for the DEBUG level. 
261      *
262      * @param format the format string
263      * @param arg    the argument
264      */
265     public void debug(String format, Object arg);
266 
267     /**
268      * Log a message at the DEBUG level according to the specified format
269      * and arguments.
270      * 
271      * <p>This form avoids superfluous object creation when the logger
272      * is disabled for the DEBUG level. 
273      *
274      * @param format the format string
275      * @param arg1   the first argument
276      * @param arg2   the second argument
277      */
278     public void debug(String format, Object arg1, Object arg2);
279 
280     /**
281      * Log a message at the DEBUG level according to the specified format
282      * and arguments.
283      * 
284      * <p>This form avoids superfluous string concatenation when the logger
285      * is disabled for the DEBUG level. However, this variant incurs the hidden
286      * (and relatively small) cost of creating an <code>Object[]</code> before invoking the method,
287      * even if this logger is disabled for DEBUG. The variants taking
288      * {@link #debug(String, Object) one} and {@link #debug(String, Object, Object) two}
289      * arguments exist solely in order to avoid this hidden cost.
290      *
291      * @param format    the format string
292      * @param arguments a list of 3 or more arguments
293      */
294     public void debug(String format, Object... arguments);
295 
296     /**
297      * Log an exception (throwable) at the DEBUG level with an
298      * accompanying message.
299      *
300      * @param msg the message accompanying the exception
301      * @param t   the exception (throwable) to log
302      */
303     public void debug(String msg, Throwable t);
304 
305     /**
306      * Similar to {@link #isDebugEnabled()} method except that the
307      * marker data is also taken into account.
308      *
309      * @param marker The marker data to take into consideration
310      * @return True if this Logger is enabled for the DEBUG level,
311      *         false otherwise. 
312      */
313     public boolean isDebugEnabled(Marker marker);
314 
315     /**
316      * Log a message with the specific Marker at the DEBUG level.
317      *
318      * @param marker the marker data specific to this log statement
319      * @param msg    the message string to be logged
320      */
321     public void debug(Marker marker, String msg);
322 
323     /**
324      * This method is similar to {@link #debug(String, Object)} method except that the
325      * marker data is also taken into consideration.
326      *
327      * @param marker the marker data specific to this log statement
328      * @param format the format string
329      * @param arg    the argument
330      */
331     public void debug(Marker marker, String format, Object arg);
332 
333     /**
334      * This method is similar to {@link #debug(String, Object, Object)}
335      * method except that the marker data is also taken into
336      * consideration.
337      *
338      * @param marker the marker data specific to this log statement
339      * @param format the format string
340      * @param arg1   the first argument
341      * @param arg2   the second argument
342      */
343     public void debug(Marker marker, String format, Object arg1, Object arg2);
344 
345     /**
346      * This method is similar to {@link #debug(String, Object...)}
347      * method except that the marker data is also taken into
348      * consideration.
349      *
350      * @param marker    the marker data specific to this log statement
351      * @param format    the format string
352      * @param arguments a list of 3 or more arguments
353      */
354     public void debug(Marker marker, String format, Object... arguments);
355 
356     /**
357      * This method is similar to {@link #debug(String, Throwable)} method except that the
358      * marker data is also taken into consideration.
359      *
360      * @param marker the marker data specific to this log statement
361      * @param msg    the message accompanying the exception
362      * @param t      the exception (throwable) to log
363      */
364     public void debug(Marker marker, String msg, Throwable t);
365 
366 
367     /**
368      * Entry point for fluent-logging for {@link org.slf4j.event.Level#DEBUG} level. 
369      *  
370      * @return LoggingEventBuilder instance as appropriate for level DEBUG
371      */
372     default public LoggingEventBuilder atDebug() {
373     	if(isDebugEnabled()) {
374     		return new DefaultLoggingEventBuilder(this, DEBUG);
375     	} else {
376     		return NOPLoggingEventBuilder.singleton();
377     	}
378     }
379     
380     /**
381      * Is the logger instance enabled for the INFO level?
382      *
383      * @return True if this Logger is enabled for the INFO level,
384      *         false otherwise.
385      */
386     public boolean isInfoEnabled();
387 
388     /**
389      * Log a message at the INFO level.
390      *
391      * @param msg the message string to be logged
392      */
393     public void info(String msg);
394 
395     /**
396      * Log a message at the INFO level according to the specified format
397      * and argument.
398      * 
399      * <p>This form avoids superfluous object creation when the logger
400      * is disabled for the INFO level. 
401      *
402      * @param format the format string
403      * @param arg    the argument
404      */
405     public void info(String format, Object arg);
406 
407     /**
408      * Log a message at the INFO level according to the specified format
409      * and arguments.
410      * 
411      * <p>This form avoids superfluous object creation when the logger
412      * is disabled for the INFO level. 
413      *
414      * @param format the format string
415      * @param arg1   the first argument
416      * @param arg2   the second argument
417      */
418     public void info(String format, Object arg1, Object arg2);
419 
420     /**
421      * Log a message at the INFO level according to the specified format
422      * and arguments.
423      * 
424      * <p>This form avoids superfluous string concatenation when the logger
425      * is disabled for the INFO level. However, this variant incurs the hidden
426      * (and relatively small) cost of creating an <code>Object[]</code> before invoking the method,
427      * even if this logger is disabled for INFO. The variants taking
428      * {@link #info(String, Object) one} and {@link #info(String, Object, Object) two}
429      * arguments exist solely in order to avoid this hidden cost.
430      *
431      * @param format    the format string
432      * @param arguments a list of 3 or more arguments
433      */
434     public void info(String format, Object... arguments);
435 
436     /**
437      * Log an exception (throwable) at the INFO level with an
438      * accompanying message.
439      *
440      * @param msg the message accompanying the exception
441      * @param t   the exception (throwable) to log
442      */
443     public void info(String msg, Throwable t);
444 
445     /**
446      * Similar to {@link #isInfoEnabled()} method except that the marker
447      * data is also taken into consideration.
448      *
449      * @param marker The marker data to take into consideration
450      * @return true if this logger is warn enabled, false otherwise 
451      */
452     public boolean isInfoEnabled(Marker marker);
453 
454     /**
455      * Log a message with the specific Marker at the INFO level.
456      *
457      * @param marker The marker specific to this log statement
458      * @param msg    the message string to be logged
459      */
460     public void info(Marker marker, String msg);
461 
462     /**
463      * This method is similar to {@link #info(String, Object)} method except that the
464      * marker data is also taken into consideration.
465      *
466      * @param marker the marker data specific to this log statement
467      * @param format the format string
468      * @param arg    the argument
469      */
470     public void info(Marker marker, String format, Object arg);
471 
472     /**
473      * This method is similar to {@link #info(String, Object, Object)}
474      * method except that the marker data is also taken into
475      * consideration.
476      *
477      * @param marker the marker data specific to this log statement
478      * @param format the format string
479      * @param arg1   the first argument
480      * @param arg2   the second argument
481      */
482     public void info(Marker marker, String format, Object arg1, Object arg2);
483 
484     /**
485      * This method is similar to {@link #info(String, Object...)}
486      * method except that the marker data is also taken into
487      * consideration.
488      *
489      * @param marker    the marker data specific to this log statement
490      * @param format    the format string
491      * @param arguments a list of 3 or more arguments
492      */
493     public void info(Marker marker, String format, Object... arguments);
494 
495     /**
496      * This method is similar to {@link #info(String, Throwable)} method
497      * except that the marker data is also taken into consideration.
498      *
499      * @param marker the marker data for this log statement
500      * @param msg    the message accompanying the exception
501      * @param t      the exception (throwable) to log
502      */
503     public void info(Marker marker, String msg, Throwable t);
504 
505     /**
506      * Entry point for fluent-logging for {@link org.slf4j.event.Level#INFO} level. 
507      *  
508      * @return LoggingEventBuilder instance as appropriate for level INFO
509      */
510     default public LoggingEventBuilder atInfo() {
511     	if(isInfoEnabled()) {
512     		return new DefaultLoggingEventBuilder(this, INFO);
513     	} else {
514     		return NOPLoggingEventBuilder.singleton();
515     	}
516     }
517  
518     
519     /**
520      * Is the logger instance enabled for the WARN level?
521      *
522      * @return True if this Logger is enabled for the WARN level,
523      *         false otherwise.
524      */
525     public boolean isWarnEnabled();
526 
527     /**
528      * Log a message at the WARN level.
529      *
530      * @param msg the message string to be logged
531      */
532     public void warn(String msg);
533 
534     /**
535      * Log a message at the WARN level according to the specified format
536      * and argument.
537      * 
538      * <p>This form avoids superfluous object creation when the logger
539      * is disabled for the WARN level. 
540      *
541      * @param format the format string
542      * @param arg    the argument
543      */
544     public void warn(String format, Object arg);
545 
546     /**
547      * Log a message at the WARN level according to the specified format
548      * and arguments.
549      * 
550      * <p>This form avoids superfluous string concatenation when the logger
551      * is disabled for the WARN level. However, this variant incurs the hidden
552      * (and relatively small) cost of creating an <code>Object[]</code> before invoking the method,
553      * even if this logger is disabled for WARN. The variants taking
554      * {@link #warn(String, Object) one} and {@link #warn(String, Object, Object) two}
555      * arguments exist solely in order to avoid this hidden cost.
556      *
557      * @param format    the format string
558      * @param arguments a list of 3 or more arguments
559      */
560     public void warn(String format, Object... arguments);
561 
562     /**
563      * Log a message at the WARN level according to the specified format
564      * and arguments.
565      * 
566      * <p>This form avoids superfluous object creation when the logger
567      * is disabled for the WARN level. 
568      *
569      * @param format the format string
570      * @param arg1   the first argument
571      * @param arg2   the second argument
572      */
573     public void warn(String format, Object arg1, Object arg2);
574 
575     /**
576      * Log an exception (throwable) at the WARN level with an
577      * accompanying message.
578      *
579      * @param msg the message accompanying the exception
580      * @param t   the exception (throwable) to log
581      */
582     public void warn(String msg, Throwable t);
583 
584     /**
585      * Similar to {@link #isWarnEnabled()} method except that the marker
586      * data is also taken into consideration.
587      *
588      * @param marker The marker data to take into consideration
589      * @return True if this Logger is enabled for the WARN level,
590      *         false otherwise.
591      */
592     public boolean isWarnEnabled(Marker marker);
593 
594     /**
595      * Log a message with the specific Marker at the WARN level.
596      *
597      * @param marker The marker specific to this log statement
598      * @param msg    the message string to be logged
599      */
600     public void warn(Marker marker, String msg);
601 
602     /**
603      * This method is similar to {@link #warn(String, Object)} method except that the
604      * marker data is also taken into consideration.
605      *
606      * @param marker the marker data specific to this log statement
607      * @param format the format string
608      * @param arg    the argument
609      */
610     public void warn(Marker marker, String format, Object arg);
611 
612     /**
613      * This method is similar to {@link #warn(String, Object, Object)}
614      * method except that the marker data is also taken into
615      * consideration.
616      *
617      * @param marker the marker data specific to this log statement
618      * @param format the format string
619      * @param arg1   the first argument
620      * @param arg2   the second argument
621      */
622     public void warn(Marker marker, String format, Object arg1, Object arg2);
623 
624     /**
625      * This method is similar to {@link #warn(String, Object...)}
626      * method except that the marker data is also taken into
627      * consideration.
628      *
629      * @param marker    the marker data specific to this log statement
630      * @param format    the format string
631      * @param arguments a list of 3 or more arguments
632      */
633     public void warn(Marker marker, String format, Object... arguments);
634 
635     /**
636      * This method is similar to {@link #warn(String, Throwable)} method
637      * except that the marker data is also taken into consideration.
638      *
639      * @param marker the marker data for this log statement
640      * @param msg    the message accompanying the exception
641      * @param t      the exception (throwable) to log
642      */
643     public void warn(Marker marker, String msg, Throwable t);
644 
645     
646     /**
647      * Entry point for fluent-logging for {@link org.slf4j.event.Level#WARN} level. 
648      *  
649      * @return LoggingEventBuilder instance as appropriate for level WARN
650      */
651     default public LoggingEventBuilder atWarn() {
652     	if(isWarnEnabled()) {
653     		return new DefaultLoggingEventBuilder(this, WARN);
654     	} else {
655     		return NOPLoggingEventBuilder.singleton();
656     	}
657     }
658 
659     
660     /**
661      * Is the logger instance enabled for the ERROR level?
662      *
663      * @return True if this Logger is enabled for the ERROR level,
664      *         false otherwise.
665      */
666     public boolean isErrorEnabled();
667 
668     /**
669      * Log a message at the ERROR level.
670      *
671      * @param msg the message string to be logged
672      */
673     public void error(String msg);
674 
675     /**
676      * Log a message at the ERROR level according to the specified format
677      * and argument.
678      * 
679      * <p>This form avoids superfluous object creation when the logger
680      * is disabled for the ERROR level. 
681      *
682      * @param format the format string
683      * @param arg    the argument
684      */
685     public void error(String format, Object arg);
686 
687     /**
688      * Log a message at the ERROR level according to the specified format
689      * and arguments.
690      * 
691      * <p>This form avoids superfluous object creation when the logger
692      * is disabled for the ERROR level. 
693      *
694      * @param format the format string
695      * @param arg1   the first argument
696      * @param arg2   the second argument
697      */
698     public void error(String format, Object arg1, Object arg2);
699 
700     /**
701      * Log a message at the ERROR level according to the specified format
702      * and arguments.
703      * 
704      * <p>This form avoids superfluous string concatenation when the logger
705      * is disabled for the ERROR level. However, this variant incurs the hidden
706      * (and relatively small) cost of creating an <code>Object[]</code> before invoking the method,
707      * even if this logger is disabled for ERROR. The variants taking
708      * {@link #error(String, Object) one} and {@link #error(String, Object, Object) two}
709      * arguments exist solely in order to avoid this hidden cost.
710      *
711      * @param format    the format string
712      * @param arguments a list of 3 or more arguments
713      */
714     public void error(String format, Object... arguments);
715 
716     /**
717      * Log an exception (throwable) at the ERROR level with an
718      * accompanying message.
719      *
720      * @param msg the message accompanying the exception
721      * @param t   the exception (throwable) to log
722      */
723     public void error(String msg, Throwable t);
724 
725     /**
726      * Similar to {@link #isErrorEnabled()} method except that the
727      * marker data is also taken into consideration.
728      *
729      * @param marker The marker data to take into consideration
730      * @return True if this Logger is enabled for the ERROR level,
731      *         false otherwise.
732      */
733     public boolean isErrorEnabled(Marker marker);
734 
735     /**
736      * Log a message with the specific Marker at the ERROR level.
737      *
738      * @param marker The marker specific to this log statement
739      * @param msg    the message string to be logged
740      */
741     public void error(Marker marker, String msg);
742 
743     /**
744      * This method is similar to {@link #error(String, Object)} method except that the
745      * marker data is also taken into consideration.
746      *
747      * @param marker the marker data specific to this log statement
748      * @param format the format string
749      * @param arg    the argument
750      */
751     public void error(Marker marker, String format, Object arg);
752 
753     /**
754      * This method is similar to {@link #error(String, Object, Object)}
755      * method except that the marker data is also taken into
756      * consideration.
757      *
758      * @param marker the marker data specific to this log statement
759      * @param format the format string
760      * @param arg1   the first argument
761      * @param arg2   the second argument
762      */
763     public void error(Marker marker, String format, Object arg1, Object arg2);
764 
765     /**
766      * This method is similar to {@link #error(String, Object...)}
767      * method except that the marker data is also taken into
768      * consideration.
769      *
770      * @param marker    the marker data specific to this log statement
771      * @param format    the format string
772      * @param arguments a list of 3 or more arguments
773      */
774     public void error(Marker marker, String format, Object... arguments);
775 
776     /**
777      * This method is similar to {@link #error(String, Throwable)}
778      * method except that the marker data is also taken into
779      * consideration.
780      *
781      * @param marker the marker data specific to this log statement
782      * @param msg    the message accompanying the exception
783      * @param t      the exception (throwable) to log
784      */
785     public void error(Marker marker, String msg, Throwable t);
786     
787     
788     
789     /**
790      * Entry point for fluent-logging for {@link org.slf4j.event.Level#ERROR} level. 
791      *  
792      * @return LoggingEventBuilder instance as appropriate for level ERROR
793      */
794     default public LoggingEventBuilder atError() {
795     	if(isErrorEnabled()) {
796     		return new DefaultLoggingEventBuilder(this, ERROR);
797     	} else {
798     		return NOPLoggingEventBuilder.singleton();
799     	}
800     }
801 
802 }