001/**
002 * Copyright (c) 2004-2011 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.Level.DEBUG;
029import static org.slf4j.event.Level.ERROR;
030import static org.slf4j.event.Level.INFO;
031import static org.slf4j.event.Level.TRACE;
032import static org.slf4j.event.Level.WARN;
033
034import org.slf4j.spi.DefaultLoggingEventBuilder;
035import org.slf4j.spi.LoggingEventBuilder;
036import org.slf4j.spi.NOPLoggingEventBuilder;
037
038/**
039 * The org.slf4j.Logger interface is the main user entry point of SLF4J API.
040 * It is expected that logging takes place through concrete implementations
041 * of this interface.
042 * 
043 * <h3>Typical usage pattern:</h3>
044 * <pre>
045 * import org.slf4j.Logger;
046 * import org.slf4j.LoggerFactory;
047 *
048 * public class Wombat {
049 *
050 *   <span style="color:green">final static Logger logger = LoggerFactory.getLogger(Wombat.class);</span>
051 *   Integer t;
052 *   Integer oldT;
053 *
054 *   public void setTemperature(Integer temperature) {
055 *     oldT = t;
056 *     t = temperature;
057 *     <span style="color:green">logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);</span>
058 *     if(temperature.intValue() &gt; 50) {
059 *       <span style="color:green">logger.info("Temperature has risen above 50 degrees.");</span>
060 *     }
061 *   }
062 * }
063 * </pre>
064 *
065 * Be sure to read the FAQ entry relating to <a href="../../../faq.html#logging_performance">parameterized
066 * logging</a>. Note that logging statements can be parameterized in
067 * <a href="../../../faq.html#paramException">presence of an exception/throwable</a>.
068 *
069 * <p>Once you are comfortable using loggers, i.e. instances of this interface, consider using
070 * <a href="MDC.html">MDC</a> as well as <a href="Marker.html">Markers</a>.
071 *
072 * @author Ceki G&uuml;lc&uuml;
073 */
074public interface Logger {
075
076    /**
077     * Case insensitive String constant used to retrieve the name of the root logger.
078     *
079     * @since 1.3
080     */
081    final public String ROOT_LOGGER_NAME = "ROOT";
082
083    /**
084     * Return the name of this <code>Logger</code> instance.
085     * @return name of this logger instance 
086     */
087    public String getName();
088
089    /**
090     * Is the logger instance enabled for the TRACE level?
091     *
092     * @return True if this Logger is enabled for the TRACE level,
093     *         false otherwise.
094     * @since 1.4
095     */
096    public boolean isTraceEnabled();
097
098    /**
099     * 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}