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.spi.ExchangeFormatter;
023    import org.apache.camel.support.ServiceSupport;
024    import org.slf4j.Logger;
025    import org.slf4j.LoggerFactory;
026    
027    /**
028     * A {@link Processor} which just logs to a {@link CamelLogger} object which can be used
029     * as an exception handler instead of using a dead letter queue.
030     * <p/>
031     * The name <tt>CamelLogger</tt> has been chosen to avoid any name clash with log kits
032     * which has a <tt>Logger</tt> class.
033     *
034     * @deprecated This class has been split up into org.apache.camel.util.CamelLogger and org.apache.camel.processor.CamelLogProcessor 
035     */
036    @Deprecated
037    public class CamelLogger extends ServiceSupport implements Processor {
038        private Logger log;
039        private LoggingLevel level;
040        private ExchangeFormatter formatter;
041    
042        public CamelLogger() {
043            this(LoggerFactory.getLogger(CamelLogger.class));
044        }
045    
046        public CamelLogger(Logger log) {
047            this(log, LoggingLevel.INFO);
048        }
049    
050        public CamelLogger(Logger log, LoggingLevel level) {
051            this.formatter = new CamelLogProcessor.DefaultExchangeFormatter();
052            this.log = log;
053            this.level = level;
054        }
055    
056        public CamelLogger(String logName) {
057            this(LoggerFactory.getLogger(logName));
058        }
059    
060        public CamelLogger(String logName, LoggingLevel level) {
061            this(LoggerFactory.getLogger(logName), level);
062        }
063    
064        public CamelLogger(Logger log, ExchangeFormatter formatter) {
065            this(log);
066            this.formatter = formatter;
067        }
068    
069        @Override
070        public String toString() {
071            return "Logger[" + log + "]";
072        }
073    
074        public void process(Exchange exchange) {
075            switch (level) {
076            case DEBUG:
077                if (log.isDebugEnabled()) {
078                    log.debug(logMessage(exchange));
079                }
080                break;
081            case ERROR:
082                if (log.isErrorEnabled()) {
083                    log.error(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 INFO:
121                if (log.isInfoEnabled()) {
122                    log.info(logMessage(exchange), exception);
123                }
124                break;
125            case TRACE:
126                if (log.isTraceEnabled()) {
127                    log.trace(logMessage(exchange), exception);
128                }
129                break;
130            case WARN:
131                if (log.isWarnEnabled()) {
132                    log.warn(logMessage(exchange), exception);
133                }
134                break;
135            case OFF:
136                break;
137            default:
138                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
139            }
140        }
141    
142        public void process(Exchange exchange, String message) {
143            switch (level) {
144            case DEBUG:
145                if (log.isDebugEnabled()) {
146                    log.debug(logMessage(exchange, message));
147                }
148                break;
149            case ERROR:
150                if (log.isErrorEnabled()) {
151                    log.error(logMessage(exchange, message));
152                }
153                break;
154            case INFO:
155                if (log.isInfoEnabled()) {
156                    log.info(logMessage(exchange, message));
157                }
158                break;
159            case TRACE:
160                if (log.isTraceEnabled()) {
161                    log.trace(logMessage(exchange, message));
162                }
163                break;
164            case WARN:
165                if (log.isWarnEnabled()) {
166                    log.warn(logMessage(exchange, message));
167                }
168                break;
169            case OFF:
170                break;
171            default:
172                log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange, message));
173            }
174        }
175    
176        public void log(String message, LoggingLevel loggingLevel) {
177            LoggingLevel oldLogLevel = getLevel();
178            setLevel(loggingLevel);
179            log(message);
180            setLevel(oldLogLevel);
181        }
182        
183        public void log(String message) {
184            switch (level) {
185            case DEBUG:
186                if (log.isDebugEnabled()) {
187                    log.debug(message);
188                }
189                break;
190            case ERROR:
191                if (log.isErrorEnabled()) {
192                    log.error(message);
193                }
194                break;
195            case INFO:
196                if (log.isInfoEnabled()) {
197                    log.info(message);
198                }
199                break;
200            case TRACE:
201                if (log.isTraceEnabled()) {
202                    log.trace(message);
203                }
204                break;
205            case WARN:
206                if (log.isWarnEnabled()) {
207                    log.warn(message);
208                }
209                break;
210            case OFF:
211                break;
212            default:
213                log.error("Unknown level: " + level + " when trying to log exchange: " + message);
214            }
215        }
216    
217        public void log(String message, Throwable exception, LoggingLevel loggingLevel) {
218            LoggingLevel oldLogLevel = getLevel();
219            setLevel(loggingLevel);
220            log(message, exception);
221            setLevel(oldLogLevel);
222        }   
223        
224        public void log(String message, Throwable exception) {
225            switch (level) {
226            case DEBUG:
227                if (log.isDebugEnabled()) {
228                    log.debug(message, exception);
229                }
230                break;
231            case ERROR:
232                if (log.isErrorEnabled()) {
233                    log.error(message, exception);
234                }
235                break;
236            case INFO:
237                if (log.isInfoEnabled()) {
238                    log.info(message, exception);
239                }
240                break;
241            case TRACE:
242                if (log.isTraceEnabled()) {
243                    log.trace(message, exception);
244                }
245                break;
246            case WARN:
247                if (log.isWarnEnabled()) {
248                    log.warn(message, exception);
249                }
250                break;
251            case OFF:
252                break;
253            default:
254                log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception);
255            }
256        }
257    
258        protected String logMessage(Exchange exchange) {
259            return formatter.format(exchange);
260        }
261    
262        protected String logMessage(Exchange exchange, String message) {
263            return formatter.format(exchange) + message;
264        }
265    
266        public Logger getLog() {
267            return log;
268        }
269    
270        public void setLog(Logger log) {
271            this.log = log;
272        }
273    
274        public LoggingLevel getLevel() {
275            return level;
276        }
277    
278        public void setLevel(LoggingLevel level) {
279            this.level = level;
280        }
281    
282        public void setFormatter(ExchangeFormatter formatter) {
283            this.formatter = formatter;
284        }
285    
286        public void setLogName(String logName) {
287            this.log = LoggerFactory.getLogger(logName);
288        }
289    
290        @Override
291        protected void doStart() throws Exception {
292            // noop
293        }
294    
295        @Override
296        protected void doStop() throws Exception {
297            // noop
298        }
299    }