001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.camel.processor;
018    
019    import org.apache.camel.Exchange;
020    import org.apache.camel.LoggingLevel;
021    import org.apache.camel.Processor;
022    import org.apache.camel.impl.DefaultExchangeFormatter;
023    import org.apache.camel.spi.ExchangeFormatter;
024    import org.apache.commons.logging.Log;
025    import org.apache.commons.logging.LogFactory;
026    
027    /**
028     * A {@link Processor} which just logs to a {@link Log} object which can be used
029     * as an exception handler instead of using a dead letter queue.
030     *
031     * @version $Revision: 749227 $
032     */
033    public class Logger implements Processor {
034        private Log log;
035        private LoggingLevel level;
036        private ExchangeFormatter formatter = DefaultExchangeFormatter.getInstance();
037    
038        public Logger() {
039            this(LogFactory.getLog(Logger.class));
040        }
041    
042        public Logger(Log log) {
043            this(log, LoggingLevel.INFO);
044        }
045    
046        public Logger(Log log, LoggingLevel level) {
047            this.log = log;
048            this.level = level;
049        }
050    
051        public Logger(String logName) {
052            this(LogFactory.getLog(logName));
053        }
054    
055        public Logger(String logName, LoggingLevel level) {
056            this(LogFactory.getLog(logName), level);
057        }
058    
059        public Logger(Log log, ExchangeFormatter formatter) {
060            this(log);
061            this.formatter = formatter;
062        }
063    
064        @Override
065        public String toString() {
066            return "Logger[" + log + "]";
067        }
068    
069        public void process(Exchange exchange) {
070            switch (level) {
071            case DEBUG:
072                if (log.isDebugEnabled()) {
073                    log.debug(logMessage(exchange));
074                }
075                break;
076            case ERROR:
077                if (log.isErrorEnabled()) {
078                    log.error(logMessage(exchange));
079                }
080                break;
081            case FATAL:
082                if (log.isFatalEnabled()) {
083                    log.fatal(logMessage(exchange));
084                }
085                break;
086            case INFO:
087                if (log.isInfoEnabled()) {
088                    log.info(logMessage(exchange));
089                }
090                break;
091            case TRACE:
092                if (log.isTraceEnabled()) {
093                    log.trace(logMessage(exchange));
094                }
095                break;
096            case WARN:
097                if (log.isWarnEnabled()) {
098                    log.warn(logMessage(exchange));
099                }
100                break;
101            case OFF:
102                break;
103            default:
104                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
105            }
106        }
107    
108        public void process(Exchange exchange, Throwable exception) {
109            switch (level) {
110            case DEBUG:
111                if (log.isDebugEnabled()) {
112                    log.debug(logMessage(exchange), exception);
113                }
114                break;
115            case ERROR:
116                if (log.isErrorEnabled()) {
117                    log.error(logMessage(exchange), exception);
118                }
119                break;
120            case FATAL:
121                if (log.isFatalEnabled()) {
122                    log.fatal(logMessage(exchange), exception);
123                }
124                break;
125            case INFO:
126                if (log.isInfoEnabled()) {
127                    log.info(logMessage(exchange), exception);
128                }
129                break;
130            case TRACE:
131                if (log.isTraceEnabled()) {
132                    log.trace(logMessage(exchange), exception);
133                }
134                break;
135            case WARN:
136                if (log.isWarnEnabled()) {
137                    log.warn(logMessage(exchange), exception);
138                }
139                break;
140            default:
141                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
142            }
143        }
144    
145        public void log(String message, LoggingLevel loggingLevel) {
146            LoggingLevel oldLogLevel = getLevel();
147            setLevel(loggingLevel);
148            log(message);
149            setLevel(oldLogLevel);
150        }
151        
152        public void log(String message) {
153            switch (level) {
154            case DEBUG:
155                if (log.isDebugEnabled()) {
156                    log.debug(message);
157                }
158                break;
159            case ERROR:
160                if (log.isErrorEnabled()) {
161                    log.error(message);
162                }
163                break;
164            case FATAL:
165                if (log.isFatalEnabled()) {
166                    log.fatal(message);
167                }
168                break;
169            case INFO:
170                if (log.isInfoEnabled()) {
171                    log.debug(message);
172                }
173                break;
174            case TRACE:
175                if (log.isTraceEnabled()) {
176                    log.trace(message);
177                }
178                break;
179            case WARN:
180                if (log.isWarnEnabled()) {
181                    log.warn(message);
182                }
183                break;
184            case OFF:
185                break;
186            default:
187                log.error("Unknown level: " + level + " when trying to log exchange: " + message);
188            }
189        }
190    
191        public void log(String message, Throwable exception, LoggingLevel loggingLevel) {
192            LoggingLevel oldLogLevel = getLevel();
193            setLevel(loggingLevel);
194            log(message, exception);
195            setLevel(oldLogLevel);
196        }   
197        
198        public void log(String message, Throwable exception) {
199            switch (level) {
200            case DEBUG:
201                if (log.isDebugEnabled()) {
202                    log.debug(message, exception);
203                }
204                break;
205            case ERROR:
206                if (log.isErrorEnabled()) {
207                    log.error(message, exception);
208                }
209                break;
210            case FATAL:
211                if (log.isFatalEnabled()) {
212                    log.fatal(message, exception);
213                }
214                break;
215            case INFO:
216                if (log.isInfoEnabled()) {
217                    log.debug(message, exception);
218                }
219                break;
220            case TRACE:
221                if (log.isTraceEnabled()) {
222                    log.trace(message, exception);
223                }
224                break;
225            case WARN:
226                if (log.isWarnEnabled()) {
227                    log.warn(message, exception);
228                }
229                break;
230            case OFF:
231                break;
232            default:
233                log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception);
234            }
235        }
236    
237        protected Object logMessage(Exchange exchange) {
238            return formatter.format(exchange);
239        }
240    
241        public Log getLog() {
242            return log;
243        }
244    
245        public void setLog(Log log) {
246            this.log = log;
247        }
248    
249        public LoggingLevel getLevel() {
250            return level;
251        }
252    
253        public void setLevel(LoggingLevel level) {
254            this.level = level;
255        }
256    
257        public void setFormatter(ExchangeFormatter formatter) {
258            this.formatter = formatter;
259        }
260    
261        public void setLogName(String logName) {
262            this.log = LogFactory.getLog(logName);
263        }
264    }