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 }