View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.myfaces.trinidad.logging;
20  
21  import java.util.Locale;
22  import java.util.MissingResourceException;
23  import java.util.ResourceBundle;
24  import java.util.logging.Handler;
25  import java.util.logging.Level;
26  import java.util.logging.LogRecord;
27  import java.util.logging.Logger;
28  import org.apache.myfaces.trinidad.util.FastMessageFormat;
29  
30  /**
31   * TrinidadLogger wraps JDK 1.4 logging to provided a large number of 
32   * extra convenience methods.  TrinidadLoggers are created off of
33   * Packages or Classes (not arbitrary names) to force
34   * proper logging hierarchies.
35   *
36   */
37  public class TrinidadLogger 
38  {
39    
40    private TrinidadLogger(Logger log)
41    {
42      if (log == null)
43        throw new IllegalArgumentException(_LOG.getMessage(
44          "LOGGER_REQUIRED"));    
45      _log = log;
46    }
47  
48    /**
49     * Get the Java logger from an Trinidad Logger.
50     * 
51     * @return a java Logger instance
52     */
53    public Logger getLogger()
54    {
55      return _log;
56    }
57  
58    /**
59     * Find or create a logger for a named subsystem.  If a logger has
60     * already been created with the given name it is returned.  Otherwise
61     * a new logger is created.
62     * <p>
63     * If a new logger is created its log level will be configured
64     * based on the LogManager configuration and it will configured
65     * to also send logging output to its parent's handlers.  It will
66     * be registered in the LogManager global namespace.
67     * 
68     * @param name        A name for the logger.  This should
69     *                be a dot-separated name and should normally
70     *                be based on the package name or class name
71     *                of the subsystem, such as java.net
72     *                or javax.swing
73     * @return a suitable Logger
74     */
75    private static TrinidadLogger createTrinidadLogger(String name) 
76    {
77      if (name == null)
78        throw new IllegalArgumentException(_LOG.getMessage(
79          "LOGGER_NAME_REQUIRED"));
80      
81      Logger log;
82  
83      if (name.startsWith("org.apache.myfaces.trinidad."))
84      {
85        log = Logger.getLogger(name, _API_LOGGER_BUNDLE);
86      }
87      else if (name.startsWith("org.apache.myfaces.trinidadinternal."))
88      {
89        log = Logger.getLogger(name, _IMPL_LOGGER_BUNDLE);
90      }
91      else
92      {
93        log = Logger.getLogger(name);
94      }
95      
96      return new TrinidadLogger(log);
97    }
98  
99    /**
100    * Find or create a logger for a named subsystem.  If a logger has 
101    * already been created with the given name it is returned.  Otherwise
102    * a new logger is created.
103    * <p>
104    * If a new logger is created its log level will be configured
105    * based on the LogManager and it will configured to also send logging
106    * output to its parent loggers Handlers.  It will be registered in
107    * the LogManager global namespace.
108    * <p>
109    * If the named Logger already exists and does not yet have a
110    * localization resource bundle then the given resource bundle 
111    * name is used.  If the named Logger already exists and has
112    * a different resource bundle name then an IllegalArgumentException
113    * is thrown.
114    * <p>
115    * @param name    A name for the logger.  This should
116    *                be a dot-separated name and should normally
117    *                be based on the package name or class name
118    *                of the subsystem, such as java.net
119    *                or javax.swing
120    * @param     resourceBundleName  name of ResourceBundle to be used for localizing
121    *                messages for this logger.
122    * @return a suitable Logger
123    * @throws MissingResourceException if the named ResourceBundle cannot be found.
124    * @throws IllegalArgumentException if the Logger already exists and uses
125    *           a different resource bundle name.
126    */
127   private static TrinidadLogger createTrinidadLogger(String name, String resourceBundleName) 
128   {
129     if (name == null)
130       throw new IllegalArgumentException(_LOG.getMessage(
131         "LOGGER_NAME_REQUIRED"));
132    
133     Logger log = Logger.getLogger(name, resourceBundleName);
134 
135     return new TrinidadLogger(log);
136   }
137 
138 
139   /**
140    * Find or create a logger for a named subsystem.  If a logger has
141    * already been created with the given name it is returned.  Otherwise
142    * a new logger is created.
143    * <p>
144    * If a new logger is created its log level will be configured
145    * based on the LogManager configuration and it will configured
146    * to also send logging output to its parent's handlers.  It will
147    * be registered in the LogManager global namespace.
148    * 
149    * @param c       A class instance for the logger.  
150    * @return a suitable Logger
151    */
152   public static TrinidadLogger createTrinidadLogger(Class<?> c) 
153   {
154     if (c == null)
155       throw new IllegalArgumentException(_LOG.getMessage(
156         "CLASS_REQUIRED"));
157     String name = c.getName();
158     return createTrinidadLogger(name);
159   }
160 
161   /**
162    * Find or create a logger for a named subsystem.  If a logger has
163    * already been created with the given name it is returned.  Otherwise
164    * a new logger is created.
165    * <p>
166    * If a new logger is created its log level will be configured
167    * based on the LogManager configuration and it will configured
168    * to also send logging output to its parent's handlers.  It will
169    * be registered in the LogManager global namespace.
170    * 
171    * @param c       A class instance for the logger.  
172    * @param     resourceBundleName  name of ResourceBundle to be used for localizing
173    *                messages for this logger.
174    *        
175    * @return a suitable Logger
176    */
177   public static TrinidadLogger createTrinidadLogger(Class<?> c, String resourceBundleName) 
178   {
179     if (c == null)
180       throw new IllegalArgumentException(_LOG.getMessage(
181         "CLASS_REQUIRED"));
182     String name = c.getName();
183     return createTrinidadLogger(name, resourceBundleName);
184   }
185 
186  /**
187    * Find or create a logger for a named subsystem.  If a logger has
188    * already been created with the given name it is returned.  Otherwise
189    * a new logger is created.
190    * <p>
191    * If a new logger is created its log level will be configured
192    * based on the LogManager configuration and it will configured
193    * to also send logging output to its parent's handlers.  It will
194    * be registered in the LogManager global namespace.
195    * 
196    * @param p       A Package instance for the logger.  
197    * @return a suitable Logger
198    */
199 
200   public static TrinidadLogger createTrinidadLogger(Package p)
201   {
202     if (p == null)
203       throw new IllegalArgumentException(_LOG.getMessage(
204         "PACKAGE_REQUIRED"));
205     String name = p.getName();
206     return createTrinidadLogger(name);
207   }
208 
209 /**
210    * Find or create a logger for a named subsystem.  If a logger has
211    * already been created with the given name it is returned.  Otherwise
212    * a new logger is created.
213    * <p>
214    * If a new logger is created its log level will be configured
215    * based on the LogManager configuration and it will configured
216    * to also send logging output to its parent's handlers.  It will
217    * be registered in the LogManager global namespace.
218    * 
219    * @param p       A Package instance for the logger.  
220    * @param     resourceBundleName  name of ResourceBundle to be used for localizing
221    *                messages for this logger.
222    *        
223    * @return a suitable Logger
224    */
225 
226   public static TrinidadLogger createTrinidadLogger(Package p, String resourceBundleName)
227   {
228     if (p == null)
229       throw new IllegalArgumentException(_LOG.getMessage(
230         "PACKAGE_REQUIRED"));
231     String name = p.getName();
232     return createTrinidadLogger(name, resourceBundleName);
233   }
234 
235   /**
236    * Create an anonymous Logger.  The newly created Logger is not
237    * registered in the LogManager namespace.  There will be no
238    * access checks on updates to the logger.
239    * <p>
240    * This factory method is primarily intended for use from applets.
241    * Because the resulting Logger is anonymous it can be kept private
242    * by the creating class.  This removes the need for normal security
243    * checks, which in turn allows untrusted applet code to update
244    * the control state of the Logger.  For example an applet can do
245    * a setLevel or an addHandler on an anonymous Logger.
246    * <p>
247    * Even although the new logger is anonymous, it is configured
248    * to have the root logger ("") as its parent.  This means that
249    * by default it inherits its effective level and handlers
250    * from the root logger.
251    * <p>
252    *
253    * @return a newly created private Logger
254    */
255   public static TrinidadLogger getAnonymousLogger() 
256   {
257     return new TrinidadLogger(Logger.getAnonymousLogger());    
258   }
259 
260   /**
261    * Create an anonymous Logger.  The newly created Logger is not
262    * registered in the LogManager namespace.  There will be no
263    * access checks on updates to the logger.
264    * <p>
265    * This factory method is primarily intended for use from applets.
266    * Because the resulting Logger is anonymous it can be kept private
267    * by the creating class.  This removes the need for normal security
268    * checks, which in turn allows untrusted applet code to update
269    * the control state of the Logger.  For example an applet can do
270    * a setLevel or an addHandler on an anonymous Logger.
271    * <p>
272    * Even although the new logger is anonymous, it is configured
273    * to have the root logger ("") as its parent.  This means that
274    * by default it inherits its effective level and handlers
275    * from the root logger.
276    * <p>
277    * @param     resourceBundleName  name of ResourceBundle to be used for localizing
278    *                messages for this logger.
279    * @return a newly created private Logger
280    * @throws MissingResourceException if the named ResourceBundle cannot be found.
281    */
282   public static TrinidadLogger getAnonymousLogger(String resourceBundleName) 
283   {
284     return new TrinidadLogger(Logger.getAnonymousLogger(resourceBundleName));
285   }
286 
287 
288   /**
289    * Log a LogRecord.
290    * <p>
291    * All the other logging methods in this class call through
292    * this method to actually perform any logging.  Subclasses can
293    * override this single method to capture all log activity.
294    *
295    * @param record the LogRecord to be published
296    */
297   public void log(LogRecord record) 
298   {
299     _log.log(record);
300   }
301 
302 
303   //================================================================
304   // Start of convenience methods WITHOUT className and methodName
305   //================================================================
306 
307   /**
308    * Log a message, with no arguments.
309    * <p>
310    * If the logger is currently enabled for the given message 
311    * level then the given message is forwarded to all the
312    * registered output Handler objects.
313    * <p>
314    * @param   msg   The string message (or a key in the message catalog)
315    */
316   public void log(String msg) 
317   {
318     log(Level.FINE, msg);
319   }
320 
321   /**
322    * Log a message, with no arguments.
323    * <p>
324    * If the logger is currently enabled for the given message 
325    * level then the given message is forwarded to all the
326    * registered output Handler objects.
327    * <p>
328    * @param level   One of the message level identifiers, e.g. SEVERE
329    * @param   msg   The string message (or a key in the message catalog)
330    */
331   public void log(Level level, String msg) 
332   {
333     if (isLoggable(level))
334     {
335       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
336       doLog(lr);  
337     }
338   }
339 
340   /**
341    * Log a message, with one object parameter.
342    * <p>
343    * If the logger is currently enabled for the given message 
344    * level then a corresponding LogRecord is created and forwarded 
345    * to all the registered output Handler objects.
346    * <p>
347    * @param level   One of the message level identifiers, e.g. SEVERE
348    * @param   msg   The string message (or a key in the message catalog)
349    * @param   param1    parameter to the message
350    */
351   public void log(Level level, String msg, Object param1) 
352   {
353     if (isLoggable(level))
354     {
355       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
356       Object params[] = { param1};
357       lr.setParameters(params);
358       doLog(lr);  
359     }
360   }
361 
362   /**
363    * Log a message, with an array of object arguments.
364    * <p>
365    * If the logger is currently enabled for the given message 
366    * level then a corresponding LogRecord is created and forwarded 
367    * to all the registered output Handler objects.
368    * <p>
369    * @param level   One of the message level identifiers, e.g. SEVERE
370    * @param   msg   The string message (or a key in the message catalog)
371    * @param   params    array of parameters to the message
372    */
373   public void log(Level level, String msg, Object params[]) 
374   {
375     if (isLoggable(level))
376     {
377       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
378       lr.setParameters(params);
379       doLog(lr);  
380     }
381   }
382 
383   /**
384    * Log a message, with associated Throwable information.
385    * <p>
386    * If the logger is currently enabled for the given message 
387    * level then the given arguments are stored in a LogRecord
388    * which is forwarded to all registered output handlers.
389    * <p>
390    * Note that the thrown argument is stored in the LogRecord thrown
391    * property, rather than the LogRecord parameters property.  Thus is it
392    * processed specially by output Formatters and is not treated
393    * as a formatting parameter to the LogRecord message property.
394    * <p>
395    * @param level   One of the message level identifiers, e.g. SEVERE
396    * @param   msg   The string message (or a key in the message catalog)
397    * @param   thrown  Throwable associated with log message.
398    */
399   public void log(Level level, String msg, Throwable thrown) 
400   {
401     if (isLoggable(level))
402     {
403       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
404       lr.setThrown(thrown);
405       doLog(lr);  
406     }
407   }
408 
409   //================================================================
410   // Start of convenience methods WITH className and methodName
411   //================================================================
412 
413   /**
414    * Log a message, specifying source class and method,
415    * with no arguments.
416    * <p>
417    * If the logger is currently enabled for the given message 
418    * level then the given message is forwarded to all the
419    * registered output Handler objects.
420    * <p>
421    * @param level   One of the message level identifiers, e.g. SEVERE
422    * @param   sourceClass    name of class that issued the logging request
423    * @param   sourceMethod   name of method that issued the logging request
424    * @param   msg   The string message (or a key in the message catalog)
425    */
426   public void logp(Level level, String sourceClass, String sourceMethod, String msg) 
427   {
428     if (isLoggable(level))
429     {
430       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
431       lr.setSourceClassName(sourceClass);
432       lr.setSourceMethodName(sourceMethod);
433       doLog(lr);  
434     }
435   }
436 
437   /**
438    * Log a message, specifying source class and method,
439    * with a single object parameter to the log message.
440    * <p>
441    * If the logger is currently enabled for the given message 
442    * level then a corresponding LogRecord is created and forwarded 
443    * to all the registered output Handler objects.
444    * <p>
445    * @param level   One of the message level identifiers, e.g. SEVERE
446    * @param   sourceClass    name of class that issued the logging request
447    * @param   sourceMethod   name of method that issued the logging request
448    * @param   msg    The string message (or a key in the message catalog)
449    * @param   param1    Parameter to the log message.
450    */
451   public void logp(Level level, String sourceClass, String sourceMethod,
452                    String msg, Object param1) 
453   {
454     if (isLoggable(level))
455     {
456       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
457       lr.setSourceClassName(sourceClass);
458       lr.setSourceMethodName(sourceMethod);
459       Object params[] = { param1};
460       lr.setParameters(params);
461       doLog(lr);  
462     }
463   }
464 
465   /**
466    * Log a message, specifying source class and method,
467    * with an array of object arguments.
468    * <p>
469    * If the logger is currently enabled for the given message 
470    * level then a corresponding LogRecord is created and forwarded 
471    * to all the registered output Handler objects.
472    * <p>
473    * @param level   One of the message level identifiers, e.g. SEVERE
474    * @param   sourceClass    name of class that issued the logging request
475    * @param   sourceMethod   name of method that issued the logging request
476    * @param   msg   The string message (or a key in the message catalog)
477    * @param   params    Array of parameters to the message
478    */
479   public void logp(Level level, String sourceClass, String sourceMethod,
480                    String msg, Object params[]) 
481   {
482     if (isLoggable(level))
483     {
484       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
485       lr.setSourceClassName(sourceClass);
486       lr.setSourceMethodName(sourceMethod);
487       lr.setParameters(params);
488       doLog(lr);  
489     }
490   }
491 
492   /**
493    * Log a message, specifying source class and method,
494    * with associated Throwable information.
495    * <p>
496    * If the logger is currently enabled for the given message 
497    * level then the given arguments are stored in a LogRecord
498    * which is forwarded to all registered output handlers.
499    * <p>
500    * Note that the thrown argument is stored in the LogRecord thrown
501    * property, rather than the LogRecord parameters property.  Thus is it
502    * processed specially by output Formatters and is not treated
503    * as a formatting parameter to the LogRecord message property.
504    * <p>
505    * @param level   One of the message level identifiers, e.g. SEVERE
506    * @param   sourceClass    name of class that issued the logging request
507    * @param   sourceMethod   name of method that issued the logging request
508    * @param   msg   The string message (or a key in the message catalog)
509    * @param   thrown  Throwable associated with log message.
510    */
511   public void logp(Level level, String sourceClass, String sourceMethod,
512                    String msg, Throwable thrown) 
513   {
514     if (isLoggable(level))
515     {
516       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
517       lr.setSourceClassName(sourceClass);
518       lr.setSourceMethodName(sourceMethod);
519       lr.setThrown(thrown);
520       doLog(lr);  
521     }
522   }
523 
524 
525   /**
526    * Log a message, specifying source class, method, and resource bundle name
527    * with no arguments.
528    * <p>
529    * If the logger is currently enabled for the given message 
530    * level then the given message is forwarded to all the
531    * registered output Handler objects.
532    * <p>
533    * The msg string is localized using the named resource bundle.  If the
534    * resource bundle name is null, then the msg string is not localized.
535    * <p>
536    * @param level   One of the message level identifiers, e.g. SEVERE
537    * @param   sourceClass    name of class that issued the logging request
538    * @param   sourceMethod   name of method that issued the logging request
539    * @param   bundleName     name of resource bundle to localize msg
540    * @param   msg   The string message (or a key in the message catalog)
541    * @throws  MissingResourceException if no suitable ResourceBundle can
542    *        be found.
543    */
544 
545   public void logrb(Level level, String sourceClass, String sourceMethod, 
546                     String bundleName, String msg) 
547   {
548     if (isLoggable(level))
549     {
550       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
551       lr.setSourceClassName(sourceClass);
552       lr.setSourceMethodName(sourceMethod);
553       doLog(lr,bundleName);  
554     }
555   }
556 
557   /**
558    * Log a message, specifying source class, method, and resource bundle name,
559    * with a single object parameter to the log message.
560    * <p>
561    * If the logger is currently enabled for the given message 
562    * level then a corresponding LogRecord is created and forwarded 
563    * to all the registered output Handler objects.
564    * <p>
565    * The msg string is localized using the named resource bundle.  If the
566    * resource bundle name is null, then the msg string is not localized.
567    * <p>
568    * @param level   One of the message level identifiers, e.g. SEVERE
569    * @param   sourceClass    name of class that issued the logging request
570    * @param   sourceMethod   name of method that issued the logging request
571    * @param   bundleName     name of resource bundle to localize msg
572    * @param   msg    The string message (or a key in the message catalog)
573    * @param   param1    Parameter to the log message.
574    * @throws  MissingResourceException if no suitable ResourceBundle can
575    *        be found.
576    */
577   public void logrb(Level level, String sourceClass, String sourceMethod,
578                     String bundleName, String msg, Object param1) 
579   {
580     if (isLoggable(level))
581     {
582       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
583       lr.setSourceClassName(sourceClass);
584       lr.setSourceMethodName(sourceMethod);
585       Object params[] = { param1};
586       lr.setParameters(params);
587       doLog(lr,bundleName);  
588     }
589   }
590 
591   /**
592    * Log a message, specifying source class, method, and resource bundle name,
593    * with an array of object arguments.
594    * <p>
595    * If the logger is currently enabled for the given message 
596    * level then a corresponding LogRecord is created and forwarded 
597    * to all the registered output Handler objects.
598    * <p>
599    * The msg string is localized using the named resource bundle.  If the
600    * resource bundle name is null, then the msg string is not localized.
601    * <p>
602    * @param level   One of the message level identifiers, e.g. SEVERE
603    * @param   sourceClass    name of class that issued the logging request
604    * @param   sourceMethod   name of method that issued the logging request
605    * @param   bundleName     name of resource bundle to localize msg
606    * @param   msg   The string message (or a key in the message catalog)
607    * @param   params    Array of parameters to the message
608    * @throws  MissingResourceException if no suitable ResourceBundle can
609    *        be found.
610    */
611   public void logrb(Level level, String sourceClass, String sourceMethod,
612                     String bundleName, String msg, Object params[]) 
613   {
614     if (isLoggable(level))
615     {
616       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
617       lr.setSourceClassName(sourceClass);
618       lr.setSourceMethodName(sourceMethod);
619       lr.setParameters(params);
620       doLog(lr,bundleName);  
621     }
622   }
623 
624   /**
625    * Log a message, specifying source class, method, and resource bundle name,
626    * with associated Throwable information.
627    * <p>
628    * If the logger is currently enabled for the given message 
629    * level then the given arguments are stored in a LogRecord
630    * which is forwarded to all registered output handlers.
631    * <p>
632    * The msg string is localized using the named resource bundle.  If the
633    * resource bundle name is null, then the msg string is not localized.
634    * <p>
635    * Note that the thrown argument is stored in the LogRecord thrown
636    * property, rather than the LogRecord parameters property.  Thus is it
637    * processed specially by output Formatters and is not treated
638    * as a formatting parameter to the LogRecord message property.
639    * <p>
640    * @param level   One of the message level identifiers, e.g. SEVERE
641    * @param   sourceClass    name of class that issued the logging request
642    * @param   sourceMethod   name of method that issued the logging request
643    * @param   bundleName     name of resource bundle to localize msg
644    * @param   msg   The string message (or a key in the message catalog)
645    * @param   thrown  Throwable associated with log message.
646    * @throws  MissingResourceException if no suitable ResourceBundle can
647    *        be found.
648    */
649   public void logrb(Level level, String sourceClass, String sourceMethod,
650                     String bundleName, String msg, Throwable thrown) 
651   {
652     if (isLoggable(level))
653     {
654       TrinidadLogRecord lr = new TrinidadLogRecord(level, msg);
655       lr.setSourceClassName(sourceClass);
656       lr.setSourceMethodName(sourceMethod);
657       lr.setThrown(thrown);
658       doLog(lr,bundleName);  
659     }
660   }
661 
662 
663   //======================================================================
664   // Start of convenience methods for logging method entries and returns.
665   //======================================================================
666 
667   /**
668    * Log a method entry.
669    * <p>
670    * This is a convenience method that can be used to log entry
671    * to a method.  A LogRecord with message "ENTRY", log level
672    * FINER, and the given sourceMethod and sourceClass is logged.
673    * <p>
674    * @param   sourceClass    name of class that issued the logging request
675    * @param   sourceMethod   name of method that is being entered
676    */
677   public void entering(String sourceClass, String sourceMethod) 
678   {
679     _log.entering(sourceClass, sourceMethod);
680   }
681 
682   /**
683    * Log a method entry, with one parameter.
684    * <p>
685    * This is a convenience method that can be used to log entry
686    * to a method.  A LogRecord with message "ENTRY {0}", log level
687    * FINER, and the given sourceMethod, sourceClass, and parameter
688    * is logged.
689    * <p>
690    * @param   sourceClass    name of class that issued the logging request
691    * @param   sourceMethod   name of method that is being entered
692    * @param   param1           parameter to the method being entered
693    */
694   public void entering(String sourceClass, String sourceMethod, Object param1) 
695   {
696     _log.entering(sourceClass, sourceMethod, param1);
697   }
698 
699   /**
700    * Log a method entry, with an array of parameters.
701    * <p>
702    * This is a convenience method that can be used to log entry
703    * to a method.  A LogRecord with message "ENTRY" (followed by a 
704    * format {N} indicator for each entry in the parameter array), 
705    * log level FINER, and the given sourceMethod, sourceClass, and 
706    * parameters is logged.
707    * <p>
708    * @param   sourceClass    name of class that issued the logging request
709    * @param   sourceMethod   name of method that is being entered
710    * @param   params           array of parameters to the method being entered
711    */
712   public void entering(String sourceClass, String sourceMethod, Object params[]) 
713   {
714     _log.entering(sourceClass, sourceMethod, params);
715   }
716 
717   /**
718    * Log a method return.
719    * <p>
720    * This is a convenience method that can be used to log returning
721    * from a method.  A LogRecord with message "RETURN", log level
722    * FINER, and the given sourceMethod and sourceClass is logged.
723    * <p>
724    * @param   sourceClass    name of class that issued the logging request
725    * @param   sourceMethod   name of the method 
726    */
727   public void exiting(String sourceClass, String sourceMethod) 
728   {
729     _log.exiting(sourceClass, sourceMethod);
730   }
731 
732 
733   /**
734    * Log a method return, with result object.
735    * <p>
736    * This is a convenience method that can be used to log returning
737    * from a method.  A LogRecord with message "RETURN {0}", log level
738    * FINER, and the gives sourceMethod, sourceClass, and result
739    * object is logged.
740    * <p>
741    * @param   sourceClass    name of class that issued the logging request
742    * @param   sourceMethod   name of the method 
743    * @param   result  Object that is being returned
744    */
745   public void exiting(String sourceClass, String sourceMethod, Object result) 
746   {
747     _log.exiting(sourceClass, sourceMethod, result);
748   }
749 
750   /**
751    * Log throwing an exception.
752    * <p>
753    * This is a convenience method to log that a method is
754    * terminating by throwing an exception.  The logging is done 
755    * using the FINER level.
756    * <p>
757    * If the logger is currently enabled for the given message 
758    * level then the given arguments are stored in a LogRecord
759    * which is forwarded to all registered output handlers.  The
760    * LogRecord's message is set to "THROW".
761    * <p>
762    * Note that the thrown argument is stored in the LogRecord thrown
763    * property, rather than the LogRecord parameters property.  Thus is it
764    * processed specially by output Formatters and is not treated
765    * as a formatting parameter to the LogRecord message property.
766    * <p>
767    * @param   sourceClass    name of class that issued the logging request
768    * @param   sourceMethod  name of the method.
769    * @param   thrown  The Throwable that is being thrown.
770    */
771   public void throwing(String sourceClass, String sourceMethod, Throwable thrown) 
772   {
773     _log.throwing(sourceClass, sourceMethod, thrown);
774   }
775 
776   //=======================================================================
777   // Start of simple convenience methods using level names as method names
778   //=======================================================================
779 
780   /**
781    * Log a SEVERE message.
782    * <p>
783    * If the logger is currently enabled for the SEVERE message 
784    * level then the given message is forwarded to all the
785    * registered output Handler objects.
786    * <p>
787    * @param   msg   The string message (or a key in the message catalog)
788    */
789   public void severe(String msg) 
790   {
791     //_log.severe(msg);
792     log(Level.SEVERE,msg);
793   }
794 
795   /**
796    * Log a WARNING message.
797    * <p>
798    * If the logger is currently enabled for the WARNING message 
799    * level then the given message is forwarded to all the
800    * registered output Handler objects.
801    * <p>
802    * @param   msg   The string message (or a key in the message catalog)
803    */
804   public void warning(String msg) 
805   {
806     //_log.warning(msg);
807     log(Level.WARNING,msg);
808   }
809 
810   /**
811    * Log an INFO message.
812    * <p>
813    * If the logger is currently enabled for the INFO message 
814    * level then the given message is forwarded to all the
815    * registered output Handler objects.
816    * <p>
817    * @param   msg   The string message (or a key in the message catalog)
818    */
819   public void info(String msg) 
820   {
821     //_log.info(msg);
822     log(Level.INFO,msg);
823   }
824 
825   /**
826    * Log a CONFIG message.
827    * <p>
828    * If the logger is currently enabled for the CONFIG message 
829    * level then the given message is forwarded to all the
830    * registered output Handler objects.
831    * <p>
832    * @param   msg   The string message (or a key in the message catalog)
833    */
834   public void config(String msg) 
835   {
836     //_log.config(msg);
837     log(Level.CONFIG,msg);
838   }
839 
840   /**
841    * Log a FINE message.
842    * <p>
843    * If the logger is currently enabled for the FINE message 
844    * level then the given message is forwarded to all the
845    * registered output Handler objects.
846    * <p>
847    * @param   msg   The string message (or a key in the message catalog)
848    */
849   public void fine(String msg) 
850   {
851     //_log.fine(msg);
852     log(Level.FINE,msg);
853   }
854 
855   /**
856    * Log a FINER message.
857    * <p>
858    * If the logger is currently enabled for the FINER message 
859    * level then the given message is forwarded to all the
860    * registered output Handler objects.
861    * <p>
862    * @param   msg   The string message (or a key in the message catalog)
863    */
864   public void finer(String msg) 
865   {
866     //_log.finer(msg);
867     log(Level.FINER,msg);
868   }
869 
870   /**
871    * Log a FINEST message.
872    * <p>
873    * If the logger is currently enabled for the FINEST message 
874    * level then the given message is forwarded to all the
875    * registered output Handler objects.
876    * <p>
877    * @param   msg   The string message (or a key in the message catalog)
878    */
879   public void finest(String msg) 
880   {
881     //_log.finest(msg);
882     log(Level.FINEST,msg);
883   }
884 
885   /**
886     * Log throwing an exception.
887     * 
888     * Comparing to Java Logging function
889     * 
890     *     Logger.throwing(sourceClass, sourceMethod, thrown) 
891     * 
892     * this function takes one more parameter "level" so that developers can 
893     * specify the logging level of an exception. Developers should pass value
894     * for the "level" parameter using following convention,
895     * <p>
896     * Level.SEVERE -- Serious exceptions or error conditions such that an 
897     * application can no longer run.
898     * <p>
899     * Level.WARNING -- Exceptions or errors that are not fatal, but an 
900     * application will run with some problems.
901     * <p>
902     * 
903     * @param level Java Logging level
904     * @param sourceClass name of class that issued the logging request
905     * @param sourceMethod name of the method
906     * @param thrown The Throwable that is being thrown
907     */
908   public void throwing(
909                       Level  level,
910                       String sourceClass,
911                       String sourceMethod,
912                       Throwable thrown
913                       )
914   {
915     logp(level, sourceClass, sourceMethod, null, thrown);
916   }
917 
918   /**
919    * Log a SEVERE message, with no arguments.
920    * <p>
921    * The message is forwarded to appropriate Java Logger objects. 
922    * <p>
923    * @param sourceClass  the name of the class that issued the logging request 
924    * @param sourceMethod the name of the method that issued the logging request 
925    * @param msg          the string message (or a key in the resource bundle)
926    */
927   public void severe(
928                     String sourceClass,
929                     String sourceMethod,
930                     String msg
931                     )
932   {
933     logp(Level.SEVERE, sourceClass, sourceMethod, msg);
934   }
935 
936   /**
937    * Log a SEVERE message, with one object parameter.
938    * <p>
939    * The message is forwarded to appropriate Java Logger objects. 
940    * <p>
941    * @param sourceClass  the name of the class that issued the logging request 
942    * @param sourceMethod the name of the method that issued the logging request 
943    * @param msg          the string message (or a key in the resource bundle)
944    * @param param1       a parameter to the message
945    */
946   public void severe(
947                     String sourceClass,
948                     String sourceMethod,
949                     String msg,
950                     Object param1
951                     )
952   {
953     logp(Level.SEVERE, sourceClass, sourceMethod, msg, param1);
954   }
955 
956   /**
957    * Log a SEVERE message, with an array of object arguments.
958    * <p>
959    * The message is forwarded to appropriate Java Logger objects. 
960    * <p>
961    * @param sourceClass  the name of the class that issued the logging request 
962    * @param sourceMethod the name of the method that issued the logging request 
963    * @param msg          the string message (or a key in the resource bundle)
964    * @param params       an array of parameters to the message
965    */
966   public void severe(
967                     String sourceClass,
968                     String sourceMethod,
969                     String msg,
970                     Object[] params
971                     )
972   {
973     logp(Level.SEVERE, sourceClass, sourceMethod, msg, params);
974   }
975 
976   /**
977    * Log a WARNING message, with no arguments.
978    * <p>
979    * The message is forwarded to appropriate Java Logger objects. 
980    * <p>
981    * @param sourceClass  the name of the class that issued the logging request 
982    * @param sourceMethod the name of the method that issued the logging request 
983    * @param msg          the string message (or a key in the resource bundle)
984    */
985   public void warning(
986                      String sourceClass,
987                      String sourceMethod,
988                      String msg
989                      )
990   {
991     logp(Level.WARNING, sourceClass, sourceMethod, msg);
992   }
993 
994   /**
995    * Log a WARNING message, with one object parameter.
996    * <p>
997    * The message is forwarded to appropriate Java Logger objects. 
998    * <p>
999    * @param sourceClass  the name of the class that issued the logging request 
1000    * @param sourceMethod the name of the method that issued the logging request 
1001    * @param msg          the string message (or a key in the resource bundle)
1002    * @param param1       a parameter to the message
1003    */
1004   public void warning(
1005                      String sourceClass,
1006                      String sourceMethod,
1007                      String msg,
1008                      Object param1
1009                      )
1010   {
1011     logp(Level.WARNING, sourceClass, sourceMethod, msg, param1);
1012   }
1013 
1014   /**
1015    * Log a WARNING message, with an array of object arguments.
1016    * <p>
1017    * The message is forwarded to appropriate Java Logger objects. 
1018    * <p>
1019    * @param sourceClass  the name of the class that issued the logging request 
1020    * @param sourceMethod the name of the method that issued the logging request 
1021    * @param msg          the string message (or a key in the resource bundle)
1022    * @param params       an array of parameters to the message
1023    */
1024   public void warning(
1025                      String sourceClass,
1026                      String sourceMethod,
1027                      String msg,
1028                      Object[] params
1029                      )
1030   {
1031     logp(Level.WARNING, sourceClass, sourceMethod, msg, params);
1032   }
1033 
1034   /**
1035    * Log a INFO message, with no arguments.
1036    * <p>
1037    * The message is forwarded to appropriate Java Logger objects. 
1038    * <p>
1039    * @param sourceClass  the name of the class that issued the logging request 
1040    * @param sourceMethod the name of the method that issued the logging request 
1041    * @param msg          the string message (or a key in the resource bundle)
1042    */
1043   public void info(
1044                   String sourceClass,
1045                   String sourceMethod,
1046                   String msg
1047                   )
1048   {
1049     logp(Level.INFO, sourceClass, sourceMethod, msg);
1050   }
1051 
1052   /**
1053    * Log a INFO message, with one object parameter.
1054    * <p>
1055    * The message is forwarded to appropriate Java Logger objects. 
1056    * <p>
1057    * @param sourceClass  the name of the class that issued the logging request 
1058    * @param sourceMethod the name of the method that issued the logging request 
1059    * @param msg          the string message (or a key in the resource bundle)
1060    * @param param1       a parameter to the message
1061    */
1062   public void info(
1063                   String sourceClass,
1064                   String sourceMethod,
1065                   String msg,
1066                   Object param1
1067                   )
1068   {
1069     logp(Level.INFO, sourceClass, sourceMethod, msg, param1);
1070   }
1071 
1072   /**
1073    * Log a INFO message, with an array of object arguments.
1074    * <p>
1075    * The message is forwarded to appropriate Java Logger objects. 
1076    * <p>
1077    * @param sourceClass  the name of the class that issued the logging request 
1078    * @param sourceMethod the name of the method that issued the logging request 
1079    * @param msg          the string message (or a key in the resource bundle)
1080    * @param params       an array of parameters to the message
1081    */
1082   public void info(
1083                   String sourceClass,
1084                   String sourceMethod,
1085                   String msg,
1086                   Object[] params
1087                   )
1088   {
1089     logp(Level.INFO, sourceClass, sourceMethod, msg, params);
1090   }
1091 
1092   /**
1093    * Log a CONFIG message, with no arguments.
1094    * <p>
1095    * The message is forwarded to appropriate Java Logger objects. 
1096    * <p>
1097    * @param sourceClass  the name of the class that issued the logging request 
1098    * @param sourceMethod the name of the method that issued the logging request 
1099    * @param msg          the string message (or a key in the resource bundle)
1100    */
1101   public void config(
1102                     String sourceClass,
1103                     String sourceMethod,
1104                     String msg
1105                     )
1106   {
1107     logp(Level.CONFIG, sourceClass, sourceMethod, msg);
1108   }
1109 
1110   /**
1111    * Log a CONFIG message, with one object parameter.
1112    * <p>
1113    * The message is forwarded to appropriate Java Logger objects. 
1114    * <p>
1115    * @param sourceClass  the name of the class that issued the logging request 
1116    * @param sourceMethod the name of the method that issued the logging request 
1117    * @param msg          the string message (or a key in the resource bundle)
1118    * @param param1       a parameter to the message
1119    */
1120   public void config(
1121                     String sourceClass,
1122                     String sourceMethod,
1123                     String msg,
1124                     Object param1
1125                     )
1126   {
1127     _log.logp(Level.CONFIG, sourceClass, sourceMethod, msg, param1);
1128   }
1129 
1130   /**
1131    * Log a CONFIG message, with an array of object arguments.
1132    * <p>
1133    * The message is forwarded to appropriate Java Logger objects. 
1134    * <p>
1135    * @param sourceClass  the name of the class that issued the logging request 
1136    * @param sourceMethod the name of the method that issued the logging request 
1137    * @param msg          the string message (or a key in the resource bundle)
1138    * @param params       an array of parameters to the message
1139    */
1140   public void config(
1141                     String sourceClass,
1142                     String sourceMethod,
1143                     String msg,
1144                     Object[] params
1145                     )
1146   {
1147     logp(Level.CONFIG, sourceClass, sourceMethod, msg, params);
1148   }
1149 
1150   /**
1151    * Log a FINE message, with no arguments.
1152    * <p>
1153    * The message is forwarded to appropriate Java Logger objects. 
1154    * <p>
1155    * @param sourceClass  the name of the class that issued the logging request 
1156    * @param sourceMethod the name of the method that issued the logging request 
1157    * @param msg          the string message (or a key in the resource bundle)
1158    */
1159   public void fine(
1160                   String sourceClass,
1161                   String sourceMethod,
1162                   String msg
1163                   )
1164   {
1165     logp(Level.FINE, sourceClass, sourceMethod, msg);
1166   }
1167 
1168   /**
1169    * Log a FINE message, with one object parameter.
1170    * <p>
1171    * The message is forwarded to appropriate Java Logger objects. 
1172    * <p>
1173    * @param sourceClass  the name of the class that issued the logging request 
1174    * @param sourceMethod the name of the method that issued the logging request 
1175    * @param msg          the string message (or a key in the resource bundle)
1176    * @param param1       a parameter to the message
1177    */
1178   public void fine(
1179                   String sourceClass,
1180                   String sourceMethod,
1181                   String msg,
1182                   Object param1
1183                   )
1184   {
1185     logp(Level.FINE, sourceClass, sourceMethod, msg, param1);
1186   }
1187 
1188   /**
1189    * Log a FINE message, with an array of object arguments.
1190    * <p>
1191    * The message is forwarded to appropriate Java Logger objects. 
1192    * <p>
1193    * @param sourceClass  the name of the class that issued the logging request 
1194    * @param sourceMethod the name of the method that issued the logging request 
1195    * @param msg          the string message (or a key in the resource bundle)
1196    * @param params       an array of parameters to the message
1197    */
1198   public void fine(
1199                   String sourceClass,
1200                   String sourceMethod,
1201                   String msg,
1202                   Object[] params
1203                   )
1204   {
1205     logp(Level.FINE, sourceClass, sourceMethod, msg, params);
1206   }
1207 
1208   /**
1209    * Log a FINER message, with no arguments.
1210    * <p>
1211    * The message is forwarded to appropriate Java Logger objects. 
1212    * <p>
1213    * @param sourceClass  the name of the class that issued the logging request 
1214    * @param sourceMethod the name of the method that issued the logging request 
1215    * @param msg          the string message (or a key in the resource bundle)
1216    */
1217   public void finer(
1218                    String sourceClass,
1219                    String sourceMethod,
1220                    String msg
1221                    )
1222   {
1223     logp(Level.FINER, sourceClass, sourceMethod, msg);
1224   }
1225 
1226   /**
1227    * Log a FINER message, with one object parameter.
1228    * <p>
1229    * The message is forwarded to appropriate Java Logger objects. 
1230    * <p>
1231    * @param sourceClass  the name of the class that issued the logging request 
1232    * @param sourceMethod the name of the method that issued the logging request 
1233    * @param msg          the string message (or a key in the resource bundle)
1234    * @param param1       a parameter to the message
1235    */
1236   public void finer(
1237                    String sourceClass,
1238                    String sourceMethod,
1239                    String msg,
1240                    Object param1
1241                    )
1242   {
1243     logp(Level.FINER, sourceClass, sourceMethod, msg, param1);
1244   }
1245 
1246   /**
1247    * Log a FINER message, with an array of object arguments.
1248    * <p>
1249    * The message is forwarded to appropriate Java Logger objects. 
1250    * <p>
1251    * @param sourceClass  the name of the class that issued the logging request 
1252    * @param sourceMethod the name of the method that issued the logging request 
1253    * @param msg          the string message (or a key in the resource bundle)
1254    * @param params       an array of parameters to the message
1255    */
1256   public void finer(
1257                    String sourceClass,
1258                    String sourceMethod,
1259                    String msg,
1260                    Object[] params
1261                    )
1262   {
1263     logp(Level.FINER, sourceClass, sourceMethod, msg, params);
1264   }
1265 
1266   /**
1267    * Log a FINEST message, with no arguments.
1268    * <p>
1269    * The message is forwarded to appropriate Java Logger objects. 
1270    * <p>
1271    * @param sourceClass  the name of the class that issued the logging request 
1272    * @param sourceMethod the name of the method that issued the logging request 
1273    * @param msg          the string message (or a key in the resource bundle)
1274    */
1275   public void finest(
1276                     String sourceClass,
1277                     String sourceMethod,
1278                     String msg
1279                     )
1280   {
1281     logp(Level.FINEST, sourceClass, sourceMethod, msg);
1282   }
1283 
1284   /**
1285    * Log a FINEST message, with one object parameter.
1286    * <p>
1287    * The message is forwarded to appropriate Java Logger objects. 
1288    * <p>
1289    * @param sourceClass  the name of the class that issued the logging request 
1290    * @param sourceMethod the name of the method that issued the logging request 
1291    * @param msg          the string message (or a key in the resource bundle)
1292    * @param param1       a parameter to the message
1293    */
1294   public void finest(
1295                     String sourceClass,
1296                     String sourceMethod,
1297                     String msg,
1298                     Object param1
1299                     )
1300   {
1301     logp(Level.FINEST, sourceClass, sourceMethod, msg, param1);
1302   }
1303 
1304   /**
1305    * Log a FINEST message, with an array of object arguments.
1306    * <p>
1307    * The message is forwarded to appropriate Java Logger objects. 
1308    * <p>
1309    * @param sourceClass  the name of the class that issued the logging request 
1310    * @param sourceMethod the name of the method that issued the logging request 
1311    * @param msg          the string message (or a key in the resource bundle)
1312    * @param params       an array of parameters to the message
1313    */
1314   public void finest(
1315                     String sourceClass,
1316                     String sourceMethod,
1317                     String msg,
1318                     Object[] params
1319                     )
1320   {
1321     logp(Level.FINEST, sourceClass, sourceMethod, msg, params);
1322   }
1323 
1324   /**
1325    * Log a message, with an list of object arguments.
1326    * <p>
1327    * The message is forwarded to appropriate Java Logger objects. 
1328    * <p>
1329    * @param sourceClass  the name of the class that issued the logging request 
1330    * @param sourceMethod the name of the method that issued the logging request 
1331    * @param msg          the string message (or a key in the resource bundle)
1332    * @param params1      Parameter 1 to the log message
1333    * @param params2      Parameter 2 to the log message
1334    * @param params3      Parameter 3 to the log message
1335    */
1336   public void logp(Level level,
1337                    String sourceClass,
1338                    String sourceMethod,
1339                    String msg,
1340                    Object params1,
1341                    Object params2,
1342                    Object params3
1343                   )
1344   {
1345     logp(level,sourceClass, sourceMethod, msg, new Object[] {params1, params2, params3});
1346   }
1347 
1348   //================================================================
1349   // End of convenience methods 
1350   //================================================================
1351 
1352   /**
1353    * Set the log level specifying which message levels will be
1354    * logged by this logger.  Message levels lower than this
1355    * value will be discarded.  The level value Level.OFF
1356    * can be used to turn off logging.
1357    * <p>
1358    * If the new level is null, it means that this node should
1359    * inherit its level from its nearest ancestor with a specific
1360    * (non-null) level value.
1361    * 
1362    * @param newLevel   the new value for the log level (may be null)
1363    * @exception  SecurityException  if a security manager exists and if
1364    *             the caller does not have LoggingPermission("control").
1365    */
1366   public void setLevel(Level newLevel) throws SecurityException 
1367   {
1368     _log.setLevel(newLevel);
1369   }
1370 
1371   /**
1372    * Get the log Level that has been specified for this Logger.
1373    * The result may be null, which means that this logger's
1374    * effective level will be inherited from its parent.
1375    *
1376    * @return    this Logger's level
1377    */
1378   public Level getLevel() 
1379   {
1380     return _log.getLevel();
1381   }
1382 
1383   /**
1384    * Check if a message of the given level would actually be logged
1385    * by this logger.  This check is based on the Loggers effective level,
1386    * which may be inherited from its parent.
1387    *
1388    * @param level   a message logging level
1389    * @return    true if the given message level is currently being logged.
1390    */
1391   public boolean isLoggable(Level level) 
1392   {
1393     return _log.isLoggable(level);
1394   }
1395 
1396   /**
1397    * Get the name for this logger.
1398    * @return logger name.  Will be null for anonymous Loggers.
1399    */
1400   public String getName() 
1401   {
1402     return _log.getName();  
1403   }
1404 
1405   /**
1406    * Add a log Handler to receive logging messages.
1407    * <p>
1408    * By default, Loggers also send their output to their parent logger.
1409    * Typically the root Logger is configured with a set of Handlers
1410    * that essentially act as default handlers for all loggers.
1411    *
1412    * @param handler a logging Handler
1413    * @exception  SecurityException  if a security manager exists and if
1414    *             the caller does not have LoggingPermission("control").
1415    */
1416   public void addHandler(Handler handler) throws SecurityException 
1417   {
1418     _log.addHandler(handler);
1419   }
1420 
1421   /**
1422    * Remove a log Handler.
1423    * <P>
1424    * Returns silently if the given Handler is not found.
1425    * 
1426    * @param handler a logging Handler
1427    * @exception  SecurityException  if a security manager exists and if
1428    *             the caller does not have LoggingPermission("control").
1429    */
1430   public void removeHandler(Handler handler) throws SecurityException 
1431   {
1432     _log.removeHandler(handler);
1433   }
1434 
1435   /**
1436    * Get the Handlers associated with this logger.
1437    * <p>
1438    * @return  an array of all registered Handlers
1439    */
1440   public Handler[] getHandlers() 
1441   {
1442     return _log.getHandlers();
1443   }
1444 
1445   /**
1446    * Specify whether or not this logger should send its output
1447    * to it's parent Logger.  This means that any LogRecords will
1448    * also be written to the parent's Handlers, and potentially
1449    * to its parent, recursively up the namespace.
1450    *
1451    * @param useParentHandlers   true if output is to be sent to the
1452    *        logger's parent.
1453    * @exception  SecurityException  if a security manager exists and if
1454    *             the caller does not have LoggingPermission("control").
1455    */
1456   public void setUseParentHandlers(boolean useParentHandlers) 
1457   {
1458     _log.setUseParentHandlers(useParentHandlers);
1459   }
1460 
1461   /**
1462    * Discover whether or not this logger is sending its output
1463    * to its parent logger.
1464    *
1465    * @return  true if output is to be sent to the logger's parent
1466    */
1467   public boolean getUseParentHandlers() 
1468   {
1469     return _log.getUseParentHandlers();
1470   }
1471 
1472   /**
1473    * Return the parent for this Logger.
1474    * <p>
1475    * This method returns the nearest extant parent in the namespace.
1476    * Thus if a Logger is called "a.b.c.d", and a Logger called "a.b"
1477    * has been created but no logger "a.b.c" exists, then a call of
1478    * getParent on the Logger "a.b.c.d" will return the Logger "a.b".
1479    * <p>
1480    * The result will be null if it is called on the root Logger
1481    * in the namespace.
1482    * 
1483    * @return nearest existing parent Logger 
1484    */
1485   public Logger getParent() 
1486   {
1487     return _log.getParent();
1488   }
1489 
1490   /**
1491    * Set the parent for this Logger.  This method is used by
1492    * the LogManager to update a Logger when the namespace changes.
1493    * <p>
1494    * It should not be called from application code.
1495    * <p>
1496    * @param  parent   the new parent logger
1497    * @exception  SecurityException  if a security manager exists and if
1498    *             the caller does not have LoggingPermission("control").
1499    */
1500   public void setParent(Logger parent) 
1501   {
1502     _log.setParent(parent);
1503   }
1504 
1505 
1506   private ResourceBundle findResourceBundle(String name) 
1507   {
1508     // Return a null bundle for a null name.
1509     if (name == null)
1510     {
1511       return null;
1512     }
1513 
1514     Locale currentLocale = Locale.getDefault();
1515     return ResourceBundle.getBundle(name, currentLocale);
1516 
1517   }
1518 
1519 
1520   private void doLog(LogRecord lr, String rbname) 
1521   {
1522     lr.setLoggerName(_log.getName());
1523     if (rbname != null)
1524     {
1525       lr.setResourceBundleName(rbname);
1526       lr.setResourceBundle(findResourceBundle(rbname));
1527     }
1528     log(lr);
1529   }
1530 
1531   private void doLog(LogRecord lr) 
1532   {
1533     lr.setLoggerName(_log.getName());
1534     String ebname = _log.getResourceBundleName();
1535     if (ebname != null)
1536     {
1537       lr.setResourceBundleName(ebname);
1538       lr.setResourceBundle(_log.getResourceBundle());
1539     }
1540     _log.log(lr);
1541   }
1542 
1543   public void severe(Throwable t)
1544   {
1545     severe(null, t);
1546   }
1547 
1548   public void severe(String message, Throwable t)
1549   {
1550     log(Level.SEVERE, message, t);
1551   }
1552 
1553   public void severe(String message, Object param)
1554   {
1555     log(Level.SEVERE, message, param);
1556   }
1557 
1558   public void severe(String message, Object[] params)
1559   {
1560     log(Level.SEVERE, message, params);
1561   }
1562 
1563 
1564   public void warning(Throwable t)
1565   {
1566     warning(null, t);
1567   }
1568 
1569   public void warning(String message, Throwable t)
1570   {
1571     log(Level.WARNING, message, t);
1572   }
1573 
1574   public void warning(String message, Object param)
1575   {
1576     log(Level.WARNING, message, param);
1577   }
1578 
1579   public void warning(String message, Object[] params)
1580   {
1581     log(Level.WARNING, message, params);
1582   }
1583 
1584   public void info(Throwable t)
1585   {
1586     info(null, t);
1587   }
1588 
1589   public void info(String message, Throwable t)
1590   {
1591     log(Level.INFO, message, t);
1592   }
1593 
1594   public void info(String message, Object param)
1595   {
1596     log(Level.INFO, message, param);
1597   }
1598 
1599   public void info(String message, Object[] params)
1600   {
1601     log(Level.INFO, message, params);
1602   }
1603 
1604   public void fine(Throwable t)
1605   {
1606     fine(null, t);
1607   }
1608 
1609   public void fine(String message, Throwable t)
1610   {
1611     log(Level.FINE, message, t);
1612   }
1613 
1614   public void fine(String message, Object param)
1615   {
1616     log(Level.FINE, message, param);
1617   }
1618 
1619   public void fine(String message, Object[] params)
1620   {
1621     log(Level.FINE, message, params);
1622   }
1623 
1624   public void finer(Throwable t)
1625   {
1626     finer(null, t);
1627   }
1628 
1629   public void finer(String message, Throwable t)
1630   {
1631     log(Level.FINER, message, t);
1632   }
1633 
1634   public void finer(String message, Object param)
1635   {
1636     log(Level.FINER, message, param);
1637   }
1638 
1639   public void finer(String message, Object[] params)
1640   {
1641     log(Level.FINER, message, params);
1642   }
1643 
1644 
1645   public void finest(Throwable t)
1646   {
1647     finest(null, t);
1648   }
1649 
1650   public void finest(String message, Throwable t)
1651   {
1652     log(Level.FINEST, message, t);
1653   }
1654 
1655   public void finest(String message, Object param)
1656   {
1657     log(Level.FINEST, message, param);
1658   }
1659 
1660   public void finest(String message, Object[] params)
1661   {
1662     log(Level.FINEST, message, params);
1663   }
1664 
1665   /**
1666    * Returns true if severe messages should be logged.
1667    */
1668   public boolean isSevere()
1669   {
1670     return isLoggable(Level.SEVERE);
1671   }
1672 
1673   /**
1674    * Returns true if warning messages should be logged.
1675    */
1676   public boolean isWarning()
1677   {
1678     return isLoggable(Level.WARNING);
1679   }
1680 
1681 
1682   /**
1683    * Returns true if info messages should be logged.
1684    */
1685   public boolean isInfo()
1686   {
1687     return isLoggable(Level.INFO);
1688   }
1689 
1690 
1691   /**
1692    * Returns true if config messages should be logged.
1693    */
1694   public boolean isConfig()
1695   {
1696     return isLoggable(Level.CONFIG);
1697   }
1698 
1699 
1700   /**
1701    * Returns true if fine messages should be logged.
1702    */
1703   public boolean isFine()
1704   {
1705     return isLoggable(Level.FINE);
1706   }
1707 
1708 
1709   /**
1710    * Returns true if finer messages should be logged.
1711    */
1712   public boolean isFiner()
1713   {
1714     return isLoggable(Level.FINER);
1715   }
1716 
1717   /**
1718    * Returns true if finest messages should be logged.
1719    */
1720   public boolean isFinest()
1721   {
1722     return isLoggable(Level.FINEST);
1723   }
1724 
1725   /**
1726    * Returns message string in default locale
1727    */
1728   public String getMessage(String key)
1729   {
1730     try
1731     {
1732       return _log.getResourceBundle().getString(key);
1733     }
1734     catch (MissingResourceException mre)
1735     {
1736       return key;
1737     }
1738   }
1739 
1740   /**
1741    * Returns formated string in default locale
1742    */
1743   public String getMessage(String key, Object[] params)
1744   {
1745     String message = getMessage(key);
1746     FastMessageFormat fmt = new FastMessageFormat(message);  
1747     return fmt.format(params);  
1748   }
1749 
1750   /**
1751    * Returns formated string in default locale
1752    */
1753   public String getMessage(String key, Object param)
1754   {
1755     if (param == null)
1756       System.out.println("null param");
1757     return getMessage(key, new Object[]{param});
1758   }
1759 
1760   private Logger _log;
1761   
1762   private static final String _API_LOGGER_BUNDLE = "org.apache.myfaces.trinidad.resource.LoggerBundle";
1763 
1764   private static final String _IMPL_LOGGER_BUNDLE = "org.apache.myfaces.trinidadinternal.resource.LoggerBundle";
1765   private static final TrinidadLogger _LOG = TrinidadLogger.createTrinidadLogger(
1766     TrinidadLogger.class);
1767 }