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: 788585 $
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            case OFF:
141                break;
142            default:
143                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
144            }
145        }
146    
147        public void process(Exchange exchange, String message) {
148            switch (level) {
149            case DEBUG:
150                if (log.isDebugEnabled()) {
151                    log.debug(logMessage(exchange, message));
152                }
153                break;
154            case ERROR:
155                if (log.isErrorEnabled()) {
156                    log.error(logMessage(exchange, message));
157                }
158                break;
159            case FATAL:
160                if (log.isFatalEnabled()) {
161                    log.fatal(logMessage(exchange, message));
162                }
163                break;
164            case INFO:
165                if (log.isInfoEnabled()) {
166                    log.info(logMessage(exchange, message));
167                }
168                break;
169            case TRACE:
170                if (log.isTraceEnabled()) {
171                    log.trace(logMessage(exchange, message));
172                }
173                break;
174            case WARN:
175                if (log.isWarnEnabled()) {
176                    log.warn(logMessage(exchange, message));
177                }
178                break;
179            case OFF:
180                break;
181            default:
182                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange, message));
183            }
184        }
185    
186        public void log(String message, LoggingLevel loggingLevel) {
187            LoggingLevel oldLogLevel = getLevel();
188            setLevel(loggingLevel);
189            log(message);
190            setLevel(oldLogLevel);
191        }
192        
193        public void log(String message) {
194            switch (level) {
195            case DEBUG:
196                if (log.isDebugEnabled()) {
197                    log.debug(message);
198                }
199                break;
200            case ERROR:
201                if (log.isErrorEnabled()) {
202                    log.error(message);
203                }
204                break;
205            case FATAL:
206                if (log.isFatalEnabled()) {
207                    log.fatal(message);
208                }
209                break;
210            case INFO:
211                if (log.isInfoEnabled()) {
212                    log.debug(message);
213                }
214                break;
215            case TRACE:
216                if (log.isTraceEnabled()) {
217                    log.trace(message);
218                }
219                break;
220            case WARN:
221                if (log.isWarnEnabled()) {
222                    log.warn(message);
223                }
224                break;
225            case OFF:
226                break;
227            default:
228                log.error("Unknown level: " + level + " when trying to log exchange: " + message);
229            }
230        }
231    
232        public void log(String message, Throwable exception, LoggingLevel loggingLevel) {
233            LoggingLevel oldLogLevel = getLevel();
234            setLevel(loggingLevel);
235            log(message, exception);
236            setLevel(oldLogLevel);
237        }   
238        
239        public void log(String message, Throwable exception) {
240            switch (level) {
241            case DEBUG:
242                if (log.isDebugEnabled()) {
243                    log.debug(message, exception);
244                }
245                break;
246            case ERROR:
247                if (log.isErrorEnabled()) {
248                    log.error(message, exception);
249                }
250                break;
251            case FATAL:
252                if (log.isFatalEnabled()) {
253                    log.fatal(message, exception);
254                }
255                break;
256            case INFO:
257                if (log.isInfoEnabled()) {
258                    log.debug(message, exception);
259                }
260                break;
261            case TRACE:
262                if (log.isTraceEnabled()) {
263                    log.trace(message, exception);
264                }
265                break;
266            case WARN:
267                if (log.isWarnEnabled()) {
268                    log.warn(message, exception);
269                }
270                break;
271            case OFF:
272                break;
273            default:
274                log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception);
275            }
276        }
277    
278        protected Object logMessage(Exchange exchange) {
279            return formatter.format(exchange);
280        }
281    
282        protected Object logMessage(Exchange exchange, String message) {
283            return formatter.format(exchange) + message;
284        }
285    
286        public Log getLog() {
287            return log;
288        }
289    
290        public void setLog(Log log) {
291            this.log = log;
292        }
293    
294        public LoggingLevel getLevel() {
295            return level;
296        }
297    
298        public void setLevel(LoggingLevel level) {
299            this.level = level;
300        }
301    
302        public void setFormatter(ExchangeFormatter formatter) {
303            this.formatter = formatter;
304        }
305    
306        public void setLogName(String logName) {
307            this.log = LogFactory.getLog(logName);
308        }
309    }