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: 788585 $ 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 case OFF: 141 break; 142 default: 143 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange)); 144 } 145 } 146 147 public void process(Exchange exchange, String message) { 148 switch (level) { 149 case DEBUG: 150 if (log.isDebugEnabled()) { 151 log.debug(logMessage(exchange, message)); 152 } 153 break; 154 case ERROR: 155 if (log.isErrorEnabled()) { 156 log.error(logMessage(exchange, message)); 157 } 158 break; 159 case FATAL: 160 if (log.isFatalEnabled()) { 161 log.fatal(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 FATAL: 206 if (log.isFatalEnabled()) { 207 log.fatal(message); 208 } 209 break; 210 case INFO: 211 if (log.isInfoEnabled()) { 212 log.debug(message); 213 } 214 break; 215 case TRACE: 216 if (log.isTraceEnabled()) { 217 log.trace(message); 218 } 219 break; 220 case WARN: 221 if (log.isWarnEnabled()) { 222 log.warn(message); 223 } 224 break; 225 case OFF: 226 break; 227 default: 228 log.error("Unknown level: " + level + " when trying to log exchange: " + message); 229 } 230 } 231 232 public void log(String message, Throwable exception, LoggingLevel loggingLevel) { 233 LoggingLevel oldLogLevel = getLevel(); 234 setLevel(loggingLevel); 235 log(message, exception); 236 setLevel(oldLogLevel); 237 } 238 239 public void log(String message, Throwable exception) { 240 switch (level) { 241 case DEBUG: 242 if (log.isDebugEnabled()) { 243 log.debug(message, exception); 244 } 245 break; 246 case ERROR: 247 if (log.isErrorEnabled()) { 248 log.error(message, exception); 249 } 250 break; 251 case FATAL: 252 if (log.isFatalEnabled()) { 253 log.fatal(message, exception); 254 } 255 break; 256 case INFO: 257 if (log.isInfoEnabled()) { 258 log.debug(message, exception); 259 } 260 break; 261 case TRACE: 262 if (log.isTraceEnabled()) { 263 log.trace(message, exception); 264 } 265 break; 266 case WARN: 267 if (log.isWarnEnabled()) { 268 log.warn(message, exception); 269 } 270 break; 271 case OFF: 272 break; 273 default: 274 log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception); 275 } 276 } 277 278 protected Object logMessage(Exchange exchange) { 279 return formatter.format(exchange); 280 } 281 282 protected Object logMessage(Exchange exchange, String message) { 283 return formatter.format(exchange) + message; 284 } 285 286 public Log getLog() { 287 return log; 288 } 289 290 public void setLog(Log log) { 291 this.log = log; 292 } 293 294 public LoggingLevel getLevel() { 295 return level; 296 } 297 298 public void setLevel(LoggingLevel level) { 299 this.level = level; 300 } 301 302 public void setFormatter(ExchangeFormatter formatter) { 303 this.formatter = formatter; 304 } 305 306 public void setLogName(String logName) { 307 this.log = LogFactory.getLog(logName); 308 } 309 }