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 }