1
2
3
4
5
6
7
8
9
10
11 package ch.qos.logback.classic.spi;
12
13 import java.io.IOException;
14 import java.io.ObjectInputStream;
15 import java.io.ObjectOutputStream;
16 import java.io.Serializable;
17 import java.util.HashMap;
18 import java.util.Map;
19
20 import org.slf4j.MDC;
21 import org.slf4j.Marker;
22 import org.slf4j.helpers.MessageFormatter;
23 import org.slf4j.impl.LogbackMDCAdapter;
24
25 import ch.qos.logback.classic.Level;
26 import ch.qos.logback.classic.Logger;
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 public class LoggingEvent implements Serializable {
43
44 private static final long serialVersionUID = 3075964498087694229L;
45
46 private static final int NULL_ARGUMENT_ARRAY = -1;
47 private static final String NULL_ARGUMENT_ARRAY_ELEMENT = "NULL_ARGUMENT_ARRAY_ELEMENT";
48
49
50
51
52 private static long startTime = System.currentTimeMillis();
53
54
55
56
57
58
59
60 transient String fqnOfLoggerClass;
61
62
63
64
65 private String threadName;
66
67
68
69
70
71
72
73
74 private transient Level level;
75
76 private String message;
77
78
79
80
81 private transient String formattedMessage;
82
83 private transient Object[] argumentArray;
84
85 private ThrowableProxy throwableProxy;
86
87 private CallerData[] callerDataArray;
88 private LoggerRemoteView loggerRemoteView;
89
90 private Marker marker;
91
92 private Map<String, String> mdcPropertyMap;
93
94
95
96
97
98 private long timeStamp;
99
100 public LoggingEvent() {
101 }
102
103 public LoggingEvent(String fqcn, Logger logger, Level level, String message,
104 Throwable throwable, Object[] argArray) {
105 this.fqnOfLoggerClass = fqcn;
106 this.loggerRemoteView = logger.getLoggerRemoteView();
107 this.level = level;
108 this.message = message;
109
110 if (throwable != null) {
111 this.throwableProxy = new ThrowableProxy(throwable);
112 }
113
114
115 this.argumentArray = argArray;
116
117 timeStamp = System.currentTimeMillis();
118
119
120 LogbackMDCAdapter logbackMDCAdapter = (LogbackMDCAdapter) MDC
121 .getMDCAdapter();
122 mdcPropertyMap = logbackMDCAdapter.getPropertyMap();
123 }
124
125 public void setArgumentArray(Object[] argArray) {
126 if (this.argumentArray != null) {
127 throw new IllegalStateException("argArray has been already set");
128 }
129 this.argumentArray = argArray;
130 }
131
132 public Object[] getArgumentArray() {
133 return this.argumentArray;
134 }
135
136 public Level getLevel() {
137 return level;
138 }
139
140 public String getThreadName() {
141 if (threadName == null) {
142 threadName = (Thread.currentThread()).getName();
143 }
144 return threadName;
145 }
146
147
148
149
150
151
152
153 public void setThreadName(String threadName) throws IllegalStateException {
154 if (this.threadName != null) {
155 throw new IllegalStateException("threadName has been already set");
156 }
157 this.threadName = threadName;
158 }
159
160
161
162
163
164 public ThrowableProxy getThrowableProxy() {
165 return throwableProxy;
166 }
167
168
169
170
171 public void setThrowableProxy(ThrowableProxy tp) {
172 if (throwableProxy != null) {
173 throw new IllegalStateException("ThrowableProxy has been already set.");
174 } else {
175 throwableProxy = tp;
176 }
177 }
178
179
180
181
182
183
184
185
186
187 public void prepareForDeferredProcessing() {
188 this.getThreadName();
189
190 if (mdcPropertyMap != null) {
191 mdcPropertyMap = new HashMap<String, String>(mdcPropertyMap);
192 }
193 }
194
195 public LoggerRemoteView getLoggerRemoteView() {
196 return loggerRemoteView;
197 }
198
199 public void setLoggerRemoteView(LoggerRemoteView loggerRemoteView) {
200 this.loggerRemoteView = loggerRemoteView;
201 }
202
203 public String getMessage() {
204 return message;
205 }
206
207 public void setMessage(String message) {
208 if (this.message != null) {
209 throw new IllegalStateException(
210 "The message for this event has been set already.");
211 }
212 this.message = message;
213 }
214
215 public long getTimeStamp() {
216 return timeStamp;
217 }
218
219 public void setTimeStamp(long timeStamp) {
220 this.timeStamp = timeStamp;
221 }
222
223 public void setLevel(Level level) {
224 if (this.level != null) {
225 throw new IllegalStateException(
226 "The level has been already set for this event.");
227 }
228 this.level = level;
229 }
230
231
232
233
234
235
236
237 public static final long getStartTime() {
238 return startTime;
239 }
240
241
242
243
244
245
246
247
248
249 public CallerData[] getCallerData() {
250
251
252 if (callerDataArray == null && fqnOfLoggerClass != null) {
253 callerDataArray = CallerData.extract(new Throwable(), fqnOfLoggerClass);
254 }
255 return callerDataArray;
256 }
257
258 public void setCallerInformation(CallerData[] callerDataArray) {
259 this.callerDataArray = callerDataArray;
260 }
261
262 public Marker getMarker() {
263 return marker;
264 }
265
266 public void setMarker(Marker marker) {
267 if (this.marker != null) {
268 throw new IllegalStateException(
269 "The marker has been already set for this event.");
270 }
271 this.marker = marker;
272 }
273
274
275
276 public String getFormattedMessage() {
277 if (formattedMessage != null) {
278 return formattedMessage;
279 }
280
281 if (argumentArray != null) {
282 formattedMessage = MessageFormatter.arrayFormat(message, argumentArray);
283 } else {
284 formattedMessage = message;
285 }
286
287 return formattedMessage;
288 }
289
290 public Map<String, String> getMDCPropertyMap() {
291 return mdcPropertyMap;
292 }
293
294 private void writeObject(ObjectOutputStream out) throws IOException {
295 out.defaultWriteObject();
296 out.writeInt(level.levelInt);
297 if (argumentArray != null) {
298 int len = argumentArray.length;
299 out.writeInt(len);
300 for (int i = 0; i < argumentArray.length; i++) {
301 if (argumentArray[i] != null) {
302 out.writeObject(argumentArray[i].toString());
303 } else {
304 out.writeObject(NULL_ARGUMENT_ARRAY_ELEMENT);
305 }
306 }
307 } else {
308 out.writeInt(NULL_ARGUMENT_ARRAY);
309 }
310
311 }
312
313 private void readObject(ObjectInputStream in) throws IOException,
314 ClassNotFoundException {
315 in.defaultReadObject();
316 int levelInt = in.readInt();
317 level = Level.toLevel(levelInt);
318
319 int argArrayLen = in.readInt();
320 if (argArrayLen != NULL_ARGUMENT_ARRAY) {
321 argumentArray = new String[argArrayLen];
322 for (int i = 0; i < argArrayLen; i++) {
323 Object val = in.readObject();
324 if (!NULL_ARGUMENT_ARRAY_ELEMENT.equals(val)) {
325 argumentArray[i] = val;
326 }
327 }
328 }
329 }
330
331 @Override
332 public String toString() {
333 StringBuilder sb = new StringBuilder();
334 sb.append('[');
335 sb.append(level).append("] ");
336 sb.append(getFormattedMessage());
337 return sb.toString();
338 }
339 }