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.AsyncCallback;
020 import org.apache.camel.AsyncProcessor;
021 import org.apache.camel.Exchange;
022 import org.apache.camel.LoggingLevel;
023 import org.apache.camel.Processor;
024 import org.apache.camel.spi.ExchangeFormatter;
025 import org.apache.camel.support.ServiceSupport;
026 import org.apache.camel.util.AsyncProcessorHelper;
027 import org.slf4j.Logger;
028 import org.slf4j.LoggerFactory;
029
030 /**
031 * A {@link Processor} which just logs to a {@link CamelLogger} object which can be used
032 * as an exception handler instead of using a dead letter queue.
033 * <p/>
034 * The name <tt>CamelLogger</tt> has been chosen to avoid any name clash with log kits
035 * which has a <tt>Logger</tt> class.
036 *
037 * @deprecated This class has been split up into org.apache.camel.util.CamelLogger and org.apache.camel.processor.CamelLogProcessor
038 */
039 @Deprecated
040 public class CamelLogger extends ServiceSupport implements AsyncProcessor {
041 private Logger log;
042 private LoggingLevel level;
043 private ExchangeFormatter formatter;
044
045 public CamelLogger() {
046 this(LoggerFactory.getLogger(CamelLogger.class));
047 }
048
049 public CamelLogger(Logger log) {
050 this(log, LoggingLevel.INFO);
051 }
052
053 public CamelLogger(Logger log, LoggingLevel level) {
054 this.formatter = new CamelLogProcessor.ToStringExchangeFormatter();
055 this.log = log;
056 this.level = level;
057 }
058
059 public CamelLogger(String logName) {
060 this(LoggerFactory.getLogger(logName));
061 }
062
063 public CamelLogger(String logName, LoggingLevel level) {
064 this(LoggerFactory.getLogger(logName), level);
065 }
066
067 public CamelLogger(Logger log, ExchangeFormatter formatter) {
068 this(log);
069 this.formatter = formatter;
070 }
071
072 @Override
073 public String toString() {
074 return "Logger[" + log + "]";
075 }
076
077 public void process(Exchange exchange) throws Exception {
078 AsyncProcessorHelper.process(this, exchange);
079 }
080
081 public boolean process(Exchange exchange, AsyncCallback callback) {
082 switch (level) {
083 case DEBUG:
084 if (log.isDebugEnabled()) {
085 log.debug(logMessage(exchange));
086 }
087 break;
088 case ERROR:
089 if (log.isErrorEnabled()) {
090 log.error(logMessage(exchange));
091 }
092 break;
093 case INFO:
094 if (log.isInfoEnabled()) {
095 log.info(logMessage(exchange));
096 }
097 break;
098 case TRACE:
099 if (log.isTraceEnabled()) {
100 log.trace(logMessage(exchange));
101 }
102 break;
103 case WARN:
104 if (log.isWarnEnabled()) {
105 log.warn(logMessage(exchange));
106 }
107 break;
108 case OFF:
109 break;
110 default:
111 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
112 }
113
114 callback.done(true);
115 return true;
116 }
117
118 public void process(Exchange exchange, Throwable exception) {
119 switch (level) {
120 case DEBUG:
121 if (log.isDebugEnabled()) {
122 log.debug(logMessage(exchange), exception);
123 }
124 break;
125 case ERROR:
126 if (log.isErrorEnabled()) {
127 log.error(logMessage(exchange), exception);
128 }
129 break;
130 case INFO:
131 if (log.isInfoEnabled()) {
132 log.info(logMessage(exchange), exception);
133 }
134 break;
135 case TRACE:
136 if (log.isTraceEnabled()) {
137 log.trace(logMessage(exchange), exception);
138 }
139 break;
140 case WARN:
141 if (log.isWarnEnabled()) {
142 log.warn(logMessage(exchange), exception);
143 }
144 break;
145 case OFF:
146 break;
147 default:
148 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange));
149 }
150 }
151
152 public void process(Exchange exchange, String message) {
153 switch (level) {
154 case DEBUG:
155 if (log.isDebugEnabled()) {
156 log.debug(logMessage(exchange, message));
157 }
158 break;
159 case ERROR:
160 if (log.isErrorEnabled()) {
161 log.error(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 INFO:
206 if (log.isInfoEnabled()) {
207 log.info(message);
208 }
209 break;
210 case TRACE:
211 if (log.isTraceEnabled()) {
212 log.trace(message);
213 }
214 break;
215 case WARN:
216 if (log.isWarnEnabled()) {
217 log.warn(message);
218 }
219 break;
220 case OFF:
221 break;
222 default:
223 log.error("Unknown level: " + level + " when trying to log exchange: " + message);
224 }
225 }
226
227 public void log(String message, Throwable exception, LoggingLevel loggingLevel) {
228 LoggingLevel oldLogLevel = getLevel();
229 setLevel(loggingLevel);
230 log(message, exception);
231 setLevel(oldLogLevel);
232 }
233
234 public void log(String message, Throwable exception) {
235 switch (level) {
236 case DEBUG:
237 if (log.isDebugEnabled()) {
238 log.debug(message, exception);
239 }
240 break;
241 case ERROR:
242 if (log.isErrorEnabled()) {
243 log.error(message, exception);
244 }
245 break;
246 case INFO:
247 if (log.isInfoEnabled()) {
248 log.info(message, exception);
249 }
250 break;
251 case TRACE:
252 if (log.isTraceEnabled()) {
253 log.trace(message, exception);
254 }
255 break;
256 case WARN:
257 if (log.isWarnEnabled()) {
258 log.warn(message, exception);
259 }
260 break;
261 case OFF:
262 break;
263 default:
264 log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception);
265 }
266 }
267
268 protected String logMessage(Exchange exchange) {
269 return formatter.format(exchange);
270 }
271
272 protected String logMessage(Exchange exchange, String message) {
273 return formatter.format(exchange) + message;
274 }
275
276 public Logger getLog() {
277 return log;
278 }
279
280 public void setLog(Logger log) {
281 this.log = log;
282 }
283
284 public LoggingLevel getLevel() {
285 return level;
286 }
287
288 public void setLevel(LoggingLevel level) {
289 this.level = level;
290 }
291
292 public void setFormatter(ExchangeFormatter formatter) {
293 this.formatter = formatter;
294 }
295
296 public void setLogName(String logName) {
297 this.log = LoggerFactory.getLogger(logName);
298 }
299
300 @Override
301 protected void doStart() throws Exception {
302 // noop
303 }
304
305 @Override
306 protected void doStop() throws Exception {
307 // noop
308 }
309 }