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: 749227 $ 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 default: 141 log.error("Unknown level: " + level + " when trying to log exchange: " + logMessage(exchange)); 142 } 143 } 144 145 public void log(String message, LoggingLevel loggingLevel) { 146 LoggingLevel oldLogLevel = getLevel(); 147 setLevel(loggingLevel); 148 log(message); 149 setLevel(oldLogLevel); 150 } 151 152 public void log(String message) { 153 switch (level) { 154 case DEBUG: 155 if (log.isDebugEnabled()) { 156 log.debug(message); 157 } 158 break; 159 case ERROR: 160 if (log.isErrorEnabled()) { 161 log.error(message); 162 } 163 break; 164 case FATAL: 165 if (log.isFatalEnabled()) { 166 log.fatal(message); 167 } 168 break; 169 case INFO: 170 if (log.isInfoEnabled()) { 171 log.debug(message); 172 } 173 break; 174 case TRACE: 175 if (log.isTraceEnabled()) { 176 log.trace(message); 177 } 178 break; 179 case WARN: 180 if (log.isWarnEnabled()) { 181 log.warn(message); 182 } 183 break; 184 case OFF: 185 break; 186 default: 187 log.error("Unknown level: " + level + " when trying to log exchange: " + message); 188 } 189 } 190 191 public void log(String message, Throwable exception, LoggingLevel loggingLevel) { 192 LoggingLevel oldLogLevel = getLevel(); 193 setLevel(loggingLevel); 194 log(message, exception); 195 setLevel(oldLogLevel); 196 } 197 198 public void log(String message, Throwable exception) { 199 switch (level) { 200 case DEBUG: 201 if (log.isDebugEnabled()) { 202 log.debug(message, exception); 203 } 204 break; 205 case ERROR: 206 if (log.isErrorEnabled()) { 207 log.error(message, exception); 208 } 209 break; 210 case FATAL: 211 if (log.isFatalEnabled()) { 212 log.fatal(message, exception); 213 } 214 break; 215 case INFO: 216 if (log.isInfoEnabled()) { 217 log.debug(message, exception); 218 } 219 break; 220 case TRACE: 221 if (log.isTraceEnabled()) { 222 log.trace(message, exception); 223 } 224 break; 225 case WARN: 226 if (log.isWarnEnabled()) { 227 log.warn(message, exception); 228 } 229 break; 230 case OFF: 231 break; 232 default: 233 log.error("Unknown level: " + level + " when trying to log exchange: " + message, exception); 234 } 235 } 236 237 protected Object logMessage(Exchange exchange) { 238 return formatter.format(exchange); 239 } 240 241 public Log getLog() { 242 return log; 243 } 244 245 public void setLog(Log log) { 246 this.log = log; 247 } 248 249 public LoggingLevel getLevel() { 250 return level; 251 } 252 253 public void setLevel(LoggingLevel level) { 254 this.level = level; 255 } 256 257 public void setFormatter(ExchangeFormatter formatter) { 258 this.formatter = formatter; 259 } 260 261 public void setLogName(String logName) { 262 this.log = LogFactory.getLog(logName); 263 } 264 }