1   package org.slf4j.ext;
2   
3   import org.slf4j.Logger;
4   import org.slf4j.Marker;
5   import org.slf4j.helpers.FormattingTuple;
6   import org.slf4j.helpers.MessageFormatter;
7   import org.slf4j.spi.LocationAwareLogger;
8   
9   /**
10   * A helper class wrapping an {@link org.slf4j.Logger} instance preserving
11   * location information if the wrapped instance supports it.
12   * 
13   * @author Ralph Goers
14   * @author Ceki Gülcü
15   */
16  public class LoggerWrapper implements Logger {
17  
18    // To ensure consistency between two instances sharing the same name
19    // (homonyms)
20    // a LoggerWrapper should not contain any state beyond
21    // the Logger instance it wraps.
22    // Note that 'instanceofLAL' directly depends on Logger.
23    // fqcn depend on the caller, but its value would not be different
24    // between successive invocations of a factory class
25  
26    protected final Logger logger;
27    final String fqcn;
28    // is this logger instance a LocationAwareLogger
29    protected final boolean instanceofLAL;
30  
31    public LoggerWrapper(Logger logger, String fqcn) {
32      this.logger = logger;
33      this.fqcn = fqcn;
34      if (logger instanceof LocationAwareLogger) {
35        instanceofLAL = true;
36      } else {
37        instanceofLAL = false;
38      }
39    }
40  
41    /**
42     * Delegate to the appropriate method of the underlying logger.
43     */
44    public boolean isTraceEnabled() {
45      return logger.isTraceEnabled();
46    }
47  
48    /**
49     * Delegate to the appropriate method of the underlying logger.
50     */
51    public boolean isTraceEnabled(Marker marker) {
52      return logger.isTraceEnabled(marker);
53    }
54  
55    /**
56     * Delegate to the appropriate method of the underlying logger.
57     */
58    public void trace(String msg) {
59      if (!logger.isTraceEnabled())
60        return;
61  
62      if (instanceofLAL) {
63        ((LocationAwareLogger) logger).log(null, fqcn,
64            LocationAwareLogger.TRACE_INT, msg, null, null);
65      } else {
66        logger.trace(msg);
67      }
68    }
69  
70    /**
71     * Delegate to the appropriate method of the underlying logger.
72     */
73    public void trace(String format, Object arg) {
74      if (!logger.isTraceEnabled())
75        return;
76  
77      if (instanceofLAL) {
78        String formattedMessage = MessageFormatter.format(format, arg)
79            .getMessage();
80        ((LocationAwareLogger) logger).log(null, fqcn,
81            LocationAwareLogger.TRACE_INT, formattedMessage,
82            new Object[] { arg }, null);
83      } else {
84        logger.trace(format, arg);
85      }
86    }
87  
88    /**
89     * Delegate to the appropriate method of the underlying logger.
90     */
91    public void trace(String format, Object arg1, Object arg2) {
92      if (!logger.isTraceEnabled())
93        return;
94  
95      if (instanceofLAL) {
96        String formattedMessage = MessageFormatter.format(format, arg1, arg2)
97            .getMessage();
98        ((LocationAwareLogger) logger).log(null, fqcn,
99            LocationAwareLogger.TRACE_INT, formattedMessage, new Object[] { arg1,
100               arg2 }, null);
101     } else {
102       logger.trace(format, arg1, arg2);
103     }
104   }
105 
106   /**
107    * Delegate to the appropriate method of the underlying logger.
108    */
109   public void trace(String format, Object[] argArray) {
110     if (!logger.isTraceEnabled())
111       return;
112 
113     if (instanceofLAL) {
114       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
115           .getMessage();
116       ((LocationAwareLogger) logger).log(null, fqcn,
117           LocationAwareLogger.TRACE_INT, formattedMessage, argArray, null);
118     } else {
119       logger.trace(format, argArray);
120     }
121   }
122 
123   /**
124    * Delegate to the appropriate method of the underlying logger.
125    */
126   public void trace(String msg, Throwable t) {
127     if (!logger.isTraceEnabled())
128       return;
129 
130     if (instanceofLAL) {
131       ((LocationAwareLogger) logger).log(null, fqcn,
132           LocationAwareLogger.TRACE_INT, msg, null, t);
133     } else {
134       logger.trace(msg, t);
135     }
136   }
137 
138   /**
139    * Delegate to the appropriate method of the underlying logger.
140    */
141   public void trace(Marker marker, String msg) {
142     if (!logger.isTraceEnabled())
143       return;
144     if (instanceofLAL) {
145       ((LocationAwareLogger) logger).log(marker, fqcn,
146           LocationAwareLogger.TRACE_INT, msg, null, null);
147     } else {
148       logger.trace(marker, msg);
149     }
150   }
151 
152   /**
153    * Delegate to the appropriate method of the underlying logger.
154    */
155   public void trace(Marker marker, String format, Object arg) {
156     if (!logger.isTraceEnabled())
157       return;
158     if (instanceofLAL) {
159       String formattedMessage = MessageFormatter.format(format, arg)
160           .getMessage();
161       ((LocationAwareLogger) logger).log(marker, fqcn,
162           LocationAwareLogger.TRACE_INT, formattedMessage,
163           new Object[] { arg }, null);
164     } else {
165       logger.trace(marker, format, arg);
166     }
167   }
168 
169   /**
170    * Delegate to the appropriate method of the underlying logger.
171    */
172   public void trace(Marker marker, String format, Object arg1, Object arg2) {
173     if (!logger.isTraceEnabled())
174       return;
175     if (instanceofLAL) {
176       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
177           .getMessage();
178       ((LocationAwareLogger) logger).log(marker, fqcn,
179           LocationAwareLogger.TRACE_INT, formattedMessage, new Object[] { arg1,
180               arg2 }, null);
181     } else {
182       logger.trace(marker, format, arg1, arg2);
183     }
184   }
185 
186   /**
187    * Delegate to the appropriate method of the underlying logger.
188    */
189   public void trace(Marker marker, String format, Object[] argArray) {
190     if (!logger.isTraceEnabled())
191       return;
192     if (instanceofLAL) {
193       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
194           .getMessage();
195       ((LocationAwareLogger) logger).log(marker, fqcn,
196           LocationAwareLogger.TRACE_INT, formattedMessage, argArray, null);
197     } else {
198       logger.trace(marker, format, argArray);
199     }
200   }
201 
202   /**
203    * Delegate to the appropriate method of the underlying logger.
204    */
205   public void trace(Marker marker, String msg, Throwable t) {
206     if (!logger.isTraceEnabled())
207       return;
208     if (instanceofLAL) {
209       ((LocationAwareLogger) logger).log(marker, fqcn,
210           LocationAwareLogger.TRACE_INT, msg, null, t);
211     } else {
212       logger.trace(marker, msg, t);
213     }
214   }
215 
216   /**
217    * Delegate to the appropriate method of the underlying logger.
218    */
219   public boolean isDebugEnabled() {
220     return logger.isDebugEnabled();
221   }
222 
223   /**
224    * Delegate to the appropriate method of the underlying logger.
225    */
226   public boolean isDebugEnabled(Marker marker) {
227     return logger.isDebugEnabled(marker);
228   }
229 
230   /**
231    * Delegate to the appropriate method of the underlying logger.
232    */
233   public void debug(String msg) {
234     if (!logger.isDebugEnabled())
235       return;
236 
237     if (instanceofLAL) {
238       ((LocationAwareLogger) logger).log(null, fqcn,
239           LocationAwareLogger.DEBUG_INT, msg, null, null);
240     } else {
241       logger.debug(msg);
242     }
243   }
244 
245   /**
246    * Delegate to the appropriate method of the underlying logger.
247    */
248   public void debug(String format, Object arg) {
249     if (!logger.isDebugEnabled())
250       return;
251 
252     if (instanceofLAL) {
253       String formattedMessage = MessageFormatter.format(format, arg)
254           .getMessage();
255       ((LocationAwareLogger) logger).log(null, fqcn,
256           LocationAwareLogger.DEBUG_INT, formattedMessage,
257           new Object[] { arg }, null);
258     } else {
259       logger.debug(format, arg);
260     }
261   }
262 
263   /**
264    * Delegate to the appropriate method of the underlying logger.
265    */
266   public void debug(String format, Object arg1, Object arg2) {
267     if (!logger.isDebugEnabled())
268       return;
269 
270     if (instanceofLAL) {
271       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
272           .getMessage();
273       ((LocationAwareLogger) logger).log(null, fqcn,
274           LocationAwareLogger.DEBUG_INT, formattedMessage, new Object[] { arg1,
275               arg2 }, null);
276     } else {
277       logger.debug(format, arg1, arg2);
278     }
279   }
280 
281   /**
282    * Delegate to the appropriate method of the underlying logger.
283    */
284   public void debug(String format, Object[] argArray) {
285     if (!logger.isDebugEnabled())
286       return;
287 
288     if (instanceofLAL) {
289       FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
290       ((LocationAwareLogger) logger).log(null, fqcn,
291           LocationAwareLogger.DEBUG_INT, ft.getMessage(), ft.getArgArray(), ft
292               .getThrowable());
293     } else {
294       logger.debug(format, argArray);
295     }
296   }
297 
298   /**
299    * Delegate to the appropriate method of the underlying logger.
300    */
301   public void debug(String msg, Throwable t) {
302     if (!logger.isDebugEnabled())
303       return;
304 
305     if (instanceofLAL) {
306       ((LocationAwareLogger) logger).log(null, fqcn,
307           LocationAwareLogger.DEBUG_INT, msg, null, t);
308     } else {
309       logger.debug(msg, t);
310     }
311   }
312 
313   /**
314    * Delegate to the appropriate method of the underlying logger.
315    */
316   public void debug(Marker marker, String msg) {
317     if (!logger.isDebugEnabled())
318       return;
319     if (instanceofLAL) {
320       ((LocationAwareLogger) logger).log(marker, fqcn,
321           LocationAwareLogger.DEBUG_INT, msg, null, null);
322     } else {
323       logger.debug(marker, msg);
324     }
325   }
326 
327   /**
328    * Delegate to the appropriate method of the underlying logger.
329    */
330   public void debug(Marker marker, String format, Object arg) {
331     if (!logger.isDebugEnabled())
332       return;
333     if (instanceofLAL) {
334       FormattingTuple ft = MessageFormatter.format(format, arg);
335       ((LocationAwareLogger) logger).log(marker, fqcn,
336           LocationAwareLogger.DEBUG_INT, ft.getMessage(), ft.getArgArray(), ft
337               .getThrowable());
338     } else {
339       logger.debug(marker, format, arg);
340     }
341   }
342 
343   /**
344    * Delegate to the appropriate method of the underlying logger.
345    */
346   public void debug(Marker marker, String format, Object arg1, Object arg2) {
347     if (!logger.isDebugEnabled())
348       return;
349     if (instanceofLAL) {
350       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
351           .getMessage();
352       ((LocationAwareLogger) logger).log(marker, fqcn,
353           LocationAwareLogger.DEBUG_INT, formattedMessage, new Object[] { arg1,
354               arg2 }, null);
355     } else {
356       logger.debug(marker, format, arg1, arg2);
357     }
358   }
359 
360   /**
361    * Delegate to the appropriate method of the underlying logger.
362    */
363   public void debug(Marker marker, String format, Object[] argArray) {
364     if (!logger.isDebugEnabled())
365       return;
366     if (instanceofLAL) {
367 
368       FormattingTuple ft = MessageFormatter.arrayFormat(format, argArray);
369       ((LocationAwareLogger) logger).log(marker, fqcn,
370           LocationAwareLogger.DEBUG_INT, ft.getMessage(), argArray, ft
371               .getThrowable());
372     } else {
373       logger.debug(marker, format, argArray);
374     }
375   }
376 
377   /**
378    * Delegate to the appropriate method of the underlying logger.
379    */
380   public void debug(Marker marker, String msg, Throwable t) {
381     if (!logger.isDebugEnabled())
382       return;
383     if (instanceofLAL) {
384       ((LocationAwareLogger) logger).log(marker, fqcn,
385           LocationAwareLogger.DEBUG_INT, msg, null, t);
386     } else {
387       logger.debug(marker, msg, t);
388     }
389   }
390 
391   /**
392    * Delegate to the appropriate method of the underlying logger.
393    */
394   public boolean isInfoEnabled() {
395     return logger.isInfoEnabled();
396   }
397 
398   /**
399    * Delegate to the appropriate method of the underlying logger.
400    */
401   public boolean isInfoEnabled(Marker marker) {
402     return logger.isInfoEnabled(marker);
403   }
404 
405   /**
406    * Delegate to the appropriate method of the underlying logger.
407    */
408   public void info(String msg) {
409     if (!logger.isInfoEnabled())
410       return;
411 
412     if (instanceofLAL) {
413       ((LocationAwareLogger) logger).log(null, fqcn,
414           LocationAwareLogger.INFO_INT, msg, null, null);
415     } else {
416       logger.info(msg);
417     }
418   }
419 
420   /**
421    * Delegate to the appropriate method of the underlying logger.
422    */
423   public void info(String format, Object arg) {
424     if (!logger.isInfoEnabled())
425       return;
426 
427     if (instanceofLAL) {
428       String formattedMessage = MessageFormatter.format(format, arg)
429           .getMessage();
430       ((LocationAwareLogger) logger).log(null, fqcn,
431           LocationAwareLogger.INFO_INT, formattedMessage, new Object[] { arg },
432           null);
433     } else {
434       logger.info(format, arg);
435     }
436   }
437 
438   /**
439    * Delegate to the appropriate method of the underlying logger.
440    */
441   public void info(String format, Object arg1, Object arg2) {
442     if (!logger.isInfoEnabled())
443       return;
444 
445     if (instanceofLAL) {
446       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
447           .getMessage();
448       ((LocationAwareLogger) logger).log(null, fqcn,
449           LocationAwareLogger.INFO_INT, formattedMessage, new Object[] { arg1,
450               arg2 }, null);
451     } else {
452       logger.info(format, arg1, arg2);
453     }
454   }
455 
456   /**
457    * Delegate to the appropriate method of the underlying logger.
458    */
459   public void info(String format, Object[] argArray) {
460     if (!logger.isInfoEnabled())
461       return;
462 
463     if (instanceofLAL) {
464       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
465           .getMessage();
466       ((LocationAwareLogger) logger).log(null, fqcn,
467           LocationAwareLogger.INFO_INT, formattedMessage, argArray, null);
468     } else {
469       logger.info(format, argArray);
470     }
471   }
472 
473   /**
474    * Delegate to the appropriate method of the underlying logger.
475    */
476   public void info(String msg, Throwable t) {
477     if (!logger.isInfoEnabled())
478       return;
479 
480     if (instanceofLAL) {
481       ((LocationAwareLogger) logger).log(null, fqcn,
482           LocationAwareLogger.INFO_INT, msg, null, t);
483     } else {
484       logger.info(msg, t);
485     }
486   }
487 
488   /**
489    * Delegate to the appropriate method of the underlying logger.
490    */
491   public void info(Marker marker, String msg) {
492     if (!logger.isInfoEnabled())
493       return;
494     if (instanceofLAL) {
495       ((LocationAwareLogger) logger).log(marker, fqcn,
496           LocationAwareLogger.INFO_INT, msg, null, null);
497     } else {
498       logger.info(marker, msg);
499     }
500   }
501 
502   /**
503    * Delegate to the appropriate method of the underlying logger.
504    */
505   public void info(Marker marker, String format, Object arg) {
506     if (!logger.isInfoEnabled())
507       return;
508     if (instanceofLAL) {
509       String formattedMessage = MessageFormatter.format(format, arg)
510           .getMessage();
511       ((LocationAwareLogger) logger).log(marker, fqcn,
512           LocationAwareLogger.INFO_INT, formattedMessage, new Object[] { arg },
513           null);
514     } else {
515       logger.info(marker, format, arg);
516     }
517   }
518 
519   /**
520    * Delegate to the appropriate method of the underlying logger.
521    */
522   public void info(Marker marker, String format, Object arg1, Object arg2) {
523     if (!logger.isInfoEnabled())
524       return;
525     if (instanceofLAL) {
526       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
527           .getMessage();
528       ((LocationAwareLogger) logger).log(marker, fqcn,
529           LocationAwareLogger.INFO_INT, formattedMessage, new Object[] { arg1,
530               arg2 }, null);
531     } else {
532       logger.info(marker, format, arg1, arg2);
533     }
534   }
535 
536   /**
537    * Delegate to the appropriate method of the underlying logger.
538    */
539   public void info(Marker marker, String format, Object[] argArray) {
540     if (!logger.isInfoEnabled())
541       return;
542     if (instanceofLAL) {
543       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
544           .getMessage();
545       ((LocationAwareLogger) logger).log(marker, fqcn,
546           LocationAwareLogger.INFO_INT, formattedMessage, argArray, null);
547     } else {
548       logger.info(marker, format, argArray);
549     }
550   }
551 
552   /**
553    * Delegate to the appropriate method of the underlying logger.
554    */
555   public void info(Marker marker, String msg, Throwable t) {
556     if (!logger.isInfoEnabled())
557       return;
558     if (instanceofLAL) {
559       ((LocationAwareLogger) logger).log(marker, fqcn,
560           LocationAwareLogger.INFO_INT, msg, null, t);
561     } else {
562       logger.info(marker, msg, t);
563     }
564   }
565 
566   public boolean isWarnEnabled() {
567     return logger.isWarnEnabled();
568   }
569 
570   /**
571    * Delegate to the appropriate method of the underlying logger.
572    */
573   public boolean isWarnEnabled(Marker marker) {
574     return logger.isWarnEnabled(marker);
575   }
576 
577   /**
578    * Delegate to the appropriate method of the underlying logger.
579    */
580   public void warn(String msg) {
581     if (!logger.isWarnEnabled())
582       return;
583 
584     if (instanceofLAL) {
585       ((LocationAwareLogger) logger).log(null, fqcn,
586           LocationAwareLogger.WARN_INT, msg, null, null);
587     } else {
588       logger.warn(msg);
589     }
590   }
591 
592   /**
593    * Delegate to the appropriate method of the underlying logger.
594    */
595   public void warn(String format, Object arg) {
596     if (!logger.isWarnEnabled())
597       return;
598 
599     if (instanceofLAL) {
600       String formattedMessage = MessageFormatter.format(format, arg)
601           .getMessage();
602       ((LocationAwareLogger) logger).log(null, fqcn,
603           LocationAwareLogger.WARN_INT, formattedMessage, new Object[] { arg },
604           null);
605     } else {
606       logger.warn(format, arg);
607     }
608   }
609 
610   /**
611    * Delegate to the appropriate method of the underlying logger.
612    */
613   public void warn(String format, Object arg1, Object arg2) {
614     if (!logger.isWarnEnabled())
615       return;
616 
617     if (instanceofLAL) {
618       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
619           .getMessage();
620       ((LocationAwareLogger) logger).log(null, fqcn,
621           LocationAwareLogger.WARN_INT, formattedMessage, new Object[] { arg1,
622               arg2 }, null);
623     } else {
624       logger.warn(format, arg1, arg2);
625     }
626   }
627 
628   /**
629    * Delegate to the appropriate method of the underlying logger.
630    */
631   public void warn(String format, Object[] argArray) {
632     if (!logger.isWarnEnabled())
633       return;
634 
635     if (instanceofLAL) {
636       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
637           .getMessage();
638       ((LocationAwareLogger) logger).log(null, fqcn,
639           LocationAwareLogger.WARN_INT, formattedMessage, argArray, null);
640     } else {
641       logger.warn(format, argArray);
642     }
643   }
644 
645   /**
646    * Delegate to the appropriate method of the underlying logger.
647    */
648   public void warn(String msg, Throwable t) {
649     if (!logger.isWarnEnabled())
650       return;
651 
652     if (instanceofLAL) {
653       ((LocationAwareLogger) logger).log(null, fqcn,
654           LocationAwareLogger.WARN_INT, msg, null, t);
655     } else {
656       logger.warn(msg, t);
657     }
658   }
659 
660   /**
661    * Delegate to the appropriate method of the underlying logger.
662    */
663   public void warn(Marker marker, String msg) {
664     if (!logger.isWarnEnabled())
665       return;
666     if (instanceofLAL) {
667       ((LocationAwareLogger) logger).log(marker, fqcn,
668           LocationAwareLogger.WARN_INT, msg, null, null);
669     } else {
670       logger.warn(marker, msg);
671     }
672   }
673 
674   /**
675    * Delegate to the appropriate method of the underlying logger.
676    */
677   public void warn(Marker marker, String format, Object arg) {
678     if (!logger.isWarnEnabled())
679       return;
680     if (instanceofLAL) {
681       String formattedMessage = MessageFormatter.format(format, arg)
682           .getMessage();
683       ((LocationAwareLogger) logger).log(marker, fqcn,
684           LocationAwareLogger.WARN_INT, formattedMessage, new Object[] { arg },
685           null);
686     } else {
687       logger.warn(marker, format, arg);
688     }
689   }
690 
691   /**
692    * Delegate to the appropriate method of the underlying logger.
693    */
694   public void warn(Marker marker, String format, Object arg1, Object arg2) {
695     if (!logger.isWarnEnabled())
696       return;
697     if (instanceofLAL) {
698       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
699           .getMessage();
700       ((LocationAwareLogger) logger).log(marker, fqcn,
701           LocationAwareLogger.WARN_INT, formattedMessage, new Object[] { arg1,
702               arg2 }, null);
703     } else {
704       logger.warn(marker, format, arg1, arg2);
705     }
706   }
707 
708   /**
709    * Delegate to the appropriate method of the underlying logger.
710    */
711   public void warn(Marker marker, String format, Object[] argArray) {
712     if (!logger.isWarnEnabled())
713       return;
714     if (instanceofLAL) {
715       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
716           .getMessage();
717       ((LocationAwareLogger) logger).log(marker, fqcn,
718           LocationAwareLogger.WARN_INT, formattedMessage, argArray, null);
719     } else {
720       logger.warn(marker, format, argArray);
721     }
722   }
723 
724   /**
725    * Delegate to the appropriate method of the underlying logger.
726    */
727   public void warn(Marker marker, String msg, Throwable t) {
728     if (!logger.isWarnEnabled())
729       return;
730     if (instanceofLAL) {
731       ((LocationAwareLogger) logger).log(marker, fqcn,
732           LocationAwareLogger.WARN_INT, msg, null, t);
733     } else {
734       logger.warn(marker, msg, t);
735     }
736   }
737 
738   /**
739    * Delegate to the appropriate method of the underlying logger.
740    */
741   public boolean isErrorEnabled() {
742     return logger.isErrorEnabled();
743   }
744 
745   /**
746    * Delegate to the appropriate method of the underlying logger.
747    */
748   public boolean isErrorEnabled(Marker marker) {
749     return logger.isErrorEnabled(marker);
750   }
751 
752   /**
753    * Delegate to the appropriate method of the underlying logger.
754    */
755   public void error(String msg) {
756     if (!logger.isErrorEnabled())
757       return;
758 
759     if (instanceofLAL) {
760       ((LocationAwareLogger) logger).log(null, fqcn,
761           LocationAwareLogger.ERROR_INT, msg, null, null);
762     } else {
763       logger.error(msg);
764     }
765   }
766 
767   /**
768    * Delegate to the appropriate method of the underlying logger.
769    */
770   public void error(String format, Object arg) {
771     if (!logger.isErrorEnabled())
772       return;
773 
774     if (instanceofLAL) {
775       String formattedMessage = MessageFormatter.format(format, arg)
776           .getMessage();
777       ((LocationAwareLogger) logger).log(null, fqcn,
778           LocationAwareLogger.ERROR_INT, formattedMessage,
779           new Object[] { arg }, null);
780     } else {
781       logger.error(format, arg);
782     }
783   }
784 
785   /**
786    * Delegate to the appropriate method of the underlying logger.
787    */
788   public void error(String format, Object arg1, Object arg2) {
789     if (!logger.isErrorEnabled())
790       return;
791 
792     if (instanceofLAL) {
793       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
794           .getMessage();
795       ((LocationAwareLogger) logger).log(null, fqcn,
796           LocationAwareLogger.ERROR_INT, formattedMessage, new Object[] { arg1,
797               arg2 }, null);
798     } else {
799       logger.error(format, arg1, arg2);
800     }
801   }
802 
803   /**
804    * Delegate to the appropriate method of the underlying logger.
805    */
806   public void error(String format, Object[] argArray) {
807     if (!logger.isErrorEnabled())
808       return;
809 
810     if (instanceofLAL) {
811       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
812           .getMessage();
813       ((LocationAwareLogger) logger).log(null, fqcn,
814           LocationAwareLogger.ERROR_INT, formattedMessage, argArray, null);
815     } else {
816       logger.error(format, argArray);
817     }
818   }
819 
820   /**
821    * Delegate to the appropriate method of the underlying logger.
822    */
823   public void error(String msg, Throwable t) {
824     if (!logger.isErrorEnabled())
825       return;
826 
827     if (instanceofLAL) {
828       ((LocationAwareLogger) logger).log(null, fqcn,
829           LocationAwareLogger.ERROR_INT, msg, null, t);
830     } else {
831       logger.error(msg, t);
832     }
833   }
834 
835   /**
836    * Delegate to the appropriate method of the underlying logger.
837    */
838   public void error(Marker marker, String msg) {
839     if (!logger.isErrorEnabled())
840       return;
841     if (instanceofLAL) {
842       ((LocationAwareLogger) logger).log(marker, fqcn,
843           LocationAwareLogger.ERROR_INT, msg, null, null);
844     } else {
845       logger.error(marker, msg);
846     }
847   }
848 
849   /**
850    * Delegate to the appropriate method of the underlying logger.
851    */
852   public void error(Marker marker, String format, Object arg) {
853     if (!logger.isErrorEnabled())
854       return;
855     if (instanceofLAL) {
856       String formattedMessage = MessageFormatter.format(format, arg)
857           .getMessage();
858       ((LocationAwareLogger) logger).log(marker, fqcn,
859           LocationAwareLogger.ERROR_INT, formattedMessage,
860           new Object[] { arg }, null);
861     } else {
862       logger.error(marker, format, arg);
863     }
864   }
865 
866   /**
867    * Delegate to the appropriate method of the underlying logger.
868    */
869   public void error(Marker marker, String format, Object arg1, Object arg2) {
870     if (!logger.isErrorEnabled())
871       return;
872     if (instanceofLAL) {
873       String formattedMessage = MessageFormatter.format(format, arg1, arg2)
874           .getMessage();
875       ((LocationAwareLogger) logger).log(marker, fqcn,
876           LocationAwareLogger.ERROR_INT, formattedMessage, new Object[] { arg1,
877               arg2 }, null);
878     } else {
879       logger.error(marker, format, arg1, arg2);
880     }
881   }
882 
883   /**
884    * Delegate to the appropriate method of the underlying logger.
885    */
886   public void error(Marker marker, String format, Object[] argArray) {
887     if (!logger.isErrorEnabled())
888       return;
889     if (instanceofLAL) {
890       String formattedMessage = MessageFormatter.arrayFormat(format, argArray)
891           .getMessage();
892       ((LocationAwareLogger) logger).log(marker, fqcn,
893           LocationAwareLogger.ERROR_INT, formattedMessage, argArray, null);
894     } else {
895       logger.error(marker, format, argArray);
896     }
897   }
898 
899   /**
900    * Delegate to the appropriate method of the underlying logger.
901    */
902   public void error(Marker marker, String msg, Throwable t) {
903     if (!logger.isErrorEnabled())
904       return;
905     if (instanceofLAL) {
906       ((LocationAwareLogger) logger).log(marker, fqcn,
907           LocationAwareLogger.ERROR_INT, msg, null, t);
908     } else {
909       logger.error(marker, msg, t);
910     }
911   }
912 
913   /**
914    * Delegate to the appropriate method of the underlying logger.
915    */
916   public String getName() {
917     return logger.getName();
918   }
919 }