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 }