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