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.Processor;
021 import org.apache.camel.impl.DefaultExchangeFormatter;
022 import org.apache.camel.processor.interceptor.ExchangeFormatter;
023 import org.apache.commons.logging.Log;
024 import org.apache.commons.logging.LogFactory;
025
026 /**
027 * A {@link Processor} which just logs to a {@link Log} object which can be used
028 * as an exception handler instead of using a dead letter queue.
029 *
030 * @version $Revision: 53974 $
031 */
032 public class Logger implements Processor {
033 private Log log;
034 private LoggingLevel level;
035 private ExchangeFormatter formatter = DefaultExchangeFormatter.getInstance();
036
037 public Logger() {
038 this(LogFactory.getLog(Logger.class));
039 }
040
041 public Logger(Log log) {
042 this(log, LoggingLevel.INFO);
043 }
044
045 public Logger(Log log, LoggingLevel level) {
046 this.log = log;
047 this.level = level;
048 }
049
050 public Logger(String logName) {
051 this(LogFactory.getLog(logName));
052 }
053
054 public Logger(String logName, LoggingLevel level) {
055 this(LogFactory.getLog(logName), level);
056 }
057
058 public Logger(Log log, ExchangeFormatter formatter) {
059 this(log);
060 this.formatter = formatter;
061 }
062
063 @Override
064 public String toString() {
065 return "Logger[" + log + "]";
066 }
067
068 public void process(Exchange exchange) {
069 switch (level) {
070 case DEBUG:
071 if (log.isDebugEnabled()) {
072 log.debug(logMessage(exchange));
073 }
074 break;
075 case ERROR:
076 if (log.isErrorEnabled()) {
077 log.error(logMessage(exchange));
078 }
079 break;
080 case FATAL:
081 if (log.isFatalEnabled()) {
082 log.fatal(logMessage(exchange));
083 }
084 break;
085 case INFO:
086 if (log.isInfoEnabled()) {
087 log.info(logMessage(exchange));
088 }
089 break;
090 case TRACE:
091 if (log.isTraceEnabled()) {
092 log.trace(logMessage(exchange));
093 }
094 break;
095 case WARN:
096 if (log.isWarnEnabled()) {
097 log.warn(logMessage(exchange));
098 }
099 break;
100 default:
101 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
102 }
103 }
104
105 public void process(Exchange exchange, Throwable exception) {
106 switch (level) {
107 case DEBUG:
108 if (log.isDebugEnabled()) {
109 log.debug(logMessage(exchange), exception);
110 }
111 break;
112 case ERROR:
113 if (log.isErrorEnabled()) {
114 log.error(logMessage(exchange), exception);
115 }
116 break;
117 case FATAL:
118 if (log.isFatalEnabled()) {
119 log.fatal(logMessage(exchange), exception);
120 }
121 break;
122 case INFO:
123 if (log.isInfoEnabled()) {
124 log.info(logMessage(exchange), exception);
125 }
126 break;
127 case TRACE:
128 if (log.isTraceEnabled()) {
129 log.trace(logMessage(exchange), exception);
130 }
131 break;
132 case WARN:
133 if (log.isWarnEnabled()) {
134 log.warn(logMessage(exchange), exception);
135 }
136 break;
137 default:
138 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
139 }
140 }
141
142 public void log(String message) {
143 switch (level) {
144 case DEBUG:
145 if (log.isDebugEnabled()) {
146 log.debug(message);
147 }
148 break;
149 case ERROR:
150 if (log.isErrorEnabled()) {
151 log.error(message);
152 }
153 break;
154 case FATAL:
155 if (log.isFatalEnabled()) {
156 log.fatal(message);
157 }
158 break;
159 case INFO:
160 if (log.isInfoEnabled()) {
161 log.debug(message);
162 }
163 break;
164 case TRACE:
165 if (log.isTraceEnabled()) {
166 log.trace(message);
167 }
168 break;
169 case WARN:
170 if (log.isWarnEnabled()) {
171 log.warn(message);
172 }
173 break;
174 default:
175 log.error("Unknown level: " + level + " when trying to log exchange: " + message);
176 }
177 }
178
179 public void log(String message, Throwable exception) {
180 switch (level) {
181 case DEBUG:
182 if (log.isDebugEnabled()) {
183 log.debug(message, exception);
184 }
185 break;
186 case ERROR:
187 if (log.isErrorEnabled()) {
188 log.error(message, exception);
189 }
190 break;
191 case FATAL:
192 if (log.isFatalEnabled()) {
193 log.fatal(message, exception);
194 }
195 break;
196 case INFO:
197 if (log.isInfoEnabled()) {
198 log.debug(message, exception);
199 }
200 break;
201 case TRACE:
202 if (log.isTraceEnabled()) {
203 log.trace(message, exception);
204 }
205 break;
206 case WARN:
207 if (log.isWarnEnabled()) {
208 log.warn(message, exception);
209 }
210 break;
211 case OFF:
212 break;
213 default:
214 log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception);
215 }
216 }
217
218 protected Object logMessage(Exchange exchange) {
219 return formatter.format(exchange);
220 }
221
222 public Log getLog() {
223 return log;
224 }
225
226 public void setLog(Log log) {
227 this.log = log;
228 }
229
230 public LoggingLevel getLevel() {
231 return level;
232 }
233
234 public void setLevel(LoggingLevel level) {
235 this.level = level;
236 }
237
238 public void setFormatter(ExchangeFormatter formatter) {
239 this.formatter = formatter;
240 }
241 }