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