1 /* 2 * Copyright 2001-2004 The Apache Software Foundation. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package org.apache.log4j; 18 19 import org.apache.log4j.helpers.NullEnumeration; 20 import org.slf4j.LoggerFactory; 21 import org.slf4j.Marker; 22 import org.slf4j.MarkerFactory; 23 import org.slf4j.spi.LocationAwareLogger; 24 25 import java.util.Enumeration; 26 27 /** 28 * <p> 29 * This class is a minimal implementation of the original 30 * <code>org.apache.log4j.Category</code> class (as found in log4j 1.2) by 31 * delegation of all calls to a {@link org.slf4j.Logger} instance. 32 * </p> 33 * 34 * <p> 35 * Log4j's <code>trace</code>, <code>debug()</code>, <code>info()</code>, 36 * <code>warn()</code>, <code>error()</code> printing methods are directly 37 * mapped to their SLF4J equivalents. Log4j's <code>fatal()</code> printing 38 * method is mapped to SLF4J's <code>error()</code> method with a FATAL marker. 39 * 40 * @author Sébastien Pennec 41 * @author Ceki Gülcü 42 */ 43 @SuppressWarnings("rawtypes") 44 public class Category { 45 46 private static final String CATEGORY_FQCN = Category.class.getName(); 47 48 private String name; 49 50 protected org.slf4j.Logger slf4jLogger; 51 private org.slf4j.spi.LocationAwareLogger locationAwareLogger; 52 53 private static Marker FATAL_MARKER = MarkerFactory.getMarker("FATAL"); 54 55 Category(String name) { 56 this.name = name; 57 slf4jLogger = LoggerFactory.getLogger(name); 58 if (slf4jLogger instanceof LocationAwareLogger) { 59 locationAwareLogger = (LocationAwareLogger) slf4jLogger; 60 } 61 } 62 63 public static Category getInstance(Class clazz) { 64 return Log4jLoggerFactory.getLogger(clazz.getName()); 65 } 66 67 public static Category getInstance(String name) { 68 return Log4jLoggerFactory.getLogger(name); 69 } 70 71 public final Category getParent() { 72 return null; 73 } 74 75 /** 76 * Returns the obvious. 77 * 78 * @return 79 */ 80 public String getName() { 81 return name; 82 } 83 84 public Appender getAppender(String name) { 85 return null; 86 } 87 88 public Enumeration getAllAppenders() { 89 return NullEnumeration.getInstance(); 90 } 91 92 /** 93 * Return the level in effect for this category/logger. 94 * 95 * <p> 96 * The result is computed by simulation. 97 * 98 * @return 99 */ 100 public Level getEffectiveLevel() { 101 if (slf4jLogger.isTraceEnabled()) { 102 return Level.TRACE; 103 } 104 if (slf4jLogger.isDebugEnabled()) { 105 return Level.DEBUG; 106 } 107 if (slf4jLogger.isInfoEnabled()) { 108 return Level.INFO; 109 } 110 if (slf4jLogger.isWarnEnabled()) { 111 return Level.WARN; 112 } 113 return Level.ERROR; 114 } 115 116 /** 117 * Returns the assigned {@link Level}, if any, for this Category. This 118 * implementation always returns null. 119 * 120 * @return Level - the assigned Level, can be <code>null</code>. 121 */ 122 final public Level getLevel() { 123 return null; 124 } 125 126 /** 127 * @deprecated Please use {@link #getLevel} instead. 128 */ 129 final public Level getPriority() { 130 return null; 131 } 132 133 /** 134 * Delegates to {@link org.slf4j.Logger#isDebugEnabled} method in SLF4J 135 */ 136 public boolean isDebugEnabled() { 137 return slf4jLogger.isDebugEnabled(); 138 } 139 140 /** 141 * Delegates to {@link org.slf4j.Logger#isInfoEnabled} method in SLF4J 142 */ 143 public boolean isInfoEnabled() { 144 return slf4jLogger.isInfoEnabled(); 145 } 146 147 /** 148 * Delegates tob {@link org.slf4j.Logger#isWarnEnabled} method in SLF4J 149 */ 150 public boolean isWarnEnabled() { 151 return slf4jLogger.isWarnEnabled(); 152 } 153 154 /** 155 * Delegates to {@link org.slf4j.Logger#isErrorEnabled} method in SLF4J 156 */ 157 public boolean isErrorEnabled() { 158 return slf4jLogger.isErrorEnabled(); 159 } 160 161 /** 162 * Determines whether the priority passed as parameter is enabled in the 163 * underlying SLF4J logger. Each log4j priority is mapped directly to its 164 * SLF4J equivalent, except for FATAL which is mapped as ERROR. 165 * 166 * @param p 167 * the priority to check against 168 * @return true if this logger is enabled for the given level, false 169 * otherwise. 170 */ 171 public boolean isEnabledFor(Priority p) { 172 switch (p.level) { 173 case Level.TRACE_INT: 174 return slf4jLogger.isTraceEnabled(); 175 case Level.DEBUG_INT: 176 return slf4jLogger.isDebugEnabled(); 177 case Level.INFO_INT: 178 return slf4jLogger.isInfoEnabled(); 179 case Level.WARN_INT: 180 return slf4jLogger.isWarnEnabled(); 181 case Level.ERROR_INT: 182 return slf4jLogger.isErrorEnabled(); 183 case Priority.FATAL_INT: 184 return slf4jLogger.isErrorEnabled(); 185 } 186 return false; 187 } 188 189 void differentiatedLog(Marker marker, String fqcn, int level, Object message, Throwable t) { 190 191 String m = convertToString(message); 192 if (locationAwareLogger != null) { 193 locationAwareLogger.log(marker, fqcn, level, m, null, t); 194 } else { 195 switch (level) { 196 case LocationAwareLogger.TRACE_INT: 197 slf4jLogger.trace(marker, m); 198 break; 199 case LocationAwareLogger.DEBUG_INT: 200 slf4jLogger.debug(marker, m); 201 break; 202 case LocationAwareLogger.INFO_INT: 203 slf4jLogger.info(marker, m); 204 break; 205 case LocationAwareLogger.WARN_INT: 206 slf4jLogger.warn(marker, m); 207 break; 208 case LocationAwareLogger.ERROR_INT: 209 slf4jLogger.error(marker, m); 210 break; 211 } 212 } 213 } 214 215 /** 216 * Delegates to {@link org.slf4j.Logger#debug(String)} method of SLF4J. 217 */ 218 public void debug(Object message) { 219 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.DEBUG_INT, message, null); 220 } 221 222 /** 223 * Delegates to {@link org.slf4j.Logger#debug(String,Throwable)} method in 224 * SLF4J. 225 */ 226 public void debug(Object message, Throwable t) { 227 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.DEBUG_INT, message, t); 228 } 229 230 /** 231 * Delegates to {@link org.slf4j.Logger#info(String)} method in SLF4J. 232 */ 233 public void info(Object message) { 234 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, null); 235 } 236 237 /** 238 * Delegates to {@link org.slf4j.Logger#info(String,Throwable)} method in 239 * SLF4J. 240 */ 241 public void info(Object message, Throwable t) { 242 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.INFO_INT, message, t); 243 } 244 245 /** 246 * Delegates to {@link org.slf4j.Logger#warn(String)} method in SLF4J. 247 */ 248 public void warn(Object message) { 249 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.WARN_INT, message, null); 250 } 251 252 /** 253 * Delegates to {@link org.slf4j.Logger#warn(String,Throwable)} method in 254 * SLF4J. 255 */ 256 public void warn(Object message, Throwable t) { 257 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.WARN_INT, message, t); 258 } 259 260 /** 261 * Delegates to {@link org.slf4j.Logger#error(String)} method in SLF4J. 262 */ 263 public void error(Object message) { 264 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, null); 265 } 266 267 /** 268 * Delegates to {@link org.slf4j.Logger#error(String,Throwable)} method in 269 * SLF4J. 270 */ 271 public void error(Object message, Throwable t) { 272 differentiatedLog(null, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, t); 273 } 274 275 /** 276 * Delegates to {@link org.slf4j.Logger#error(String)} method in SLF4J. 277 */ 278 public void fatal(Object message) { 279 differentiatedLog(FATAL_MARKER, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, null); 280 } 281 282 /** 283 * Delegates to {@link org.slf4j.Logger#error(String,Throwable)} method in 284 * SLF4J. In addition, the call is marked with a marker named "FATAL". 285 */ 286 public void fatal(Object message, Throwable t) { 287 differentiatedLog(FATAL_MARKER, CATEGORY_FQCN, LocationAwareLogger.ERROR_INT, message, t); 288 } 289 290 protected void forcedLog(String FQCN, Priority p, Object msg, Throwable t) { 291 log(FQCN, p, msg, t); 292 } 293 294 // See also http://bugzilla.slf4j.org/show_bug.cgi?id=168 295 public void log(String FQCN, Priority p, Object msg, Throwable t) { 296 int levelInt = priorityToLevelInt(p); 297 differentiatedLog(null, FQCN, levelInt, msg, t); 298 } 299 300 public void log(Priority p, Object message, Throwable t) { 301 int levelInt = priorityToLevelInt(p); 302 differentiatedLog(null, CATEGORY_FQCN, levelInt, message, t); 303 } 304 305 public void log(Priority p, Object message) { 306 int levelInt = priorityToLevelInt(p); 307 differentiatedLog(null, CATEGORY_FQCN, levelInt, message, null); 308 } 309 310 private int priorityToLevelInt(Priority p) { 311 switch (p.level) { 312 case Level.TRACE_INT: 313 case Level.X_TRACE_INT: 314 return LocationAwareLogger.TRACE_INT; 315 case Priority.DEBUG_INT: 316 return LocationAwareLogger.DEBUG_INT; 317 case Priority.INFO_INT: 318 return LocationAwareLogger.INFO_INT; 319 case Priority.WARN_INT: 320 return LocationAwareLogger.WARN_INT; 321 case Priority.ERROR_INT: 322 return LocationAwareLogger.ERROR_INT; 323 case Priority.FATAL_INT: 324 return LocationAwareLogger.ERROR_INT; 325 default: 326 throw new IllegalStateException("Unknown Priority " + p); 327 } 328 } 329 330 protected final String convertToString(Object message) { 331 if (message == null) { 332 return (String) message; 333 } else { 334 return message.toString(); 335 } 336 } 337 338 public void setAdditivity(boolean additive) { 339 // nothing to do 340 } 341 342 public void addAppender(Appender newAppender) { 343 // nothing to do 344 } 345 346 public void setLevel(Level level) { 347 // nothing to do 348 } 349 350 } 351
