1. Project Clover database Sat Feb 2 2019 06:45:20 CET
  2. Package org.xwiki.logging

File LogQueue.java

 

Coverage histogram

../../../img/srcFileCovDistChart9.png
41% of files have more coverage

Code metrics

8
91
70
1
563
384
75
0.82
1.3
70
1.07

Classes

Class Line # Actions
LogQueue 37 91 0% 75 16
0.905325590.5%
 

Contributing tests

This file is covered by 170 tests. .

Source view

1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.logging;
21   
22    import java.util.Arrays;
23    import java.util.LinkedList;
24    import java.util.List;
25    import java.util.concurrent.ConcurrentLinkedQueue;
26   
27    import org.apache.commons.lang3.ArrayUtils;
28    import org.slf4j.Marker;
29    import org.xwiki.logging.event.LogEvent;
30   
31    /**
32    * A queue of {@link LogEvent}s.
33    *
34    * @version $Id: 8b6c1180bd061a99e5c414249292798cd8fc67e7 $
35    * @since 3.2M3
36    */
 
37    public class LogQueue extends ConcurrentLinkedQueue<LogEvent> implements Logger
38    {
39    /**
40    * Serialization identifier.
41    */
42    private static final long serialVersionUID = 1L;
43   
44    /**
45    * Copy the stored log into a passed {@link org.slf4j.Logger}.
46    *
47    * @param targetLogger the logger where to copy the stored log
48    * @since 5.3M1
49    */
 
50  30 toggle public void log(org.slf4j.Logger targetLogger)
51    {
52  30 for (LogEvent logEvent : this) {
53  13 logEvent.log(targetLogger);
54    }
55    }
56   
57    /**
58    * @param level the log level
59    * @param format the log message
60    * @param arguments the event arguments to insert in the message
61    * @return the created {@link LogEvent} instance
62    * @since 4.1RC1
63    */
 
64  0 toggle public LogEvent addLogEvent(LogLevel level, String format, Object[] arguments)
65    {
66  0 return addLogEvent(null, level, format, arguments);
67    }
68   
69    /**
70    * @param marker the log marker
71    * @param level the log level
72    * @param format the log message
73    * @param arguments the event arguments to insert in the message
74    * @return the created {@link LogEvent} instance
75    * @since 4.3M1
76    */
 
77  101 toggle public LogEvent addLogEvent(Marker marker, LogLevel level, String format, Object[] arguments)
78    {
79  101 Object[] actualArray;
80  101 Throwable throwable;
81  101 if (arguments.length > 0 && arguments[arguments.length - 1] instanceof Throwable) {
82  2 actualArray = Arrays.copyOf(arguments, arguments.length - 1);
83  2 throwable = (Throwable) arguments[arguments.length - 1];
84    } else {
85  99 actualArray = arguments;
86  99 throwable = null;
87    }
88   
89  101 return addLogEvent(marker, level, format, actualArray, throwable);
90    }
91   
92    /**
93    * @param level the log level
94    * @param format the log message
95    * @param arguments the event arguments to insert in the message
96    * @param throwable the throwable associated to the event
97    * @return the created {@link LogEvent} instance
98    * @since 4.1RC1
99    */
 
100  0 toggle public LogEvent addLogEvent(LogLevel level, String format, Object[] arguments, Throwable throwable)
101    {
102  0 return addLogEvent(null, level, format, arguments, throwable);
103    }
104   
105    /**
106    * @param marker the log marker
107    * @param level the log level
108    * @param format the log message
109    * @param arguments the event arguments to insert in the message
110    * @param throwable the throwable associated to the event
111    * @return the created {@link LogEvent} instance
112    * @since 4.3M1
113    */
 
114  113 toggle public LogEvent addLogEvent(Marker marker, LogLevel level, String format, Object[] arguments, Throwable throwable)
115    {
116  113 LogEvent logEvent = LogUtils.newLogEvent(marker, level, format, arguments, throwable);
117  113 log(logEvent);
118   
119  113 return logEvent;
120    }
121   
 
122  10684 toggle @Override
123    public void log(LogEvent logEvent)
124    {
125  10684 add(logEvent);
126    }
127   
128    /**
129    * Filter logs of a specific level.
130    *
131    * @param level the level of the logs to return
132    * @return the filtered logs
133    * @since 4.1RC1
134    */
 
135  112 toggle public List<LogEvent> getLogs(LogLevel level)
136    {
137  112 List<LogEvent> levelLogs = new LinkedList<LogEvent>();
138   
139  112 for (LogEvent log : this) {
140  304 if (log.getLevel() == level) {
141  27 levelLogs.add(log);
142    }
143    }
144   
145  112 return levelLogs;
146    }
147   
148    /**
149    * Filter logs of a specific level.
150    *
151    * @param level the level of the logs to return
152    * @return the filtered logs
153    * @since 4.2M1
154    */
 
155  211 toggle public List<LogEvent> getLogsFrom(LogLevel level)
156    {
157  211 List<LogEvent> levelLogs = new LinkedList<LogEvent>();
158   
159  211 for (LogEvent log : this) {
160  1594 if (log.getLevel().compareTo(level) <= 0) {
161  22 levelLogs.add(log);
162    }
163    }
164   
165  211 return levelLogs;
166    }
167   
168    /**
169    * Indicate if the list contains logs of a specific level.
170    *
171    * @param level the level of the logs to return
172    * @return true if log of provided level or less exist
173    * @since 6.0M1
174    */
 
175  15 toggle public boolean containLogsFrom(LogLevel level)
176    {
177  15 for (LogEvent log : this) {
178  10 if (log.getLevel().compareTo(level) <= 0) {
179  4 return true;
180    }
181    }
182   
183  11 return false;
184    }
185   
186    // Logger
187   
 
188  0 toggle @Override
189    public String getName()
190    {
191  0 return null;
192    }
193   
194    // TRACE
195   
 
196  1 toggle @Override
197    public boolean isTraceEnabled()
198    {
199  1 return true;
200    }
201   
 
202  1 toggle @Override
203    public void trace(String msg)
204    {
205  1 trace(msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
206    }
207   
 
208  1 toggle @Override
209    public void trace(String format, Object arg)
210    {
211  1 trace((Marker) null, format, arg);
212    }
213   
 
214  1 toggle @Override
215    public void trace(String format, Object arg1, Object arg2)
216    {
217  1 trace((Marker) null, format, arg1, arg2);
218    }
219   
 
220  2 toggle @Override
221    public void trace(String format, Object... arguments)
222    {
223  2 trace((Marker) null, format, arguments);
224    }
225   
 
226  1 toggle @Override
227    public void trace(String msg, Throwable t)
228    {
229  1 trace((Marker) null, msg, t);
230    }
231   
 
232  0 toggle @Override
233    public boolean isTraceEnabled(Marker marker)
234    {
235  0 return true;
236    }
237   
 
238  3 toggle @Override
239    public void trace(Marker marker, String msg)
240    {
241  3 trace(marker, msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
242    }
243   
 
244  2 toggle @Override
245    public void trace(Marker marker, String format, Object arg)
246    {
247  2 trace(marker, format, new Object[] { arg });
248    }
249   
 
250  2 toggle @Override
251    public void trace(Marker marker, String format, Object arg1, Object arg2)
252    {
253  2 trace(marker, format, new Object[] { arg1, arg2 });
254    }
255   
 
256  10 toggle @Override
257    public void trace(Marker marker, String format, Object... arguments)
258    {
259  10 addLogEvent(marker, LogLevel.TRACE, format, arguments);
260    }
261   
 
262  2 toggle @Override
263    public void trace(Marker marker, String msg, Throwable t)
264    {
265  2 addLogEvent(marker, LogLevel.TRACE, msg, ArrayUtils.EMPTY_OBJECT_ARRAY, t);
266    }
267   
268    // DEBUG
269   
 
270  1 toggle @Override
271    public boolean isDebugEnabled()
272    {
273  1 return true;
274    }
275   
 
276  1 toggle @Override
277    public void debug(String msg)
278    {
279  1 debug((Marker) null, msg);
280    }
281   
 
282  1 toggle @Override
283    public void debug(String format, Object arg)
284    {
285  1 debug((Marker) null, format, arg);
286    }
287   
 
288  1 toggle @Override
289    public void debug(String format, Object arg1, Object arg2)
290    {
291  1 debug((Marker) null, format, arg1, arg2);
292    }
293   
 
294  1 toggle @Override
295    public void debug(String format, Object... arguments)
296    {
297  1 debug((Marker) null, format, arguments);
298    }
299   
 
300  1 toggle @Override
301    public void debug(String msg, Throwable t)
302    {
303  1 debug((Marker) null, msg, t);
304    }
305   
 
306  0 toggle @Override
307    public boolean isDebugEnabled(Marker marker)
308    {
309  0 return true;
310    }
311   
 
312  4 toggle @Override
313    public void debug(Marker marker, String msg)
314    {
315  4 debug(marker, msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
316    }
317   
 
318  2 toggle @Override
319    public void debug(Marker marker, String format, Object arg)
320    {
321  2 debug(marker, format, new Object[] { arg });
322    }
323   
 
324  2 toggle @Override
325    public void debug(Marker marker, String format, Object arg1, Object arg2)
326    {
327  2 debug(marker, format, new Object[] { arg1, arg2 });
328    }
329   
 
330  10 toggle @Override
331    public void debug(Marker marker, String format, Object... arguments)
332    {
333  10 addLogEvent(marker, LogLevel.DEBUG, format, arguments);
334    }
335   
 
336  2 toggle @Override
337    public void debug(Marker marker, String msg, Throwable t)
338    {
339  2 addLogEvent(marker, LogLevel.DEBUG, msg, ArrayUtils.EMPTY_OBJECT_ARRAY, t);
340    }
341   
342    // INFO
343   
 
344  1 toggle @Override
345    public boolean isInfoEnabled()
346    {
347  1 return true;
348    }
349   
 
350  1 toggle @Override
351    public void info(String msg)
352    {
353  1 info((Marker) null, msg);
354    }
355   
 
356  1 toggle @Override
357    public void info(String format, Object arg)
358    {
359  1 info((Marker) null, format, arg);
360    }
361   
 
362  1 toggle @Override
363    public void info(String format, Object arg1, Object arg2)
364    {
365  1 info((Marker) null, format, arg1, arg2);
366    }
367   
 
368  1 toggle @Override
369    public void info(String format, Object... arguments)
370    {
371  1 info((Marker) null, format, arguments);
372    }
373   
 
374  1 toggle @Override
375    public void info(String msg, Throwable t)
376    {
377  1 info((Marker) null, msg, t);
378    }
379   
 
380  0 toggle @Override
381    public boolean isInfoEnabled(Marker marker)
382    {
383  0 return true;
384    }
385   
 
386  4 toggle @Override
387    public void info(Marker marker, String msg)
388    {
389  4 info(marker, msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
390    }
391   
 
392  2 toggle @Override
393    public void info(Marker marker, String format, Object arg)
394    {
395  2 info(marker, format, new Object[] { arg });
396    }
397   
 
398  2 toggle @Override
399    public void info(Marker marker, String format, Object arg1, Object arg2)
400    {
401  2 info(marker, format, new Object[] { arg1, arg2 });
402    }
403   
 
404  10 toggle @Override
405    public void info(Marker marker, String format, Object... arguments)
406    {
407  10 addLogEvent(marker, LogLevel.INFO, format, arguments);
408    }
409   
 
410  2 toggle @Override
411    public void info(Marker marker, String msg, Throwable t)
412    {
413  2 addLogEvent(marker, LogLevel.INFO, msg, ArrayUtils.EMPTY_OBJECT_ARRAY, t);
414    }
415   
416    // WARN
417   
 
418  1 toggle @Override
419    public boolean isWarnEnabled()
420    {
421  1 return true;
422    }
423   
 
424  3 toggle @Override
425    public void warn(String msg)
426    {
427  3 warn((Marker) null, msg);
428    }
429   
 
430  3 toggle @Override
431    public void warn(String format, Object arg)
432    {
433  3 warn((Marker) null, format, arg);
434    }
435   
 
436  1 toggle @Override
437    public void warn(String format, Object arg1, Object arg2)
438    {
439  1 warn((Marker) null, format, arg1, arg2);
440    }
441   
 
442  1 toggle @Override
443    public void warn(String format, Object... arguments)
444    {
445  1 warn((Marker) null, format, arguments);
446    }
447   
 
448  1 toggle @Override
449    public void warn(String msg, Throwable t)
450    {
451  1 warn((Marker) null, msg, t);
452    }
453   
 
454  0 toggle @Override
455    public boolean isWarnEnabled(Marker marker)
456    {
457  0 return true;
458    }
459   
 
460  6 toggle @Override
461    public void warn(Marker marker, String msg)
462    {
463  6 warn(marker, msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
464    }
465   
 
466  4 toggle @Override
467    public void warn(Marker marker, String format, Object arg)
468    {
469  4 warn(marker, format, new Object[] { arg });
470    }
471   
 
472  2 toggle @Override
473    public void warn(Marker marker, String format, Object arg1, Object arg2)
474    {
475  2 warn(marker, format, new Object[] { arg1, arg2 });
476    }
477   
 
478  14 toggle @Override
479    public void warn(Marker marker, String format, Object... arguments)
480    {
481  14 addLogEvent(marker, LogLevel.WARN, format, arguments);
482    }
483   
 
484  2 toggle @Override
485    public void warn(Marker marker, String msg, Throwable t)
486    {
487  2 addLogEvent(marker, LogLevel.WARN, msg, ArrayUtils.EMPTY_OBJECT_ARRAY, t);
488    }
489   
490    // ERROR
491   
 
492  1 toggle @Override
493    public boolean isErrorEnabled()
494    {
495  1 return true;
496    }
497   
 
498  10 toggle @Override
499    public void error(String msg)
500    {
501  10 error((Marker) null, msg);
502    }
503   
 
504  16 toggle @Override
505    public void error(String format, Object arg)
506    {
507  16 error((Marker) null, format, arg);
508    }
509   
 
510  18 toggle @Override
511    public void error(String format, Object arg1, Object arg2)
512    {
513  18 error((Marker) null, format, arg1, arg2);
514    }
515   
 
516  5 toggle @Override
517    public void error(String format, Object... arguments)
518    {
519  5 error((Marker) null, format, arguments);
520    }
521   
 
522  2 toggle @Override
523    public void error(String msg, Throwable t)
524    {
525  2 error((Marker) null, msg, t);
526    }
527   
 
528  0 toggle @Override
529    public boolean isErrorEnabled(Marker marker)
530    {
531  0 return true;
532    }
533   
 
534  15 toggle @Override
535    public void error(Marker marker, String msg)
536    {
537  15 error(marker, msg, ArrayUtils.EMPTY_OBJECT_ARRAY);
538    }
539   
 
540  17 toggle @Override
541    public void error(Marker marker, String format, Object arg)
542    {
543  17 error(marker, format, new Object[] { arg });
544    }
545   
 
546  19 toggle @Override
547    public void error(Marker marker, String format, Object arg1, Object arg2)
548    {
549  19 error(marker, format, new Object[] { arg1, arg2 });
550    }
551   
 
552  57 toggle @Override
553    public void error(Marker marker, String format, Object... arguments)
554    {
555  57 addLogEvent(marker, LogLevel.ERROR, format, arguments);
556    }
557   
 
558  4 toggle @Override
559    public void error(Marker marker, String msg, Throwable t)
560    {
561  4 addLogEvent(marker, LogLevel.ERROR, msg, ArrayUtils.EMPTY_OBJECT_ARRAY, t);
562    }
563    }