1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.log4j;
18
19 import java.util.Enumeration;
20 import java.util.Map;
21 import java.util.ResourceBundle;
22 import java.util.WeakHashMap;
23 import java.util.concurrent.ConcurrentHashMap;
24 import java.util.concurrent.ConcurrentMap;
25
26 import org.apache.log4j.helpers.NullEnumeration;
27 import org.apache.log4j.spi.LoggerFactory;
28 import org.apache.log4j.spi.LoggingEvent;
29 import org.apache.logging.log4j.core.LoggerContext;
30 import org.apache.logging.log4j.core.util.NameUtil;
31 import org.apache.logging.log4j.message.LocalizedMessage;
32 import org.apache.logging.log4j.message.Message;
33 import org.apache.logging.log4j.message.ObjectMessage;
34 import org.apache.logging.log4j.util.Strings;
35
36
37
38
39
40 public class Category {
41
42 private static LoggerFactory loggerFactory = new PrivateFactory();
43
44 private static final Map<LoggerContext, ConcurrentMap<String, Logger>> CONTEXT_MAP =
45 new WeakHashMap<LoggerContext, ConcurrentMap<String, Logger>>();
46
47 private static final String FQCN = Category.class.getName();
48
49
50
51
52 protected ResourceBundle bundle = null;
53
54 private final org.apache.logging.log4j.core.Logger logger;
55
56
57
58
59
60
61 protected Category(final LoggerContext context, final String name) {
62 this.logger = context.getLogger(name);
63 }
64
65
66
67
68
69 protected Category(final String name) {
70 this((LoggerContext) PrivateManager.getContext(), name);
71 }
72
73 private Category(final org.apache.logging.log4j.core.Logger logger) {
74 this.logger = logger;
75 }
76
77 public static Category getInstance(final String name) {
78 return getInstance((LoggerContext) PrivateManager.getContext(), name, loggerFactory);
79 }
80
81 static Category getInstance(final LoggerContext context, final String name) {
82 return getInstance(context, name, loggerFactory);
83 }
84
85 static Category getInstance(final LoggerContext context, final String name, final LoggerFactory factory) {
86 final ConcurrentMap<String, Logger> loggers = getLoggersMap(context);
87 Logger logger = loggers.get(name);
88 if (logger != null) {
89 return logger;
90 }
91 logger = factory.makeNewLoggerInstance(context, name);
92 final Logger prev = loggers.putIfAbsent(name, logger);
93 return prev == null ? logger : prev;
94 }
95
96 public static Category getInstance(@SuppressWarnings("rawtypes") final Class clazz) {
97 return getInstance(clazz.getName());
98 }
99
100 static Category getInstance(final LoggerContext context, @SuppressWarnings("rawtypes") final Class clazz) {
101 return getInstance(context, clazz.getName());
102 }
103
104 public final String getName() {
105 return logger.getName();
106 }
107
108 org.apache.logging.log4j.core.Logger getLogger() {
109 return logger;
110 }
111
112 public final Category getParent() {
113 final org.apache.logging.log4j.core.Logger parent = logger.getParent();
114 if (parent == null) {
115 return null;
116 }
117 final ConcurrentMap<String, Logger> loggers = getLoggersMap(logger.getContext());
118 final Logger l = loggers.get(parent.getName());
119 return l == null ? new Category(parent) : l;
120 }
121
122 public static Category getRoot() {
123 return getInstance(Strings.EMPTY);
124 }
125
126
127 static Category getRoot(final LoggerContext context) {
128 return getInstance(context, Strings.EMPTY);
129 }
130
131 private static ConcurrentMap<String, Logger> getLoggersMap(final LoggerContext context) {
132 synchronized (CONTEXT_MAP) {
133 ConcurrentMap<String, Logger> map = CONTEXT_MAP.get(context);
134 if (map == null) {
135 map = new ConcurrentHashMap<String, Logger>();
136 CONTEXT_MAP.put(context, map);
137 }
138 return map;
139 }
140 }
141
142
143
144
145
146
147
148
149
150
151
152 @SuppressWarnings("rawtypes")
153 @Deprecated
154 public static Enumeration getCurrentCategories() {
155 return LogManager.getCurrentLoggers();
156 }
157
158 public final Level getEffectiveLevel() {
159 switch (logger.getLevel().getStandardLevel()) {
160 case TRACE:
161 return Level.TRACE;
162 case DEBUG:
163 return Level.DEBUG;
164 case INFO:
165 return Level.INFO;
166 case WARN:
167 return Level.WARN;
168 case ERROR:
169 return Level.ERROR;
170 case FATAL:
171 return Level.FATAL;
172 default:
173 return Level.OFF;
174 }
175 }
176
177 public final Priority getChainedPriority() {
178 return getEffectiveLevel();
179 }
180
181 public final Level getLevel() {
182 return getEffectiveLevel();
183 }
184
185 public void setLevel(final Level level) {
186 logger.setLevel(org.apache.logging.log4j.Level.toLevel(level.levelStr));
187 }
188
189 public final Level getPriority() {
190 return getEffectiveLevel();
191 }
192
193 public void setPriority(final Priority priority) {
194 logger.setLevel(org.apache.logging.log4j.Level.toLevel(priority.levelStr));
195 }
196
197 public void debug(final Object message) {
198 maybeLog(FQCN, org.apache.logging.log4j.Level.DEBUG, message, null);
199 }
200
201 public void debug(final Object message, final Throwable t) {
202 maybeLog(FQCN, org.apache.logging.log4j.Level.DEBUG, message, t);
203 }
204
205 public boolean isDebugEnabled() {
206 return logger.isDebugEnabled();
207 }
208
209 public void error(final Object message) {
210 maybeLog(FQCN, org.apache.logging.log4j.Level.ERROR, message, null);
211 }
212
213 public void error(final Object message, final Throwable t) {
214 maybeLog(FQCN, org.apache.logging.log4j.Level.ERROR, message, t);
215 }
216
217 public boolean isErrorEnabled() {
218 return logger.isErrorEnabled();
219 }
220
221 public void warn(final Object message) {
222 maybeLog(FQCN, org.apache.logging.log4j.Level.WARN, message, null);
223 }
224
225 public void warn(final Object message, final Throwable t) {
226 maybeLog(FQCN, org.apache.logging.log4j.Level.WARN, message, t);
227 }
228
229 public boolean isWarnEnabled() {
230 return logger.isWarnEnabled();
231 }
232
233 public void fatal(final Object message) {
234 maybeLog(FQCN, org.apache.logging.log4j.Level.FATAL, message, null);
235 }
236
237 public void fatal(final Object message, final Throwable t) {
238 maybeLog(FQCN, org.apache.logging.log4j.Level.FATAL, message, t);
239 }
240
241 public boolean isFatalEnabled() {
242 return logger.isFatalEnabled();
243 }
244
245 public void info(final Object message) {
246 maybeLog(FQCN, org.apache.logging.log4j.Level.INFO, message, null);
247 }
248
249 public void info(final Object message, final Throwable t) {
250 maybeLog(FQCN, org.apache.logging.log4j.Level.INFO, message, t);
251 }
252
253 public boolean isInfoEnabled() {
254 return logger.isInfoEnabled();
255 }
256
257 public void trace(final Object message) {
258 maybeLog(FQCN, org.apache.logging.log4j.Level.TRACE, message, null);
259 }
260
261 public void trace(final Object message, final Throwable t) {
262 maybeLog(FQCN, org.apache.logging.log4j.Level.TRACE, message, t);
263 }
264
265 public boolean isTraceEnabled() {
266 return logger.isTraceEnabled();
267 }
268
269 public boolean isEnabledFor(final Priority level) {
270 final org.apache.logging.log4j.Level lvl = org.apache.logging.log4j.Level.toLevel(level.toString());
271 return isEnabledFor(lvl);
272 }
273
274
275
276
277
278 public void addAppender(final Appender appender) {
279 }
280
281
282
283
284
285 public void callAppenders(final LoggingEvent event) {
286 }
287
288 @SuppressWarnings("rawtypes")
289 public Enumeration getAllAppenders() {
290 return NullEnumeration.getInstance();
291 }
292
293
294
295
296
297
298 public Appender getAppender(final String name) {
299 return null;
300 }
301
302
303
304
305
306
307 public boolean isAttached(final Appender appender) {
308 return false;
309 }
310
311
312
313
314 public void removeAllAppenders() {
315 }
316
317
318
319
320
321 public void removeAppender(final Appender appender) {
322 }
323
324
325
326
327
328 public void removeAppender(final String name) {
329 }
330
331
332
333
334 public static void shutdown() {
335 }
336
337
338 public void forcedLog(final String fqcn, final Priority level, final Object message, final Throwable t) {
339 final org.apache.logging.log4j.Level lvl = org.apache.logging.log4j.Level.toLevel(level.toString());
340 final Message msg = message instanceof Message ? (Message) message : new ObjectMessage(message);
341 logger.logMessage(fqcn, lvl, null, msg, t);
342 }
343
344 public boolean exists(final String name) {
345 return PrivateManager.getContext().hasLogger(name);
346 }
347
348 public boolean getAdditivity() {
349 return logger.isAdditive();
350 }
351
352 public void setAdditivity(final boolean additivity) {
353 logger.setAdditive(additivity);
354 }
355
356 public void setResourceBundle(final ResourceBundle bundle) {
357 this.bundle = bundle;
358 }
359
360 public ResourceBundle getResourceBundle() {
361 if (bundle != null) {
362 return bundle;
363 }
364 String name = logger.getName();
365 final ConcurrentMap<String, Logger> loggers = getLoggersMap(logger.getContext());
366 while ((name = NameUtil.getSubName(name)) != null) {
367 if (loggers.containsKey(name)) {
368 final ResourceBundle rb = loggers.get(name).bundle;
369 if (rb != null) {
370 return rb;
371 }
372 }
373 }
374 return null;
375 }
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391 public void assertLog(final boolean assertion, final String msg) {
392 if (!assertion) {
393 this.error(msg);
394 }
395 }
396
397 public void l7dlog(final Priority priority, final String key, final Throwable t) {
398 if (isEnabledFor(priority)) {
399 final Message msg = new LocalizedMessage(bundle, key, null);
400 forcedLog(FQCN, priority, msg, t);
401 }
402 }
403
404 public void l7dlog(final Priority priority, final String key, final Object[] params, final Throwable t) {
405 if (isEnabledFor(priority)) {
406 final Message msg = new LocalizedMessage(bundle, key, params);
407 forcedLog(FQCN, priority, msg, t);
408 }
409 }
410
411 public void log(final Priority priority, final Object message, final Throwable t) {
412 if (isEnabledFor(priority)) {
413 final Message msg = new ObjectMessage(message);
414 forcedLog(FQCN, priority, msg, t);
415 }
416 }
417
418 public void log(final Priority priority, final Object message) {
419 if (isEnabledFor(priority)) {
420 final Message msg = new ObjectMessage(message);
421 forcedLog(FQCN, priority, msg, null);
422 }
423 }
424
425 public void log(final String fqcn, final Priority priority, final Object message, final Throwable t) {
426 if (isEnabledFor(priority)) {
427 final Message msg = new ObjectMessage(message);
428 forcedLog(fqcn, priority, msg, t);
429 }
430 }
431
432 private void maybeLog(final String fqcn, final org.apache.logging.log4j.Level level,
433 final Object message, final Throwable throwable) {
434 if (logger.isEnabled(level, null, message, throwable)) {
435 logger.logMessage(FQCN, level, null, new ObjectMessage(message), throwable);
436 }
437 }
438
439
440
441
442 private static class PrivateFactory implements LoggerFactory {
443
444 @Override
445 public Logger makeNewLoggerInstance(final LoggerContext context, final String name) {
446 return new Logger(context, name);
447 }
448 }
449
450
451
452
453 private static class PrivateManager extends org.apache.logging.log4j.LogManager {
454 private static final String FQCN = Category.class.getName();
455
456 public static org.apache.logging.log4j.spi.LoggerContext getContext() {
457 return getContext(FQCN, false);
458 }
459
460 public static org.apache.logging.log4j.Logger getLogger(final String name) {
461 return getLogger(FQCN, name);
462 }
463 }
464
465 private boolean isEnabledFor(final org.apache.logging.log4j.Level level) {
466 return logger.isEnabled(level, null, null);
467 }
468
469 }