001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     * 
010     *      http://www.apache.org/licenses/LICENSE-2.0
011     * 
012     * Unless required by applicable law or agreed to in writing, software
013     * distributed under the License is distributed on an "AS IS" BASIS,
014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    package org.apache.oozie.util;
019    
020    
021    import org.apache.commons.logging.Log;
022    import org.apache.commons.logging.LogFactory;
023    
024    import java.text.MessageFormat;
025    import java.util.ArrayList;
026    import java.util.HashMap;
027    import java.util.List;
028    import java.util.Map;
029    
030    /**
031     * The <code>XLog</code> class extends the functionality of the Apache common-logging <code>Log</code> interface. <p/>
032     * It provides common prefix support, message templating with variable parameters and selective tee logging to multiple
033     * logs. <p/> It provides also the LogFactory functionality.
034     */
035    public class XLog implements Log {
036    
037        /**
038         * <code>LogInfo</code> stores contextual information to create log prefixes. <p/> <code>LogInfo</code> uses a
039         * <code>ThreadLocal</code> to propagate the context. <p/> <code>LogInfo</code> context parameters are configurable
040         * singletons.
041         */
042        public static class Info {
043            private static String template = "";
044            private static List<String> parameterNames = new ArrayList<String>();
045    
046            private static ThreadLocal<Info> tlLogInfo = new ThreadLocal<Info>() {
047                @Override
048                protected Info initialValue() {
049                    return new Info();
050                }
051    
052            };
053    
054            /**
055             * Define a <code>LogInfo</code> context parameter. <p/> The parameter name and its contextual value will be
056             * used to create all prefixes.
057             *
058             * @param name name of the context parameter.
059             */
060            public static void defineParameter(String name) {
061                ParamChecker.notEmpty(name, "name");
062                int count = parameterNames.size();
063                if (count > 0) {
064                    template += " ";
065                }
066                template += name + "[{" + count + "}]";
067                parameterNames.add(name);
068            }
069    
070            /**
071             * Remove all defined context parameters. <p/>
072             */
073            public static void reset() {
074                template = "";
075                parameterNames.clear();
076            }
077    
078            /**
079             * Return the <code>LogInfo</code> instance in context.
080             *
081             * @return The thread local instance of LogInfo
082             */
083            public static Info get() {
084                return tlLogInfo.get();
085            }
086    
087            /**
088             * Remove the <code>LogInfo</code> instance in context.
089             */
090            public static void remove() {
091                tlLogInfo.remove();
092            }
093    
094            private Map<String, String> parameters = new HashMap<String, String>();
095    
096            /**
097             * Constructs an empty LogInfo.
098             */
099            public Info() {
100            }
101    
102    
103            /**
104             * Construct a new LogInfo object from an existing one.
105             *
106             * @param logInfo LogInfo object to copy parameters from.
107             */
108            public Info(Info logInfo) {
109                setParameters(logInfo);
110            }
111    
112            /**
113             * Clear all parameters set in this logInfo instance.
114             */
115            public void clear() {
116                parameters.clear();
117            }
118    
119            /**
120             * Set a parameter value in the <code>LogInfo</code> context.
121             *
122             * @param name parameter name.
123             * @param value parameter value.
124             */
125            public void setParameter(String name, String value) {
126                if (!parameterNames.contains(name)) {
127                    throw new IllegalArgumentException(format("Parameter[{0}] not defined", name));
128                }
129                parameters.put(name, value);
130            }
131    
132            /**
133             * Returns the specified parameter.
134             *
135             * @param name parameter name.
136             * @return the parameter value.
137             */
138            public String getParameter(String name) {
139                return parameters.get(name);
140            }
141    
142            /**
143             * Clear a parameter value from the <code>LogInfo</code> context.
144             *
145             * @param name parameter name.
146             */
147            public void clearParameter(String name) {
148                if (!parameterNames.contains(name)) {
149                    throw new IllegalArgumentException(format("Parameter[{0}] not defined", name));
150                }
151                parameters.remove(name);
152            }
153    
154            /**
155             * Set all the parameter values from the given <code>LogInfo</code>.
156             *
157             * @param logInfo <code>LogInfo</code> to copy all parameter values from.
158             */
159            public void setParameters(Info logInfo) {
160                parameters.clear();
161                parameters.putAll(logInfo.parameters);
162            }
163    
164            /**
165             * Create the <code>LogInfo</code> prefix using the current parameter values.
166             *
167             * @return the <code>LogInfo</code> prefix.
168             */
169            public String createPrefix() {
170                String[] params = new String[parameterNames.size()];
171                for (int i = 0; i < params.length; i++) {
172                    params[i] = parameters.get(parameterNames.get(i));
173                    if (params[i] == null) {
174                        params[i] = "-";
175                    }
176                }
177                return MessageFormat.format(template, (Object[]) params);
178            }
179    
180        }
181    
182        /**
183         * Return the named logger configured with the {@link org.apache.oozie.util.XLog.Info} prefix.
184         *
185         * @param name logger name.
186         * @return the named logger configured with the {@link org.apache.oozie.util.XLog.Info} prefix.
187         */
188        public static XLog getLog(String name) {
189            return getLog(name, true);
190        }
191    
192        /**
193         * Return the named logger configured with the {@link org.apache.oozie.util.XLog.Info} prefix.
194         *
195         * @param clazz from which the logger name will be derived.
196         * @return the named logger configured with the {@link org.apache.oozie.util.XLog.Info} prefix.
197         */
198        public static XLog getLog(Class clazz) {
199            return getLog(clazz, true);
200        }
201    
202        /**
203         * Return the named logger.
204         *
205         * @param name logger name.
206         * @param prefix indicates if the {@link org.apache.oozie.util.XLog.Info} prefix has to be used or not.
207         * @return the named logger.
208         */
209        public static XLog getLog(String name, boolean prefix) {
210            return new XLog(LogFactory.getLog(name), (prefix) ? Info.get().createPrefix() : "");
211        }
212    
213        /**
214         * Return the named logger.
215         *
216         * @param clazz from which the logger name will be derived.
217         * @param prefix indicates if the {@link org.apache.oozie.util.XLog.Info} prefix has to be used or not.
218         * @return the named logger.
219         */
220        public static XLog getLog(Class clazz, boolean prefix) {
221            return new XLog(LogFactory.getLog(clazz), (prefix) ? Info.get().createPrefix() : "");
222        }
223    
224        /**
225         * Reset the logger prefix
226         *
227         * @param log the named logger
228         * @return the named logger with reset prefix
229         */
230        public static XLog resetPrefix(XLog log) {
231            log.setMsgPrefix(Info.get().createPrefix());
232            return log;
233        }
234    
235        /**
236         * Mask for logging to the standard log.
237         */
238        public static final int STD = 1;
239    
240        /**
241         * Mask for tee logging to the OPS log.
242         */
243        public static final int OPS = 4;
244    
245        private static final int ALL = STD | OPS;
246    
247        private static final int[] LOGGER_MASKS = {STD, OPS};
248    
249        //package private for testing purposes.
250        Log[] loggers;
251    
252        private String prefix = "";
253    
254        /**
255         * Create a <code>XLog</code> with no prefix.
256         *
257         * @param log Log instance to use for logging.
258         */
259        public XLog(Log log) {
260            this(log, "");
261        }
262    
263        /**
264         * Create a <code>XLog</code> with a common prefix. <p/> The prefix will be prepended to all log messages.
265         *
266         * @param log Log instance to use for logging.
267         * @param prefix common prefix to use for all log messages.
268         */
269        public XLog(Log log, String prefix) {
270            this.prefix = prefix;
271            loggers = new Log[2];
272            loggers[0] = log;
273            loggers[1] = LogFactory.getLog("oozieops");
274        }
275    
276        /**
277         * Return the common prefix.
278         *
279         * @return the common prefix.
280         */
281        public String getMsgPrefix() {
282            return prefix;
283        }
284    
285        /**
286         * Set the common prefix.
287         *
288         * @param prefix the common prefix to set.
289         */
290        public void setMsgPrefix(String prefix) {
291            this.prefix = (prefix != null) ? prefix : "";
292        }
293    
294        //All the methods from the commonsLogging Log interface will log to the default logger only.
295    
296        /**
297         * Log a debug message to the common <code>Log</code>.
298         *
299         * @param o message.
300         */
301        @Override
302        public void debug(Object o) {
303            log(Level.DEBUG, STD, "{0}", o);
304        }
305    
306        /**
307         * Log a debug message and <code>Exception</code> to the common <code>Log</code>.
308         *
309         * @param o message.
310         * @param throwable exception.
311         */
312        @Override
313        public void debug(Object o, Throwable throwable) {
314            log(Level.DEBUG, STD, "{0}", o, throwable);
315        }
316    
317        /**
318         * Log a error message to the common <code>Log</code>.
319         *
320         * @param o message.
321         */
322        @Override
323        public void error(Object o) {
324            log(Level.ERROR, STD, "{0}", o);
325        }
326    
327        /**
328         * Log a error message and <code>Exception</code> to the common <code>Log</code>.
329         *
330         * @param o message.
331         * @param throwable exception.
332         */
333        @Override
334        public void error(Object o, Throwable throwable) {
335            log(Level.ERROR, STD, "{0}", o, throwable);
336        }
337    
338        /**
339         * Log a fatal message to the common <code>Log</code>.
340         *
341         * @param o message.
342         */
343        @Override
344        public void fatal(Object o) {
345            log(Level.FATAL, STD, "{0}", o);
346        }
347    
348        /**
349         * Log a fatal message and <code>Exception</code> to the common <code>Log</code>.
350         *
351         * @param o message.
352         * @param throwable exception.
353         */
354        @Override
355        public void fatal(Object o, Throwable throwable) {
356            log(Level.FATAL, STD, "{0}", o, throwable);
357        }
358    
359        /**
360         * Log a info message to the common <code>Log</code>.
361         *
362         * @param o message.
363         */
364        @Override
365        public void info(Object o) {
366            log(Level.INFO, STD, "{0}", o);
367        }
368    
369        /**
370         * Log a info message and <code>Exception</code> to the common <code>Log</code>.
371         *
372         * @param o message.
373         * @param throwable exception.
374         */
375        @Override
376        public void info(Object o, Throwable throwable) {
377            log(Level.INFO, STD, "{0}", o, throwable);
378        }
379    
380        /**
381         * Log a trace message to the common <code>Log</code>.
382         *
383         * @param o message.
384         */
385        @Override
386        public void trace(Object o) {
387            log(Level.TRACE, STD, "{0}", o);
388        }
389    
390        /**
391         * Log a trace message and <code>Exception</code> to the common <code>Log</code>.
392         *
393         * @param o message.
394         * @param throwable exception.
395         */
396        @Override
397        public void trace(Object o, Throwable throwable) {
398            log(Level.TRACE, STD, "{0}", o, throwable);
399        }
400    
401        /**
402         * Log a warn message to the common <code>Log</code>.
403         *
404         * @param o message.
405         */
406        @Override
407        public void warn(Object o) {
408            log(Level.WARN, STD, "{0}", o);
409        }
410    
411        /**
412         * Log a warn message and <code>Exception</code> to the common <code>Log</code>.
413         *
414         * @param o message.
415         * @param throwable exception.
416         */
417        @Override
418        public void warn(Object o, Throwable throwable) {
419            log(Level.WARN, STD, "{0}", o, throwable);
420        }
421    
422        /**
423         * Return if debug logging is enabled.
424         *
425         * @return <code>true</code> if debug logging is enable, <code>false</code> if not.
426         */
427        @Override
428        public boolean isDebugEnabled() {
429            return isEnabled(Level.DEBUG, ALL);
430        }
431    
432        /**
433         * Return if error logging is enabled.
434         *
435         * @return <code>true</code> if error logging is enable, <code>false</code> if not.
436         */
437        @Override
438        public boolean isErrorEnabled() {
439            return isEnabled(Level.ERROR, ALL);
440        }
441    
442        /**
443         * Return if fatal logging is enabled.
444         *
445         * @return <code>true</code> if fatal logging is enable, <code>false</code> if not.
446         */
447        @Override
448        public boolean isFatalEnabled() {
449            return isEnabled(Level.FATAL, ALL);
450        }
451    
452        /**
453         * Return if info logging is enabled.
454         *
455         * @return <code>true</code> if info logging is enable, <code>false</code> if not.
456         */
457        @Override
458        public boolean isInfoEnabled() {
459            return isEnabled(Level.INFO, ALL);
460        }
461    
462        /**
463         * Return if trace logging is enabled.
464         *
465         * @return <code>true</code> if trace logging is enable, <code>false</code> if not.
466         */
467        @Override
468        public boolean isTraceEnabled() {
469            return isEnabled(Level.TRACE, ALL);
470        }
471    
472        /**
473         * Return if warn logging is enabled.
474         *
475         * @return <code>true</code> if warn logging is enable, <code>false</code> if not.
476         */
477        @Override
478        public boolean isWarnEnabled() {
479            return isEnabled(Level.WARN, ALL);
480        }
481    
482        public enum Level {
483            FATAL, ERROR, INFO, WARN, DEBUG, TRACE
484        }
485    
486        private boolean isEnabled(Level level, int loggerMask) {
487            for (int i = 0; i < loggers.length; i++) {
488                if ((LOGGER_MASKS[i] & loggerMask) != 0) {
489                    boolean enabled = false;
490                    switch (level) {
491                        case FATAL:
492                            enabled = loggers[i].isFatalEnabled();
493                            break;
494                        case ERROR:
495                            enabled = loggers[i].isErrorEnabled();
496                            break;
497                        case INFO:
498                            enabled = loggers[i].isInfoEnabled();
499                            break;
500                        case WARN:
501                            enabled = loggers[i].isWarnEnabled();
502                            break;
503                        case DEBUG:
504                            enabled = loggers[i].isDebugEnabled();
505                            break;
506                        case TRACE:
507                            enabled = loggers[i].isTraceEnabled();
508                            break;
509                    }
510                    if (enabled) {
511                        return true;
512                    }
513                }
514            }
515            return false;
516        }
517    
518    
519        private void log(Level level, int loggerMask, String msgTemplate, Object... params) {
520            loggerMask |= STD;
521            if (isEnabled(level, loggerMask)) {
522                String prefix = getMsgPrefix();
523                prefix = (prefix != null && prefix.length() > 0) ? prefix + " " : "";
524    
525                String msg = prefix + format(msgTemplate, params);
526                Throwable throwable = getCause(params);
527    
528                for (int i = 0; i < LOGGER_MASKS.length; i++) {
529                    if (isEnabled(level, loggerMask & LOGGER_MASKS[i])) {
530                        Log log = loggers[i];
531                        switch (level) {
532                            case FATAL:
533                                log.fatal(msg, throwable);
534                                break;
535                            case ERROR:
536                                log.error(msg, throwable);
537                                break;
538                            case INFO:
539                                log.info(msg, throwable);
540                                break;
541                            case WARN:
542                                log.warn(msg, throwable);
543                                break;
544                            case DEBUG:
545                                log.debug(msg, throwable);
546                                break;
547                            case TRACE:
548                                log.trace(msg, throwable);
549                                break;
550                        }
551                    }
552                }
553            }
554        }
555    
556        /**
557         * Log a fatal message <code>Exception</code> to the common <code>Log</code>.
558         *
559         * @param msgTemplate message template.
560         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
561         */
562        public void fatal(String msgTemplate, Object... params) {
563            log(Level.FATAL, STD, msgTemplate, params);
564        }
565    
566        /**
567         * Log a error message <code>Exception</code> to the common <code>Log</code>.
568         *
569         * @param msgTemplate message template.
570         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
571         */
572        public void error(String msgTemplate, Object... params) {
573            log(Level.ERROR, STD, msgTemplate, params);
574        }
575    
576        /**
577         * Log a info message <code>Exception</code> to the common <code>Log</code>.
578         *
579         * @param msgTemplate message template.
580         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
581         */
582        public void info(String msgTemplate, Object... params) {
583            log(Level.INFO, STD, msgTemplate, params);
584        }
585    
586        /**
587         * Log a warn message <code>Exception</code> to the common <code>Log</code>.
588         *
589         * @param msgTemplate message template.
590         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
591         */
592        public void warn(String msgTemplate, Object... params) {
593            log(Level.WARN, STD, msgTemplate, params);
594        }
595    
596        /**
597         * Log a debug message <code>Exception</code> to the common <code>Log</code>.
598         *
599         * @param msgTemplate message template.
600         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
601         */
602        public void debug(String msgTemplate, Object... params) {
603            log(Level.DEBUG, STD, msgTemplate, params);
604        }
605    
606        /**
607         * Log a trace message <code>Exception</code> to the common <code>Log</code>.
608         *
609         * @param msgTemplate message template.
610         * @param params parameters for the message template. If the last parameter is an exception it is logged as such.
611         */
612        public void trace(String msgTemplate, Object... params) {
613            log(Level.TRACE, STD, msgTemplate, params);
614        }
615    
616        /**
617         * Tee Log a fatal message <code>Exception</code> to the common log and specified <code>Log</code>s.
618         *
619         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
620         * @param msgTemplate message template.
621         * @param params parameters for the message template.
622         */
623        public void fatal(int loggerMask, String msgTemplate, Object... params) {
624            log(Level.FATAL, loggerMask, msgTemplate, params);
625        }
626    
627        /**
628         * Tee Log a error message <code>Exception</code> to the common log and specified <code>Log</code>s.
629         *
630         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
631         * @param msgTemplate message template.
632         * @param params parameters for the message template.
633         */
634        public void error(int loggerMask, String msgTemplate, Object... params) {
635            log(Level.ERROR, loggerMask, msgTemplate, params);
636        }
637    
638        /**
639         * Tee Log a info message <code>Exception</code> to the common log and specified <code>Log</code>s.
640         *
641         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
642         * @param msgTemplate message template.
643         * @param params parameters for the message template.
644         */
645        public void info(int loggerMask, String msgTemplate, Object... params) {
646            log(Level.INFO, loggerMask, msgTemplate, params);
647        }
648    
649        /**
650         * Tee Log a warn message <code>Exception</code> to the common log and specified <code>Log</code>s.
651         *
652         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
653         * @param msgTemplate message template.
654         * @param params parameters for the message template.
655         */
656        public void warn(int loggerMask, String msgTemplate, Object... params) {
657            log(Level.WARN, loggerMask, msgTemplate, params);
658        }
659    
660        /**
661         * Tee Log a debug message <code>Exception</code> to the common log and specified <code>Log</code>s.
662         *
663         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
664         * @param msgTemplate message template.
665         * @param params parameters for the message template.
666         */
667        public void debug(int loggerMask, String msgTemplate, Object... params) {
668            log(Level.DEBUG, loggerMask, msgTemplate, params);
669        }
670    
671        /**
672         * Tee Log a trace message <code>Exception</code> to the common log and specified <code>Log</code>s.
673         *
674         * @param loggerMask log mask, it is a bit mask, possible values are <code>APP</code> and <code>OPS</code>.
675         * @param msgTemplate message template.
676         * @param params parameters for the message template.
677         */
678        public void trace(int loggerMask, String msgTemplate, Object... params) {
679            log(Level.TRACE, loggerMask, msgTemplate, params);
680        }
681    
682        /**
683         * Utility method that does uses the <code>StringFormat</code> to format the message template using the provided
684         * parameters. <p/> In addition to the <code>StringFormat</code> syntax for message templates, it supports
685         * <code>{E}</code> for ENTER. <p/> The last parameter is ignored for the formatting if it is an Exception.
686         *
687         * @param msgTemplate message template.
688         * @param params paramaters to use in the template. If the last parameter is an Exception, it is ignored.
689         * @return formatted message.
690         */
691        public static String format(String msgTemplate, Object... params) {
692            ParamChecker.notEmpty(msgTemplate, "msgTemplate");
693            msgTemplate = msgTemplate.replace("{E}", System.getProperty("line.separator"));
694            if (params != null && params.length > 0) {
695                msgTemplate = MessageFormat.format(msgTemplate, params);
696            }
697            return msgTemplate;
698        }
699    
700        /**
701         * Utility method that extracts the <code>Throwable</code>, if present, from the parameters.
702         *
703         * @param params parameters.
704         * @return a <code>Throwable</code> instance if it is the last parameter, <code>null</code> otherwise.
705         */
706        public static Throwable getCause(Object... params) {
707            Throwable throwable = null;
708            if (params != null && params.length > 0 && params[params.length - 1] instanceof Throwable) {
709                throwable = (Throwable) params[params.length - 1];
710            }
711            return throwable;
712        }
713    
714    }