001 /**************************************************************** 002 * Licensed to the Apache Software Foundation (ASF) under one * 003 * or more contributor license agreements. See the NOTICE file * 004 * distributed with this work for additional information * 005 * regarding copyright ownership. The ASF licenses this file * 006 * to you under the Apache License, Version 2.0 (the * 007 * "License"); you may not use this file except in compliance * 008 * with the License. You may obtain a copy of the License at * 009 * * 010 * http://www.apache.org/licenses/LICENSE-2.0 * 011 * * 012 * Unless required by applicable law or agreed to in writing, * 013 * software distributed under the License is distributed on an * 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * 015 * KIND, either express or implied. See the License for the * 016 * specific language governing permissions and limitations * 017 * under the License. * 018 ****************************************************************/ 019 020 package org.apache.james.jspf.impl; 021 022 import org.apache.james.jspf.core.Logger; 023 import org.apache.log4j.Level; 024 025 /** 026 * Implementation of the Logger interface using the Log4J implementation 027 * strategy. 028 */ 029 public class Log4JLogger implements Logger { 030 private org.apache.log4j.Logger m_Logger; 031 032 public Log4JLogger(org.apache.log4j.Logger log4jLogger) { 033 m_Logger = log4jLogger; 034 } 035 036 /** 037 * Log a debug message. 038 * 039 * @param message 040 * the message 041 */ 042 public void debug(String message) { 043 m_Logger.debug(message); 044 } 045 046 /** 047 * Log a debug message. 048 * 049 * @param message 050 * the message 051 * @param throwable 052 * the throwable 053 */ 054 public void debug(String message, Throwable throwable) { 055 m_Logger.debug(message, throwable); 056 } 057 058 /** 059 * Determine if messages of priority "debug" will be logged. 060 * 061 * @return true if "debug" messages will be logged 062 */ 063 public boolean isDebugEnabled() { 064 return m_Logger.isDebugEnabled(); 065 } 066 067 /** 068 * Log a info message. 069 * 070 * @param message 071 * the message 072 */ 073 public void info(String message) { 074 m_Logger.info(message); 075 } 076 077 /** 078 * Log a info message. 079 * 080 * @param message 081 * the message 082 * @param throwable 083 * the throwable 084 */ 085 public void info(String message, Throwable throwable) { 086 m_Logger.info(message, throwable); 087 } 088 089 /** 090 * Determine if messages of priority "info" will be logged. 091 * 092 * @return true if "info" messages will be logged 093 */ 094 public boolean isInfoEnabled() { 095 return m_Logger.isInfoEnabled(); 096 } 097 098 /** 099 * Log a warn message. 100 * 101 * @param message 102 * the message 103 */ 104 public void warn(String message) { 105 m_Logger.warn(message); 106 } 107 108 /** 109 * Log a warn message. 110 * 111 * @param message 112 * the message 113 * @param throwable 114 * the throwable 115 */ 116 public void warn(String message, Throwable throwable) { 117 m_Logger.warn(message, throwable); 118 } 119 120 /** 121 * Determine if messages of priority "warn" will be logged. 122 * 123 * @return true if "warn" messages will be logged 124 */ 125 public boolean isWarnEnabled() { 126 return m_Logger.isEnabledFor(Level.WARN); 127 } 128 129 /** 130 * Log a error message. 131 * 132 * @param message 133 * the message 134 */ 135 public void error(String message) { 136 m_Logger.error(message); 137 } 138 139 /** 140 * Log a error message. 141 * 142 * @param message 143 * the message 144 * @param throwable 145 * the throwable 146 */ 147 public void error(String message, Throwable throwable) { 148 m_Logger.error(message, throwable); 149 } 150 151 /** 152 * Determine if messages of priority "error" will be logged. 153 * 154 * @return true if "error" messages will be logged 155 */ 156 public boolean isErrorEnabled() { 157 return m_Logger.isEnabledFor(Level.ERROR); 158 } 159 160 /** 161 * Log a fatalError message. 162 * 163 * @param message 164 * the message 165 */ 166 public void fatalError(String message) { 167 m_Logger.fatal(message); 168 } 169 170 /** 171 * Log a fatalError message. 172 * 173 * @param message 174 * the message 175 * @param throwable 176 * the throwable 177 */ 178 public void fatalError(String message, Throwable throwable) { 179 m_Logger.fatal(message, throwable); 180 } 181 182 /** 183 * Determine if messages of priority "fatalError" will be logged. 184 * 185 * @return true if "fatalError" messages will be logged 186 */ 187 public boolean isFatalErrorEnabled() { 188 return m_Logger.isEnabledFor(Level.FATAL); 189 } 190 191 /** 192 * Create a new child logger. The name of the child logger is 193 * [current-loggers-name].[passed-in-name] Throws 194 * <code>IllegalArgumentException</code> if name has an empty element name 195 * 196 * @param name 197 * the subname of this logger 198 * @return the new logger 199 */ 200 public Logger getChildLogger(String name) { 201 String newName = m_Logger.getName() + "." + name; 202 org.apache.log4j.Logger childLog4JLogger = org.apache.log4j.Logger 203 .getLogger(newName); 204 Log4JLogger child = new Log4JLogger(childLog4JLogger); 205 return child; 206 } 207 }