001/**
002 * Copyright (c) 2004-2021 QOS.ch
003 * All rights reserved.
004 *
005 * Permission is hereby granted, free  of charge, to any person obtaining
006 * a  copy  of this  software  and  associated  documentation files  (the
007 * "Software"), to  deal in  the Software without  restriction, including
008 * without limitation  the rights to  use, copy, modify,  merge, publish,
009 * distribute,  sublicense, and/or sell  copies of  the Software,  and to
010 * permit persons to whom the Software  is furnished to do so, subject to
011 * the following conditions:
012 *
013 * The  above  copyright  notice  and  this permission  notice  shall  be
014 * included in all copies or substantial portions of the Software.
015 *
016 * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
017 * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
018 * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
019 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
020 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
021 * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
022 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
023 *
024 */
025
026package org.slf4j;
027
028import static org.slf4j.event.EventConstants.DEBUG_INT;
029import static org.slf4j.event.EventConstants.ERROR_INT;
030import static org.slf4j.event.EventConstants.INFO_INT;
031import static org.slf4j.event.EventConstants.TRACE_INT;
032import static org.slf4j.event.EventConstants.WARN_INT;
033import static org.slf4j.event.Level.DEBUG;
034import static org.slf4j.event.Level.ERROR;
035import static org.slf4j.event.Level.INFO;
036import static org.slf4j.event.Level.TRACE;
037import static org.slf4j.event.Level.WARN;
038
039import org.slf4j.event.Level;
040import org.slf4j.spi.DefaultLoggingEventBuilder;
041import org.slf4j.spi.LoggingEventBuilder;
042import org.slf4j.spi.NOPLoggingEventBuilder;
043
044/**
045 * The org.slf4j.Logger interface is the main user entry point of SLF4J API.
046 * It is expected that logging takes place through concrete implementations
047 * of this interface.
048 * 
049 * <H3>Typical usage pattern:</H3>
050 * <pre>
051 * import org.slf4j.Logger;
052 * import org.slf4j.LoggerFactory;
053 *
054 * public class Wombat {
055 *
056 *   <span style="color:green">final static Logger logger = LoggerFactory.getLogger(Wombat.class);</span>
057 *   Integer t;
058 *   Integer oldT;
059 *
060 *   public void setTemperature(Integer temperature) {
061 *     oldT = t;
062 *     t = temperature;
063 *     <span style="color:green">logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);</span>
064 *     if (temperature.intValue() &gt; 50) {
065 *       <span style="color:green">logger.info("Temperature has risen above 50 degrees.");</span>
066 *     }
067 *   }
068 * }
069 * </pre>
070 *
071 * <p>Note that version 2.0 of the SLF4J API introduces a <a href="../../../manual.html#fluent">fluent api</a>,
072 * the most significant API change to occur in the last 20 years.
073 *
074 * <p>Be sure to read the FAQ entry relating to <a href="../../../faq.html#logging_performance">parameterized
075 * logging</a>. Note that logging statements can be parameterized in
076 * <a href="../../../faq.html#paramException">presence of an exception/throwable</a>.
077 *
078 * <p>Once you are comfortable using loggers, i.e. instances of this interface, consider using
079 * <a href="MDC.html">MDC</a> as well as <a href="Marker.html">Markers</a>.
080 *
081 * @author Ceki G&uuml;lc&uuml;
082 */
083public interface Logger {
084
085    /**
086     * Case insensitive String constant used to retrieve the name of the root logger.
087     *
088     * @since 1.3
089     */
090    final public String ROOT_LOGGER_NAME = "ROOT";
091
092    /**
093     * Return the name of this <code>Logger</code> instance.
094     * @return name of this logger instance 
095     */
096    public String getName();
097
098    /**
099     * 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}