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 }