Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. 
18
 
19
 
20
 package org.apache.cxf.common.logging;
21
 
33
 
A container for static utility methods related to logging. By default, CXF logs to java.util.logging. An application can change this. To log to another system, the application must provide an object that extends AbstractDelegatingLogger, and advertise that class via one of the following mechanisms:
  • Create a file, in the classpath, named META-INF/cxf/org.apache.cxf.Logger. This file should contain the fully-qualified name of the class, with no comments, on a single line.
  • Call setLoggerClass(java.lang.Class) with a Class<?> reference to the logger class.
CXF provides Log4jLogger to use log4j instead of java.util.logging. 
50
 
51
 public final class LogUtils {
52
     public static final String KEY = "org.apache.cxf.Logger";
53
     
54
     private static final Object[] NO_PARAMETERS = new Object[0];
55
 
56
     
57
     private static Class<?> loggerClass;
    
    
Prevents instantiation. 
61
 
62
     private LogUtils() {
63
     }
64
 
65
     static {
66
         try {
67
             String cname = System.getProperty();
68
             if (StringUtils.isEmpty(cname)) {
69
                 InputStream ins = Thread.currentThread().getContextClassLoader()
70
                     .getResourceAsStream("META-INF/cxf/" + );
71
                 if (ins == null) {
72
                     ins = ClassLoader.getSystemResourceAsStream("META-INF/cxf/" + );
73
                 }
74
                 if (ins != null) {
75
                     BufferedReader din = new BufferedReader(new InputStreamReader(ins));
76
                     cname = din.readLine();
77
                 }
78
             }
79
             if (!StringUtils.isEmpty(cname)) {
80
                  = Class.forName(cname, true,
81
                                             Thread.currentThread().getContextClassLoader());
82
                 getLogger(LogUtils.class).fine("Using " + .getName() + " for logging.");
83
             }
84
         } catch (Exception ex) {
85
             //ignore
86
         }
87
     }
    
    
    
Specify a logger class that inherits from AbstractDelegatingLogger. Enable users to use their own logger implementation. 
93
 
94
     public static void setLoggerClass(Class<? extends AbstractDelegatingLogger> cls) {
95
          = cls;
96
     }

    
    
Get a Logger with the associated default resource bundle for the class.

Parameters:
cls the Class to contain the Logger
Returns:
an appropriate Logger
105
    public static Logger getLogger(Class<?> cls) {
106
        return createLogger(cls, null, cls.getName());
107
    }
    
    
Get a Logger with an associated resource bundle.

Parameters:
cls the Class to contain the Logger
name the resource name
Returns:
an appropriate Logger
116
    public static Logger getLogger(Class<?> cls, String resourcename) {
117
        return createLogger(cls, resourcename, cls.getName());
118
    }

    
Get a Logger with an associated resource bundle.

Parameters:
cls the Class to contain the Logger (to find resources)
name the resource name
loggerName the full name for the logger
Returns:
an appropriate Logger
128
    public static Logger getLogger(Class<?> cls,
129
                                     String resourcename,
130
                                     String loggerName) {
131
        return createLogger(cls, resourcename, loggerName);
132
    }

    
Get a Logger with the associated default resource bundle for the class.

Parameters:
cls the Class to contain the Logger
Returns:
an appropriate Logger
140
    public static Logger getL7dLogger(Class<?> cls) {
141
        return createLogger(cls, null, cls.getName());
142
    }
    
    
Get a Logger with an associated resource bundle.

Parameters:
cls the Class to contain the Logger
name the resource name
Returns:
an appropriate Logger
151
    public static Logger getL7dLogger(Class<?> cls, String resourcename) {
152
        return createLogger(cls, resourcename, cls.getName());
153
    }

    
Get a Logger with an associated resource bundle.

Parameters:
cls the Class to contain the Logger (to find resources)
name the resource name
loggerName the full name for the logger
Returns:
an appropriate Logger
163
    public static Logger getL7dLogger(Class<?> cls,
164
                                      String resourcename,
165
                                      String loggerName) {
166
        return createLogger(cls, resourcename, loggerName);
167
    }
    
    
Create a logger 
172
    protected static Logger createLogger(Class<?> cls, 
173
                                         String name, 
174
                                         String loggerName) {
175
        if ( != null) {
176
            try {
177
                Constructor cns = .getConstructor(String.class, String.class);
178
                if (name == null) {
179
                    try {
180
                        return (Logger) cns.newInstance(loggerName, BundleUtils.getBundleName(cls));
181
                    } catch (InvocationTargetException ite) {
182
                        if (ite.getTargetException() instanceof MissingResourceException) {
183
                            return (Logger) cns.newInstance(loggerName, null);
184
                        } else {
185
                            throw ite;
186
                        }
187
                    } 
188
                } else {
189
                    try {
190
                        return (Logger) cns.newInstance(loggerName, BundleUtils.getBundleName(cls, name));
191
                    } catch (InvocationTargetException ite) {
192
                        if (ite.getTargetException() instanceof MissingResourceException) {
193
                            throw (MissingResourceException)ite.getTargetException();
194
                        } else {
195
                            throw ite;
196
                        }
197
                    } 
198
                }
199
            } catch (Exception e) {
200
                throw new RuntimeException(e);
201
            }
202
        }
203
        if (name == null) {
204
            try {
205
                return Logger.getLogger(loggerName, BundleUtils.getBundleName(cls)); //NOPMD
206
            } catch (MissingResourceException rex) {
207
                return Logger.getLogger(loggerName, null); //NOPMD
208
            }
209
        } else {
210
            return Logger.getLogger(loggerName, BundleUtils.getBundleName(cls, name)); //NOPMD
211
        }
212
    }

    
Allows both parameter substitution and a typed Throwable to be logged.

Parameters:
logger the Logger the log to
level the severity level
message the log message
throwable the Throwable to log
parameter the parameter to substitute into message
223
    public static void log(Logger logger, 
224
                           Level level, 
225
                           String message, 
226
                           Throwable throwable,
227
                           Object parameter) {
228
        if (logger.isLoggable(level)) {
229
            final String formattedMessage = 
230
                MessageFormat.format(localize(logger, message), parameter);
231
            doLog(logger, level, formattedMessage, throwable);
232
        }
233
    }

    
Allows both parameter substitution and a typed Throwable to be logged.

Parameters:
logger the Logger the log to
level the severity level
message the log message
throwable the Throwable to log
parameters the parameters to substitute into message
244
    public static void log(Logger logger, 
245
                           Level level, 
246
                           String message, 
247
                           Throwable throwable,
248
                           Object... parameters) {
249
        if (logger.isLoggable(level)) {
250
            final String formattedMessage = 
251
                MessageFormat.format(localize(logger, message), parameters);
252
            doLog(logger, level, formattedMessage, throwable);
253
        }
254
    }
 
    
Checks log level and logs

Parameters:
logger the Logger the log to
level the severity level
message the log message
262
    
263
    public static void log(Logger logger, 
264
                           Level level, 
265
                           String message) {
266
        log(logger, level, message, );        
267
    }  
    
    
Checks log level and logs

Parameters:
logger the Logger the log to
level the severity level
message the log message
throwable the Throwable to log
276
      
277
    public static void log(Logger logger, 
278
                           Level level, 
279
                           String message, 
280
                           Throwable throwable) {
281
        log(logger, level, message, throwable, );
282
    }
  
    
Checks log level and logs

Parameters:
logger the Logger the log to
level the severity level
message the log message
parameter the parameter to substitute into message
291
      
292
    public static void log(Logger logger, 
293
                           Level level, 
294
                           String message, 
295
                           Object parameter) {
296
        log(logger, level, message, new Object[] {parameter});
297
    }
    
    
Checks log level and logs

Parameters:
logger the Logger the log to
level the severity level
message the log message
parameters the parameters to substitute into message
306
      
307
    public static void log(Logger logger, 
308
                           Level level, 
309
                           String message, 
310
                           Object[] parameters) {
311
        if (logger.isLoggable(level)) {
312
            String msg = localize(logger, message);
313
            try {
314
                msg = MessageFormat.format(msg, parameters);
315
            } catch (IllegalArgumentException ex) {
316
                //ignore, log as is
317
            }
318
            doLog(logger, level, msg, null);
319
        }        
320
    }
322
    private static void doLog(Logger log, Level level, String msg, Throwable t) {
323
        LogRecord record = new LogRecord(level, msg);
324
    
325
        record.setLoggerName(log.getName());
326
        record.setResourceBundleName(log.getResourceBundleName());
327
        record.setResourceBundle(log.getResourceBundle());
328
            
329
        if (t != null) {
330
            record.setThrown(t);
331
        }
332
        
333
        //try to get the right class name/method name - just trace
334
        //back the stack till we get out of this class
335
        StackTraceElement stack[] = (new Throwable()).getStackTrace();
336
        String cname = LogUtils.class.getName();
337
        for (int x = 0; x < stack.length; x++) {
338
            StackTraceElement frame = stack[x];
339
            if (!frame.getClassName().equals(cname)) {
340
                record.setSourceClassName(frame.getClassName());
341
                record.setSourceMethodName(frame.getMethodName());
342
                break;
343
            }
344
        }
345
        log.log(record);
346
    }

    
Retrieve localized message retrieved from a logger's resource bundle.

Parameters:
logger the Logger
message the message to be localized
355
    private static String localize(Logger logger, String message) {
356
        ResourceBundle bundle = logger.getResourceBundle();
357
        try {
358
            return bundle != null ? bundle.getString(message) : message;
359
        } catch (MissingResourceException ex) {
360
            //string not in the bundle
361
            return message;
362
        }
363
    }
New to GrepCode? Check out our FAQ X