1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package org.apache.log4j.pattern;
19
20 import org.apache.log4j.Category;
21 import org.apache.log4j.Level;
22 import org.apache.log4j.Logger;
23 import org.apache.log4j.MDC;
24 import org.apache.log4j.NDC;
25 import org.apache.log4j.Priority;
26 import org.apache.log4j.helpers.Loader;
27 import org.apache.log4j.helpers.LogLog;
28 import org.apache.log4j.spi.LocationInfo;
29 import org.apache.log4j.spi.LoggerRepository;
30 import org.apache.log4j.spi.RendererSupport;
31 import org.apache.log4j.spi.ThrowableInformation;
32
33 import java.io.ObjectInputStream;
34 import java.io.ObjectOutputStream;
35 import java.lang.reflect.Method;
36 import java.util.Collections;
37 import java.util.HashMap;
38 import java.util.Hashtable;
39 import java.util.Map;
40 import java.util.Set;
41
42 // Contributors: Nelson Minar <nelson@monkey.org>
43 // Wolf Siberski
44 // Anders Kristensen <akristensen@dynamicsoft.com>
45
46 /**
47 * This class is a copy of o.a.l.spi.LoggingEvent from
48 * log4j 1.2.15 which has been renamed to keep
49 * the same overall class name length to allow a
50 * serialization written with a prior instance of o.a.l.spi.LoggingEvent
51 * to be deserialized with this class just by mangling the class name
52 * in the byte stream.
53 *
54 */
55 public class LogEvent implements java.io.Serializable {
56
57 private static long startTime = System.currentTimeMillis();
58
59 /** Fully qualified name of the calling category class. */
60 transient public final String fqnOfCategoryClass;
61
62 /**
63 * The category of the logging event. This field is not serialized
64 * for performance reasons.
65 *
66 * <p>It is set by the LoggingEvent constructor or set by a remote
67 * entity after deserialization.
68 *
69 * @deprecated This field will be marked as private or be completely
70 * removed in future releases. Please do not use it.
71 * */
72 transient private Category logger;
73
74 /**
75 * <p>The category (logger) name.
76 *
77 * @deprecated This field will be marked as private in future
78 * releases. Please do not access it directly. Use the {@link
79 * #getLoggerName} method instead.
80
81 * */
82 final public String categoryName;
83
84 /**
85 * Level of logging event. Level cannot be serializable because it
86 * is a flyweight. Due to its special seralization it cannot be
87 * declared final either.
88 *
89 * <p> This field should not be accessed directly. You shoud use the
90 * {@link #getLevel} method instead.
91 *
92 * @deprecated This field will be marked as private in future
93 * releases. Please do not access it directly. Use the {@link
94 * #getLevel} method instead.
95 * */
96 transient public Priority level;
97
98 /** The nested diagnostic context (NDC) of logging event. */
99 private String ndc;
100
101 /** The mapped diagnostic context (MDC) of logging event. */
102 private Hashtable mdcCopy;
103
104
105 /** Have we tried to do an NDC lookup? If we did, there is no need
106 * to do it again. Note that its value is always false when
107 * serialized. Thus, a receiving SocketNode will never use it's own
108 * (incorrect) NDC. See also writeObject method. */
109 private boolean ndcLookupRequired = true;
110
111
112 /** Have we tried to do an MDC lookup? If we did, there is no need
113 * to do it again. Note that its value is always false when
114 * serialized. See also the getMDC and getMDCCopy methods. */
115 private boolean mdcCopyLookupRequired = true;
116
117 /** The application supplied message of logging event. */
118 transient private Object message;
119
120 /** The application supplied message rendered through the log4j
121 objet rendering mechanism.*/
122 private String renderedMessage;
123
124 /** The name of thread in which this logging event was generated. */
125 private String threadName;
126
127
128 /** This
129 variable contains information about this event's throwable
130 */
131 private ThrowableInformation throwableInfo;
132
133 /** The number of milliseconds elapsed from 1/1/1970 until logging event
134 was created. */
135 public final long timeStamp;
136 /** Location information for the caller. */
137 private LocationInfo locationInfo;
138
139 // Serialization
140 static final long serialVersionUID = -868428216207166145L;
141
142 static final Integer[] PARAM_ARRAY = new Integer[1];
143 static final String TO_LEVEL = "toLevel";
144 static final Class[] TO_LEVEL_PARAMS = new Class[] {int.class};
145 static final Hashtable methodCache = new Hashtable(3); // use a tiny table
146
147 /**
148 Instantiate a LoggingEvent from the supplied parameters.
149
150 <p>Except {@link #timeStamp} all the other fields of
151 <code>LoggingEvent</code> are filled when actually needed.
152 <p>
153 @param logger The logger generating this event.
154 @param level The level of this event.
155 @param message The message of this event.
156 @param throwable The throwable of this event. */
157 public LogEvent(String fqnOfCategoryClass, Category logger,
158 Priority level, Object message, Throwable throwable) {
159 this.fqnOfCategoryClass = fqnOfCategoryClass;
160 this.logger = logger;
161 this.categoryName = logger.getName();
162 this.level = level;
163 this.message = message;
164 if(throwable != null) {
165 this.throwableInfo = new ThrowableInformation(throwable);
166 }
167 timeStamp = System.currentTimeMillis();
168 }
169
170 /**
171 Instantiate a LoggingEvent from the supplied parameters.
172
173 <p>Except {@link #timeStamp} all the other fields of
174 <code>LoggingEvent</code> are filled when actually needed.
175 <p>
176 @param logger The logger generating this event.
177 @param timeStamp the timestamp of this logging event
178 @param level The level of this event.
179 @param message The message of this event.
180 @param throwable The throwable of this event. */
181 public LogEvent(String fqnOfCategoryClass, Category logger,
182 long timeStamp, Priority level, Object message,
183 Throwable throwable) {
184 this.fqnOfCategoryClass = fqnOfCategoryClass;
185 this.logger = logger;
186 this.categoryName = logger.getName();
187 this.level = level;
188 this.message = message;
189 if(throwable != null) {
190 this.throwableInfo = new ThrowableInformation(throwable);
191 }
192
193 this.timeStamp = timeStamp;
194 }
195
196 /**
197 Create new instance.
198 @since 1.2.15
199 @param fqnOfCategoryClass Fully qualified class name
200 of Logger implementation.
201 @param logger The logger generating this event.
202 @param timeStamp the timestamp of this logging event
203 @param level The level of this event.
204 @param message The message of this event.
205 @param threadName thread name
206 @param throwable The throwable of this event.
207 @param ndc Nested diagnostic context
208 @param info Location info
209 @param properties MDC properties
210 */
211 public LogEvent(final String fqnOfCategoryClass,
212 final Logger logger,
213 final long timeStamp,
214 final Level level,
215 final Object message,
216 final String threadName,
217 final ThrowableInformation throwable,
218 final String ndc,
219 final LocationInfo info,
220 final java.util.Map properties) {
221 super();
222 this.fqnOfCategoryClass = fqnOfCategoryClass;
223 this.logger = logger;
224 if (logger != null) {
225 categoryName = logger.getName();
226 } else {
227 categoryName = null;
228 }
229 this.level = level;
230 this.message = message;
231 if(throwable != null) {
232 this.throwableInfo = throwable;
233 }
234
235 this.timeStamp = timeStamp;
236 this.threadName = threadName;
237 ndcLookupRequired = false;
238 this.ndc = ndc;
239 this.locationInfo = info;
240 mdcCopyLookupRequired = false;
241 if (properties != null) {
242 mdcCopy = new java.util.Hashtable(properties);
243 }
244 }
245
246 /**
247 Set the location information for this logging event. The collected
248 information is cached for future use.
249 */
250 public LocationInfo getLocationInformation() {
251 if(locationInfo == null) {
252 locationInfo = new LocationInfo(new Throwable(), fqnOfCategoryClass);
253 }
254 return locationInfo;
255 }
256
257 /**
258 * Return the level of this event. Use this form instead of directly
259 * accessing the <code>level</code> field. */
260 public Level getLevel() {
261 return (Level) level;
262 }
263
264 /**
265 * Return the name of the logger. Use this form instead of directly
266 * accessing the <code>categoryName</code> field.
267 */
268 public String getLoggerName() {
269 return categoryName;
270 }
271
272 /**
273 Return the message for this logging event.
274
275 <p>Before serialization, the returned object is the message
276 passed by the user to generate the logging event. After
277 serialization, the returned value equals the String form of the
278 message possibly after object rendering.
279
280 @since 1.1 */
281 public
282 Object getMessage() {
283 if(message != null) {
284 return message;
285 } else {
286 return getRenderedMessage();
287 }
288 }
289
290 /**
291 * This method returns the NDC for this event. It will return the
292 * correct content even if the event was generated in a different
293 * thread or even on a different machine. The {@link NDC#get} method
294 * should <em>never</em> be called directly. */
295 public
296 String getNDC() {
297 if(ndcLookupRequired) {
298 ndcLookupRequired = false;
299 ndc = NDC.get();
300 }
301 return ndc;
302 }
303
304
305 /**
306 Returns the the context corresponding to the <code>key</code>
307 parameter. If there is a local MDC copy, possibly because we are
308 in a logging server or running inside AsyncAppender, then we
309 search for the key in MDC copy, if a value is found it is
310 returned. Otherwise, if the search in MDC copy returns a null
311 result, then the current thread's <code>MDC</code> is used.
312
313 <p>Note that <em>both</em> the local MDC copy and the current
314 thread's MDC are searched.
315
316 */
317 public
318 Object getMDC(String key) {
319 Object r;
320 // Note the mdcCopy is used if it exists. Otherwise we use the MDC
321 // that is associated with the thread.
322 if(mdcCopy != null) {
323 r = mdcCopy.get(key);
324 if(r != null) {
325 return r;
326 }
327 }
328 return MDC.get(key);
329 }
330
331 /**
332 Obtain a copy of this thread's MDC prior to serialization or
333 asynchronous logging.
334 */
335 public
336 void getMDCCopy() {
337 if(mdcCopyLookupRequired) {
338 mdcCopyLookupRequired = false;
339 // the clone call is required for asynchronous logging.
340 // See also bug #5932.
341 Hashtable t = (Hashtable) MDC.getContext();
342 if(t != null) {
343 mdcCopy = (Hashtable) t.clone();
344 }
345 }
346 }
347
348 public
349 String getRenderedMessage() {
350 if(renderedMessage == null && message != null) {
351 if(message instanceof String)
352 renderedMessage = (String) message;
353 else {
354 LoggerRepository repository = logger.getLoggerRepository();
355
356 if(repository instanceof RendererSupport) {
357 RendererSupport rs = (RendererSupport) repository;
358 renderedMessage= rs.getRendererMap().findAndRender(message);
359 } else {
360 renderedMessage = message.toString();
361 }
362 }
363 }
364 return renderedMessage;
365 }
366
367 /**
368 Returns the time when the application started, in milliseconds
369 elapsed since 01.01.1970. */
370 public static long getStartTime() {
371 return startTime;
372 }
373
374 public
375 String getThreadName() {
376 if(threadName == null)
377 threadName = (Thread.currentThread()).getName();
378 return threadName;
379 }
380
381 /**
382 Returns the throwable information contained within this
383 event. May be <code>null</code> if there is no such information.
384
385 <p>Note that the {@link Throwable} object contained within a
386 {@link ThrowableInformation} does not survive serialization.
387
388 @since 1.1 */
389 public
390 ThrowableInformation getThrowableInformation() {
391 return throwableInfo;
392 }
393
394 /**
395 Return this event's throwable's string[] representaion.
396 */
397 public
398 String[] getThrowableStrRep() {
399
400 if(throwableInfo == null)
401 return null;
402 else
403 return throwableInfo.getThrowableStrRep();
404 }
405
406
407 private
408 void readLevel(ObjectInputStream ois)
409 throws java.io.IOException, ClassNotFoundException {
410
411 int p = ois.readInt();
412 try {
413 String className = (String) ois.readObject();
414 if(className == null) {
415 level = Level.toLevel(p);
416 } else {
417 Method m = (Method) methodCache.get(className);
418 if(m == null) {
419 Class clazz = Loader.loadClass(className);
420 // Note that we use Class.getDeclaredMethod instead of
421 // Class.getMethod. This assumes that the Level subclass
422 // implements the toLevel(int) method which is a
423 // requirement. Actually, it does not make sense for Level
424 // subclasses NOT to implement this method. Also note that
425 // only Level can be subclassed and not Priority.
426 m = clazz.getDeclaredMethod(TO_LEVEL, TO_LEVEL_PARAMS);
427 methodCache.put(className, m);
428 }
429 PARAM_ARRAY[0] = new Integer(p);
430 level = (Level) m.invoke(null, PARAM_ARRAY);
431 }
432 } catch(Exception e) {
433 LogLog.warn("Level deserialization failed, reverting to default.", e);
434 level = Level.toLevel(p);
435 }
436 }
437
438 private void readObject(ObjectInputStream ois)
439 throws java.io.IOException, ClassNotFoundException {
440 ois.defaultReadObject();
441 readLevel(ois);
442
443 // Make sure that no location info is available to Layouts
444 if(locationInfo == null)
445 locationInfo = new LocationInfo(null, null);
446 }
447
448 private
449 void writeObject(ObjectOutputStream oos) throws java.io.IOException {
450 // Aside from returning the current thread name the wgetThreadName
451 // method sets the threadName variable.
452 this.getThreadName();
453
454 // This sets the renders the message in case it wasn't up to now.
455 this.getRenderedMessage();
456
457 // This call has a side effect of setting this.ndc and
458 // setting ndcLookupRequired to false if not already false.
459 this.getNDC();
460
461 // This call has a side effect of setting this.mdcCopy and
462 // setting mdcLookupRequired to false if not already false.
463 this.getMDCCopy();
464
465 // This sets the throwable sting representation of the event throwable.
466 this.getThrowableStrRep();
467
468 oos.defaultWriteObject();
469
470 // serialize this event's level
471 writeLevel(oos);
472 }
473
474 private
475 void writeLevel(ObjectOutputStream oos) throws java.io.IOException {
476
477 oos.writeInt(level.toInt());
478
479 Class clazz = level.getClass();
480 if(clazz == Level.class) {
481 oos.writeObject(null);
482 } else {
483 // writing directly the Class object would be nicer, except that
484 // serialized a Class object can not be read back by JDK
485 // 1.1.x. We have to resort to this hack instead.
486 oos.writeObject(clazz.getName());
487 }
488 }
489
490 /**
491 * Set value for MDC property.
492 * This adds the specified MDC property to the event.
493 * Access to the MDC is not synchronized, so this
494 * method should only be called when it is known that
495 * no other threads are accessing the MDC.
496 * @since 1.2.15
497 * @param propName
498 * @param propValue
499 */
500 public final void setProperty(final String propName,
501 final String propValue) {
502 if (mdcCopy == null) {
503 getMDCCopy();
504 }
505 if (mdcCopy == null) {
506 mdcCopy = new Hashtable();
507 }
508 mdcCopy.put(propName, propValue);
509 }
510
511 /**
512 * Return a property for this event. The return value can be null.
513 *
514 * Equivalent to getMDC(String) in log4j 1.2. Provided
515 * for compatibility with log4j 1.3.
516 *
517 * @param key property name
518 * @return property value or null if property not set
519 * @since 1.2.15
520 */
521 public final String getProperty(final String key) {
522 Object value = getMDC(key);
523 String retval = null;
524 if (value != null) {
525 retval = value.toString();
526 }
527 return retval;
528 }
529
530 /**
531 * Check for the existence of location information without creating it
532 * (a byproduct of calling getLocationInformation).
533 * @return true if location information has been extracted.
534 * @since 1.2.15
535 */
536 public final boolean locationInformationExists() {
537 return (locationInfo != null);
538 }
539
540 /**
541 * Getter for the event's time stamp. The time stamp is calculated starting
542 * from 1970-01-01 GMT.
543 * @return timestamp
544 *
545 * @since 1.2.15
546 */
547 public final long getTimeStamp() {
548 return timeStamp;
549 }
550
551 /**
552 * Returns the set of the key values in the properties
553 * for the event.
554 *
555 * The returned set is unmodifiable by the caller.
556 *
557 * Provided for compatibility with log4j 1.3
558 *
559 * @return Set an unmodifiable set of the property keys.
560 * @since 1.2.15
561 */
562 public Set getPropertyKeySet() {
563 return getProperties().keySet();
564 }
565
566 /**
567 * Returns the set of properties
568 * for the event.
569 *
570 * The returned set is unmodifiable by the caller.
571 *
572 * Provided for compatibility with log4j 1.3
573 *
574 * @return Set an unmodifiable map of the properties.
575 * @since 1.2.15
576 */
577 public Map getProperties() {
578 getMDCCopy();
579 Map properties;
580 if (mdcCopy == null) {
581 properties = new HashMap();
582 } else {
583 properties = mdcCopy;
584 }
585 return Collections.unmodifiableMap(properties);
586 }
587
588 /**
589 * Get the fully qualified name of the calling logger sub-class/wrapper.
590 * Provided for compatibility with log4j 1.3
591 * @return fully qualified class name, may be null.
592 * @since 1.2.15
593 */
594 public String getFQNOfLoggerClass() {
595 return fqnOfCategoryClass;
596 }
597
598
599
600 }