|
1 /* |
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 |
|
26 package com.sun.istack.internal.logging; |
|
27 |
|
28 import com.sun.istack.internal.NotNull; |
|
29 |
|
30 import java.util.StringTokenizer; |
|
31 import java.util.logging.Level; |
|
32 |
|
33 /** |
|
34 * This is a helper class that provides some convenience methods wrapped around the |
|
35 * standard {@link java.util.logging.Logger} interface. |
|
36 * |
|
37 * The class also makes sure that logger names of each Metro subsystem are consistent |
|
38 * with each other. |
|
39 * |
|
40 * @author Marek Potociar <marek.potociar at sun.com> |
|
41 * @author Fabian Ritzmann |
|
42 */ |
|
43 public class Logger { |
|
44 |
|
45 private static final String WS_LOGGING_SUBSYSTEM_NAME_ROOT = "com.sun.metro"; |
|
46 private static final String ROOT_WS_PACKAGE = "com.sun.xml.internal.ws."; |
|
47 // |
|
48 private static final Level METHOD_CALL_LEVEL_VALUE = Level.FINEST; |
|
49 // |
|
50 private final String componentClassName; |
|
51 private final java.util.logging.Logger logger; |
|
52 |
|
53 /** |
|
54 * Prevents creation of a new instance of this Logger unless used by a subclass. |
|
55 */ |
|
56 protected Logger(final String systemLoggerName, final String componentName) { |
|
57 this.componentClassName = "[" + componentName + "] "; |
|
58 this.logger = java.util.logging.Logger.getLogger(systemLoggerName); |
|
59 } |
|
60 |
|
61 /** |
|
62 * <p> |
|
63 * The factory method returns preconfigured Logger wrapper for the class. Method calls |
|
64 * {@link #getSystemLoggerName(java.lang.Class)} to generate default logger name. |
|
65 * </p> |
|
66 * <p> |
|
67 * Since there is no caching implemented, it is advised that the method is called only once |
|
68 * per a class in order to initialize a final static logger variable, which is then used |
|
69 * through the class to perform actual logging tasks. |
|
70 * </p> |
|
71 * |
|
72 * @param componentClass class of the component that will use the logger instance. Must not be {@code null}. |
|
73 * @return logger instance preconfigured for use with the component |
|
74 * @throws NullPointerException if the componentClass parameter is {@code null}. |
|
75 */ |
|
76 public static @NotNull Logger getLogger(final @NotNull Class<?> componentClass) { |
|
77 return new Logger(getSystemLoggerName(componentClass), componentClass.getName()); |
|
78 } |
|
79 |
|
80 /** |
|
81 * The factory method returns preconfigured Logger wrapper for the class. Since there is no caching implemented, |
|
82 * it is advised that the method is called only once per a class in order to initialize a final static logger variable, |
|
83 * which is then used through the class to perform actual logging tasks. |
|
84 * |
|
85 * This method should be only used in a special cases when overriding of a default logger name derived from the |
|
86 * package of the component class is needed. For all common use cases please use {@link #getLogger(java.lang.Class)} |
|
87 * method. |
|
88 * |
|
89 * @param customLoggerName custom name of the logger. |
|
90 * @param componentClass class of the component that will use the logger instance. Must not be {@code null}. |
|
91 * @return logger instance preconfigured for use with the component |
|
92 * @throws NullPointerException if the componentClass parameter is {@code null}. |
|
93 * |
|
94 * @see #getLogger(java.lang.Class) |
|
95 */ |
|
96 public static @NotNull Logger getLogger(final @NotNull String customLoggerName, final @NotNull Class<?> componentClass) { |
|
97 return new Logger(customLoggerName, componentClass.getName()); |
|
98 } |
|
99 |
|
100 /** |
|
101 * Calculates the subsystem suffix based on the package of the component class |
|
102 * @param componentClass class of the component that will use the logger instance. Must not be {@code null}. |
|
103 * @return system logger name for the given {@code componentClass} instance |
|
104 */ |
|
105 static final String getSystemLoggerName(@NotNull Class<?> componentClass) { |
|
106 StringBuilder sb = new StringBuilder(componentClass.getPackage().getName()); |
|
107 final int lastIndexOfWsPackage = sb.lastIndexOf(ROOT_WS_PACKAGE); |
|
108 if (lastIndexOfWsPackage > -1) { |
|
109 sb.replace(0, lastIndexOfWsPackage + ROOT_WS_PACKAGE.length(), ""); |
|
110 |
|
111 StringTokenizer st = new StringTokenizer(sb.toString(), "."); |
|
112 sb = new StringBuilder(WS_LOGGING_SUBSYSTEM_NAME_ROOT).append("."); |
|
113 if (st.hasMoreTokens()) { |
|
114 String token = st.nextToken(); |
|
115 if ("api".equals(token)) { |
|
116 token = st.nextToken(); |
|
117 } |
|
118 sb.append(token); |
|
119 } |
|
120 } |
|
121 |
|
122 return sb.toString(); |
|
123 } |
|
124 |
|
125 public void log(final Level level, final String message) { |
|
126 if (!this.logger.isLoggable(level)) { |
|
127 return; |
|
128 } |
|
129 logger.logp(level, componentClassName, getCallerMethodName(), message); |
|
130 } |
|
131 |
|
132 public void log(final Level level, final String message, Object param1) { |
|
133 if (!this.logger.isLoggable(level)) { |
|
134 return; |
|
135 } |
|
136 logger.logp(level, componentClassName, getCallerMethodName(), message, param1); |
|
137 } |
|
138 |
|
139 public void log(final Level level, final String message, Object[] params) { |
|
140 if (!this.logger.isLoggable(level)) { |
|
141 return; |
|
142 } |
|
143 logger.logp(level, componentClassName, getCallerMethodName(), message, params); |
|
144 } |
|
145 |
|
146 public void log(final Level level, final String message, final Throwable thrown) { |
|
147 if (!this.logger.isLoggable(level)) { |
|
148 return; |
|
149 } |
|
150 logger.logp(level, componentClassName, getCallerMethodName(), message, thrown); |
|
151 } |
|
152 |
|
153 public void finest(final String message) { |
|
154 if (!this.logger.isLoggable(Level.FINEST)) { |
|
155 return; |
|
156 } |
|
157 logger.logp(Level.FINEST, componentClassName, getCallerMethodName(), message); |
|
158 } |
|
159 |
|
160 public void finest(final String message, Object[] params) { |
|
161 if (!this.logger.isLoggable(Level.FINEST)) { |
|
162 return; |
|
163 } |
|
164 logger.logp(Level.FINEST, componentClassName, getCallerMethodName(), message, params); |
|
165 } |
|
166 |
|
167 public void finest(final String message, final Throwable thrown) { |
|
168 if (!this.logger.isLoggable(Level.FINEST)) { |
|
169 return; |
|
170 } |
|
171 logger.logp(Level.FINEST, componentClassName, getCallerMethodName(), message, thrown); |
|
172 } |
|
173 |
|
174 public void finer(final String message) { |
|
175 if (!this.logger.isLoggable(Level.FINER)) { |
|
176 return; |
|
177 } |
|
178 logger.logp(Level.FINER, componentClassName, getCallerMethodName(), message); |
|
179 } |
|
180 |
|
181 public void finer(final String message, Object[] params) { |
|
182 if (!this.logger.isLoggable(Level.FINER)) { |
|
183 return; |
|
184 } |
|
185 logger.logp(Level.FINER, componentClassName, getCallerMethodName(), message, params); |
|
186 } |
|
187 |
|
188 public void finer(final String message, final Throwable thrown) { |
|
189 if (!this.logger.isLoggable(Level.FINER)) { |
|
190 return; |
|
191 } |
|
192 logger.logp(Level.FINER, componentClassName, getCallerMethodName(), message, thrown); |
|
193 } |
|
194 |
|
195 public void fine(final String message) { |
|
196 if (!this.logger.isLoggable(Level.FINE)) { |
|
197 return; |
|
198 } |
|
199 logger.logp(Level.FINE, componentClassName, getCallerMethodName(), message); |
|
200 } |
|
201 |
|
202 public void fine(final String message, final Throwable thrown) { |
|
203 if (!this.logger.isLoggable(Level.FINE)) { |
|
204 return; |
|
205 } |
|
206 logger.logp(Level.FINE, componentClassName, getCallerMethodName(), message, thrown); |
|
207 } |
|
208 |
|
209 public void info(final String message) { |
|
210 if (!this.logger.isLoggable(Level.INFO)) { |
|
211 return; |
|
212 } |
|
213 logger.logp(Level.INFO, componentClassName, getCallerMethodName(), message); |
|
214 } |
|
215 |
|
216 public void info(final String message, Object[] params) { |
|
217 if (!this.logger.isLoggable(Level.INFO)) { |
|
218 return; |
|
219 } |
|
220 logger.logp(Level.INFO, componentClassName, getCallerMethodName(), message, params); |
|
221 } |
|
222 |
|
223 public void info(final String message, final Throwable thrown) { |
|
224 if (!this.logger.isLoggable(Level.INFO)) { |
|
225 return; |
|
226 } |
|
227 logger.logp(Level.INFO, componentClassName, getCallerMethodName(), message, thrown); |
|
228 } |
|
229 |
|
230 public void config(final String message) { |
|
231 if (!this.logger.isLoggable(Level.CONFIG)) { |
|
232 return; |
|
233 } |
|
234 logger.logp(Level.CONFIG, componentClassName, getCallerMethodName(), message); |
|
235 } |
|
236 |
|
237 public void config(final String message, Object[] params) { |
|
238 if (!this.logger.isLoggable(Level.CONFIG)) { |
|
239 return; |
|
240 } |
|
241 logger.logp(Level.CONFIG, componentClassName, getCallerMethodName(), message, params); |
|
242 } |
|
243 |
|
244 public void config(final String message, final Throwable thrown) { |
|
245 if (!this.logger.isLoggable(Level.CONFIG)) { |
|
246 return; |
|
247 } |
|
248 logger.logp(Level.CONFIG, componentClassName, getCallerMethodName(), message, thrown); |
|
249 } |
|
250 |
|
251 public void warning(final String message) { |
|
252 if (!this.logger.isLoggable(Level.WARNING)) { |
|
253 return; |
|
254 } |
|
255 logger.logp(Level.WARNING, componentClassName, getCallerMethodName(), message); |
|
256 } |
|
257 |
|
258 public void warning(final String message, Object[] params) { |
|
259 if (!this.logger.isLoggable(Level.WARNING)) { |
|
260 return; |
|
261 } |
|
262 logger.logp(Level.WARNING, componentClassName, getCallerMethodName(), message, params); |
|
263 } |
|
264 |
|
265 public void warning(final String message, final Throwable thrown) { |
|
266 if (!this.logger.isLoggable(Level.WARNING)) { |
|
267 return; |
|
268 } |
|
269 logger.logp(Level.WARNING, componentClassName, getCallerMethodName(), message, thrown); |
|
270 } |
|
271 |
|
272 public void severe(final String message) { |
|
273 if (!this.logger.isLoggable(Level.SEVERE)) { |
|
274 return; |
|
275 } |
|
276 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), message); |
|
277 } |
|
278 |
|
279 public void severe(final String message, Object[] params) { |
|
280 if (!this.logger.isLoggable(Level.SEVERE)) { |
|
281 return; |
|
282 } |
|
283 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), message, params); |
|
284 } |
|
285 |
|
286 public void severe(final String message, final Throwable thrown) { |
|
287 if (!this.logger.isLoggable(Level.SEVERE)) { |
|
288 return; |
|
289 } |
|
290 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), message, thrown); |
|
291 } |
|
292 |
|
293 public boolean isMethodCallLoggable() { |
|
294 return this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE); |
|
295 } |
|
296 |
|
297 public boolean isLoggable(final Level level) { |
|
298 return this.logger.isLoggable(level); |
|
299 } |
|
300 |
|
301 public void setLevel(final Level level) { |
|
302 this.logger.setLevel(level); |
|
303 } |
|
304 |
|
305 public void entering() { |
|
306 if (!this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE)) { |
|
307 return; |
|
308 } |
|
309 |
|
310 logger.entering(componentClassName, getCallerMethodName()); |
|
311 } |
|
312 |
|
313 public void entering(final Object... parameters) { |
|
314 if (!this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE)) { |
|
315 return; |
|
316 } |
|
317 |
|
318 logger.entering(componentClassName, getCallerMethodName(), parameters); |
|
319 } |
|
320 |
|
321 public void exiting() { |
|
322 if (!this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE)) { |
|
323 return; |
|
324 } |
|
325 logger.exiting(componentClassName, getCallerMethodName()); |
|
326 } |
|
327 |
|
328 public void exiting(final Object result) { |
|
329 if (!this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE)) { |
|
330 return; |
|
331 } |
|
332 logger.exiting(componentClassName, getCallerMethodName(), result); |
|
333 } |
|
334 |
|
335 /** |
|
336 * Method logs {@code exception}'s message as a {@code SEVERE} logging level |
|
337 * message. |
|
338 * <p/> |
|
339 * If {@code cause} parameter is not {@code null}, it is logged as well and |
|
340 * {@code exception} original cause is initialized with instance referenced |
|
341 * by {@code cause} parameter. |
|
342 * |
|
343 * @param exception exception whose message should be logged. Must not be |
|
344 * {@code null}. |
|
345 * @param cause initial cause of the exception that should be logged as well |
|
346 * and set as {@code exception}'s original cause. May be {@code null}. |
|
347 * @return the same exception instance that was passed in as the {@code exception} |
|
348 * parameter. |
|
349 */ |
|
350 public <T extends Throwable> T logSevereException(final T exception, final Throwable cause) { |
|
351 if (this.logger.isLoggable(Level.SEVERE)) { |
|
352 if (cause == null) { |
|
353 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
354 } else { |
|
355 exception.initCause(cause); |
|
356 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage(), cause); |
|
357 } |
|
358 } |
|
359 |
|
360 return exception; |
|
361 } |
|
362 |
|
363 /** |
|
364 * Method logs {@code exception}'s message as a {@code SEVERE} logging level |
|
365 * message. |
|
366 * <p/> |
|
367 * If {@code logCause} parameter is {@code true}, {@code exception}'s original |
|
368 * cause is logged as well (if exists). This may be used in cases when |
|
369 * {@code exception}'s class provides constructor to initialize the original |
|
370 * cause. In such case you do not need to use |
|
371 * {@link #logSevereException(Throwable, Throwable)} |
|
372 * method version but you might still want to log the original cause as well. |
|
373 * |
|
374 * @param exception exception whose message should be logged. Must not be |
|
375 * {@code null}. |
|
376 * @param logCause deterimnes whether initial cause of the exception should |
|
377 * be logged as well |
|
378 * @return the same exception instance that was passed in as the {@code exception} |
|
379 * parameter. |
|
380 */ |
|
381 public <T extends Throwable> T logSevereException(final T exception, final boolean logCause) { |
|
382 if (this.logger.isLoggable(Level.SEVERE)) { |
|
383 if (logCause && exception.getCause() != null) { |
|
384 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage(), exception.getCause()); |
|
385 } else { |
|
386 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
387 } |
|
388 } |
|
389 |
|
390 return exception; |
|
391 } |
|
392 |
|
393 /** |
|
394 * Same as {@link #logSevereException(Throwable, boolean) logSevereException(exception, true)}. |
|
395 */ |
|
396 public <T extends Throwable> T logSevereException(final T exception) { |
|
397 if (this.logger.isLoggable(Level.SEVERE)) { |
|
398 if (exception.getCause() == null) { |
|
399 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
400 } else { |
|
401 logger.logp(Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage(), exception.getCause()); |
|
402 } |
|
403 } |
|
404 |
|
405 return exception; |
|
406 } |
|
407 |
|
408 /** |
|
409 * Method logs {@code exception}'s message at the logging level specified by the |
|
410 * {@code level} argument. |
|
411 * <p/> |
|
412 * If {@code cause} parameter is not {@code null}, it is logged as well and |
|
413 * {@code exception} original cause is initialized with instance referenced |
|
414 * by {@code cause} parameter. |
|
415 * |
|
416 * @param exception exception whose message should be logged. Must not be |
|
417 * {@code null}. |
|
418 * @param cause initial cause of the exception that should be logged as well |
|
419 * and set as {@code exception}'s original cause. May be {@code null}. |
|
420 * @param level loging level which should be used for logging |
|
421 * @return the same exception instance that was passed in as the {@code exception} |
|
422 * parameter. |
|
423 */ |
|
424 public <T extends Throwable> T logException(final T exception, final Throwable cause, final Level level) { |
|
425 if (this.logger.isLoggable(level)) { |
|
426 if (cause == null) { |
|
427 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
428 } else { |
|
429 exception.initCause(cause); |
|
430 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage(), cause); |
|
431 } |
|
432 } |
|
433 |
|
434 return exception; |
|
435 } |
|
436 |
|
437 /** |
|
438 * Method logs {@code exception}'s message at the logging level specified by the |
|
439 * {@code level} argument. |
|
440 * <p/> |
|
441 * If {@code logCause} parameter is {@code true}, {@code exception}'s original |
|
442 * cause is logged as well (if exists). This may be used in cases when |
|
443 * {@code exception}'s class provides constructor to initialize the original |
|
444 * cause. In such case you do not need to use |
|
445 * {@link #logException(Throwable, Throwable, Level) logException(exception, cause, level)} |
|
446 * method version but you might still want to log the original cause as well. |
|
447 * |
|
448 * @param exception exception whose message should be logged. Must not be |
|
449 * {@code null}. |
|
450 * @param logCause deterimnes whether initial cause of the exception should |
|
451 * be logged as well |
|
452 * @param level loging level which should be used for logging |
|
453 * @return the same exception instance that was passed in as the {@code exception} |
|
454 * parameter. |
|
455 */ |
|
456 public <T extends Throwable> T logException(final T exception, final boolean logCause, final Level level) { |
|
457 if (this.logger.isLoggable(level)) { |
|
458 if (logCause && exception.getCause() != null) { |
|
459 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage(), exception.getCause()); |
|
460 } else { |
|
461 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
462 } |
|
463 } |
|
464 |
|
465 return exception; |
|
466 } |
|
467 |
|
468 /** |
|
469 * Same as {@link #logException(Throwable, Throwable, Level) |
|
470 * logException(exception, true, level)}. |
|
471 */ |
|
472 public <T extends Throwable> T logException(final T exception, final Level level) { |
|
473 if (this.logger.isLoggable(level)) { |
|
474 if (exception.getCause() == null) { |
|
475 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage()); |
|
476 } else { |
|
477 logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage(), exception.getCause()); |
|
478 } |
|
479 } |
|
480 |
|
481 return exception; |
|
482 } |
|
483 |
|
484 /** |
|
485 * Function returns the name of the caller method for the method executing this |
|
486 * function. |
|
487 * |
|
488 * @return caller method name from the call stack of the current {@link Thread}. |
|
489 */ |
|
490 private static String getCallerMethodName() { |
|
491 return getStackMethodName(5); |
|
492 } |
|
493 |
|
494 /** |
|
495 * Method returns the name of the method that is on the {@code methodIndexInStack} |
|
496 * position in the call stack of the current {@link Thread}. |
|
497 * |
|
498 * @param methodIndexInStack index to the call stack to get the method name for. |
|
499 * @return the name of the method that is on the {@code methodIndexInStack} |
|
500 * position in the call stack of the current {@link Thread}. |
|
501 */ |
|
502 private static String getStackMethodName(final int methodIndexInStack) { |
|
503 final String methodName; |
|
504 |
|
505 final StackTraceElement[] stack = Thread.currentThread().getStackTrace(); |
|
506 if (stack.length > methodIndexInStack + 1) { |
|
507 methodName = stack[methodIndexInStack].getMethodName(); |
|
508 } else { |
|
509 methodName = "UNKNOWN METHOD"; |
|
510 } |
|
511 |
|
512 return methodName; |
|
513 } |
|
514 |
|
515 } |