1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38 package org.metricshub.wbem.sblim.cimclient.internal.logging;
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60 import java.io.FileOutputStream;
61 import java.io.IOException;
62 import java.io.InputStream;
63 import java.io.OutputStream;
64 import java.text.MessageFormat;
65 import java.util.ArrayList;
66 import java.util.List;
67 import java.util.Properties;
68 import java.util.logging.ConsoleHandler;
69 import java.util.logging.FileHandler;
70 import java.util.logging.Handler;
71 import java.util.logging.Level;
72 import java.util.logging.LogRecord;
73 import java.util.logging.Logger;
74 import org.metricshub.wbem.sblim.cimclient.CIMXMLTraceListener;
75 import org.metricshub.wbem.sblim.cimclient.LogAndTraceManager;
76 import org.metricshub.wbem.sblim.cimclient.LogListener;
77 import org.metricshub.wbem.sblim.cimclient.TraceListener;
78 import org.metricshub.wbem.sblim.cimclient.WBEMConfigurationProperties;
79 import org.metricshub.wbem.sblim.cimclient.internal.util.WBEMConfiguration;
80 import org.metricshub.wbem.sblim.cimclient.internal.util.WBEMConstants;
81
82
83
84
85
86
87
88
89
90 public class LogAndTraceBroker {
91 private static final String TRACE_LOGGER = "org.metricshub.wbem.sblim.cimclient.trace";
92
93 private static final String FILE_LOGGER = "org.metricshub.wbem.sblim.cimclient.file";
94
95 private static final String CONSOLE_LOGGER = "org.metricshub.wbem.sblim.cimclient.console";
96
97 private static LogAndTraceBroker cBroker = new LogAndTraceBroker();
98
99
100
101
102
103
104 public static LogAndTraceBroker getBroker() {
105 return cBroker;
106 }
107
108
109
110
111
112
113
114
115
116
117
118 public static boolean isLoggingStarted() {
119 return cBroker != null;
120 }
121
122 private volatile ArrayList<LogListener> iLogListeners;
123
124 private volatile ArrayList<TraceListener> iTraceListeners;
125
126 private volatile ArrayList<CIMXMLTraceListener> iCIMXMLTraceListeners;
127
128 private String iProductName = "SBLIM CIM Client for Java";
129
130 private String iCopyright = "COPYRIGHT (C) 2006, 2013 IBM Corp.";
131
132 private String iVersion = "?";
133
134 private String iBuildDate = "?";
135
136 private String iBuildTime = "?";
137
138 private OutputStream iXmlTraceStream = null;
139
140 private OutputStream iXmlTraceFile = null;
141
142 private final String iTHIS_CLASS = this.getClass().getName();
143
144 private final String iTHROWABLE = Throwable.class.getName();
145
146 private int iInternalLevelConsole = Level.OFF.intValue();
147
148 private int iInternalLevelLogFile = Level.OFF.intValue();
149
150 private int iInternalLevelTraceFile = Level.OFF.intValue();
151
152 private LogListener iInternalListenerLogConsole = null;
153
154 private LogListener iInternalListenerLogFile = null;
155
156 private TraceListener iInternalListenerTraceConsole = null;
157
158 private TraceListener iInternalListenerTraceFile = null;
159
160 private int iNumInternalLogListeners = 0;
161
162 private int iNumExternalLogListeners = 0;
163
164 private int iNumInternalTraceListeners = 0;
165
166 private int iNumExternalTraceListeners = 0;
167
168 private LogAndTraceBroker() {
169 this.iLogListeners = new ArrayList<LogListener>();
170 this.iTraceListeners = new ArrayList<TraceListener>();
171 this.iCIMXMLTraceListeners = new ArrayList<CIMXMLTraceListener>();
172 loadVersionTxt();
173 registerInternalListeners();
174 initXmlTraceFile();
175 }
176
177 @Override
178 protected void finalize() throws Throwable {
179 try {
180 if (
181 this.iXmlTraceFile != null &&
182 (!this.iXmlTraceFile.equals(System.out)) &&
183 (!this.iXmlTraceFile.equals(System.err))
184 ) this.iXmlTraceFile.close();
185 } catch (IOException e) {
186
187 } finally {
188 this.iXmlTraceFile = null;
189 super.finalize();
190 }
191 }
192
193
194
195
196 public void registerInternalListeners() {
197 try {
198 Level level = WBEMConfiguration.getGlobalConfiguration().getLogConsoleLevel();
199 String type = WBEMConfiguration.getGlobalConfiguration().getLogConsoleType();
200 if (level.intValue() < Level.OFF.intValue() && WBEMConstants.MESSAGE.equals(type)) {
201 final Logger logger = Logger.getLogger(CONSOLE_LOGGER);
202 final Handler handler = new ConsoleHandler();
203 handler.setFormatter(new LogFormatter());
204 handler.setLevel(level);
205 logger.addHandler(handler);
206 logger.setLevel(level);
207 logger.setUseParentHandlers(false);
208 this.iInternalLevelConsole = level.intValue();
209 if (this.iInternalListenerLogConsole != null) removeLogListener(this.iInternalListenerLogConsole);
210 this.iInternalListenerLogConsole =
211 new LogListener() {
212
213 public void log(Level pLevel, String pMessageKey, String pMessage, Object[] pParameters) {
214 LogRecord record = new LogRecord(pLevel, pMessageKey + " " + pMessage);
215 record.setParameters(pParameters);
216 logger.log(record);
217 }
218 };
219 addLogListener(this.iInternalListenerLogConsole);
220 }
221 } catch (Exception e) {
222
223 }
224 try {
225 Level level = WBEMConfiguration.getGlobalConfiguration().getLogFileLevel();
226 String location = WBEMConfiguration.getGlobalConfiguration().getLogFileLocation();
227 int size = WBEMConfiguration.getGlobalConfiguration().getLogFileSizeLimit();
228 int count = WBEMConfiguration.getGlobalConfiguration().getLogFileCount();
229 if (level.intValue() < Level.OFF.intValue()) {
230 final Logger logger = Logger.getLogger(FILE_LOGGER);
231 final Handler handler = new FileHandler(location, size, count);
232 handler.setFormatter(new LogFormatter());
233 handler.setLevel(level);
234 logger.addHandler(handler);
235 logger.setLevel(level);
236 logger.setUseParentHandlers(false);
237 this.iInternalLevelLogFile = level.intValue();
238 if (this.iInternalListenerLogFile != null) removeLogListener(this.iInternalListenerLogFile);
239 this.iInternalListenerLogFile =
240 new LogListener() {
241
242 public void log(Level pLevel, String pMessageKey, String pMessage, Object[] pParameters) {
243 LogRecord record = new LogRecord(pLevel, pMessageKey + " " + pMessage);
244 record.setParameters(pParameters);
245 logger.log(record);
246 }
247 };
248 addLogListener(this.iInternalListenerLogFile);
249 }
250 } catch (Exception e) {
251
252 }
253 try {
254 Level level = WBEMConfiguration.getGlobalConfiguration().getLogConsoleLevel();
255 String type = WBEMConfiguration.getGlobalConfiguration().getLogConsoleType();
256 if (level.intValue() < Level.OFF.intValue() && WBEMConstants.TRACE.equals(type)) {
257 final Logger logger = Logger.getLogger(CONSOLE_LOGGER);
258 final Handler handler = new ConsoleHandler();
259 handler.setFormatter(new TraceFormatter());
260 handler.setLevel(level);
261 logger.addHandler(handler);
262 logger.setLevel(level);
263 logger.setUseParentHandlers(false);
264 this.iInternalLevelConsole = level.intValue();
265 if (this.iInternalListenerTraceConsole != null) removeTraceListener(this.iInternalListenerTraceConsole);
266 this.iInternalListenerTraceConsole =
267 new TraceListener() {
268
269 public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage) {
270 LogRecord record = new LogRecord(pLevel, pMessage);
271 record.setSourceMethodName(String.valueOf(pOrigin));
272 logger.log(record);
273 }
274
275 public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage, Throwable pThrown) {
276 LogRecord record = new LogRecord(pLevel, pMessage);
277 record.setSourceMethodName(String.valueOf(pOrigin));
278 record.setThrown(pThrown);
279 logger.log(record);
280 }
281 };
282 addTraceListener(this.iInternalListenerTraceConsole);
283 }
284 } catch (Exception e) {
285
286 }
287 try {
288 Level level = WBEMConfiguration.getGlobalConfiguration().getTraceFileLevel();
289 String location = WBEMConfiguration.getGlobalConfiguration().getTraceFileLocation();
290 int size = WBEMConfiguration.getGlobalConfiguration().getTraceFileSizeLimit();
291 int count = WBEMConfiguration.getGlobalConfiguration().getTraceFileCount();
292 if (level.intValue() < Level.OFF.intValue()) {
293 final Logger logger = Logger.getLogger(TRACE_LOGGER);
294 final Handler handler = new FileHandler(location, size, count);
295 handler.setFormatter(new TraceFormatter());
296 handler.setLevel(level);
297 logger.addHandler(handler);
298 logger.setLevel(level);
299 logger.setUseParentHandlers(false);
300 this.iInternalLevelTraceFile = level.intValue();
301 if (this.iInternalListenerTraceFile != null) removeTraceListener(this.iInternalListenerTraceFile);
302 this.iInternalListenerTraceFile =
303 new TraceListener() {
304
305 public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage) {
306 LogRecord record = new LogRecord(pLevel, pMessage);
307 record.setSourceMethodName(String.valueOf(pOrigin));
308 logger.log(record);
309 }
310
311 public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage, Throwable pThrown) {
312 LogRecord record = new LogRecord(pLevel, pMessage);
313 record.setSourceMethodName(String.valueOf(pOrigin));
314 record.setThrown(pThrown);
315 logger.log(record);
316 }
317 };
318 addTraceListener(this.iInternalListenerTraceFile);
319 }
320 } catch (Exception e) {
321
322 }
323 }
324
325
326
327
328
329
330
331
332 public synchronized void addLogListener(LogListener pListener) {
333 if (pListener == null) return;
334 sendGreetings(pListener);
335 ArrayList<LogListener> newListeners = new ArrayList<LogListener>(this.iLogListeners);
336 newListeners.add(pListener);
337 this.iLogListeners = newListeners;
338
339 if (
340 (this.iInternalListenerLogFile != null && this.iInternalListenerLogFile.equals(pListener)) ||
341 (this.iInternalListenerLogConsole != null && this.iInternalListenerLogConsole.equals(pListener))
342 ) {
343 this.iNumInternalLogListeners++;
344 } else {
345 this.iNumExternalLogListeners++;
346 }
347 }
348
349 private void loadVersionTxt() {
350 InputStream is = null;
351 try {
352 Properties version = new Properties();
353 is = LogAndTraceManager.class.getResourceAsStream("version.txt");
354 version.load(is);
355 this.iProductName = version.getProperty("PRODUCTNAME");
356 this.iCopyright = version.getProperty("COPYRIGHT");
357 this.iVersion = version.getProperty("VERSION");
358 this.iBuildDate = version.getProperty("BUILDDATE");
359 this.iBuildTime = version.getProperty("BUILDTIME");
360 } catch (Exception e) {
361
362 } finally {
363 if (is != null) {
364 try {
365 is.close();
366 } catch (IOException e) {
367
368 }
369 }
370 }
371 }
372
373 private void sendGreetings(LogListener pListener) {
374 pListener.log(
375 MessageLoader.getLevel(Messages.GREETING),
376 Messages.GREETING,
377 MessageLoader.getLocalizedMessage(Messages.GREETING),
378 new Object[] { this.iProductName, this.iCopyright }
379 );
380 pListener.log(
381 MessageLoader.getLevel(Messages.RELEASE),
382 Messages.RELEASE,
383 MessageLoader.getLocalizedMessage(Messages.RELEASE),
384 new Object[] { this.iVersion, this.iBuildDate, this.iBuildTime }
385 );
386 pListener.log(
387 MessageLoader.getLevel(Messages.OS),
388 Messages.OS,
389 MessageLoader.getLocalizedMessage(Messages.OS),
390 new Object[] { System.getProperty("os.name"), System.getProperty("os.version"), System.getProperty("os.arch") }
391 );
392 pListener.log(
393 MessageLoader.getLevel(Messages.JRE),
394 Messages.JRE,
395 MessageLoader.getLocalizedMessage(Messages.JRE),
396 new Object[] { System.getProperty("java.version"), System.getProperty("java.vendor") }
397 );
398 pListener.log(
399 MessageLoader.getLevel(Messages.JVM),
400 Messages.JVM,
401 MessageLoader.getLocalizedMessage(Messages.JVM),
402 new Object[] {
403 System.getProperty("java.vm.name"),
404 System.getProperty("java.vm.version"),
405 System.getProperty("java.vm.vendor")
406 }
407 );
408 pListener.log(
409 MessageLoader.getLevel(Messages.CONFIGURATION_URL),
410 Messages.CONFIGURATION_URL,
411 MessageLoader.getLocalizedMessage(Messages.CONFIGURATION_URL),
412 new Object[] { WBEMConfiguration.getActiveConfigFullURL() }
413 );
414 if (!WBEMConfiguration.isConfigurationLoadSuccessful()) {
415 pListener.log(
416 MessageLoader.getLevel(Messages.CONFIGURATION_LOAD_FAILED),
417 Messages.CONFIGURATION_LOAD_FAILED,
418 MessageLoader.getLocalizedMessage(Messages.CONFIGURATION_LOAD_FAILED),
419 (Object[]) null
420 );
421 if (WBEMConfiguration.getConfigurationLoadException() != null) {
422 pListener.log(
423 MessageLoader.getLevel(Messages.EXCEPTION_DURING_CONFIGURATION_LOAD),
424 Messages.EXCEPTION_DURING_CONFIGURATION_LOAD,
425 MessageLoader.getLocalizedMessage(Messages.EXCEPTION_DURING_CONFIGURATION_LOAD),
426 new Object[] { WBEMConfiguration.getConfigurationLoadException().getMessage() }
427 );
428 }
429 }
430 }
431
432 private void sendGreetings(TraceListener pListener) {
433 StackTraceElement origin = new Throwable().getStackTrace()[0];
434 pListener.trace(
435 MessageLoader.getLevel(Messages.GREETING),
436 origin,
437 MessageFormat.format(
438 MessageLoader.getMessage(Messages.GREETING),
439 new Object[] { this.iProductName, this.iCopyright }
440 )
441 );
442 pListener.trace(
443 MessageLoader.getLevel(Messages.RELEASE),
444 origin,
445 MessageFormat.format(
446 MessageLoader.getMessage(Messages.RELEASE),
447 new Object[] { this.iVersion, this.iBuildDate, this.iBuildTime }
448 )
449 );
450 pListener.trace(
451 MessageLoader.getLevel(Messages.OS),
452 origin,
453 MessageFormat.format(
454 MessageLoader.getMessage(Messages.OS),
455 new Object[] { System.getProperty("os.name"), System.getProperty("os.version"), System.getProperty("os.arch") }
456 )
457 );
458 pListener.trace(
459 MessageLoader.getLevel(Messages.JRE),
460 origin,
461 MessageFormat.format(
462 MessageLoader.getMessage(Messages.JRE),
463 new Object[] { System.getProperty("java.version"), System.getProperty("java.vendor") }
464 )
465 );
466 pListener.trace(
467 MessageLoader.getLevel(Messages.JVM),
468 origin,
469 MessageFormat.format(
470 MessageLoader.getMessage(Messages.JVM),
471 new Object[] {
472 System.getProperty("java.vm.name"),
473 System.getProperty("java.vm.version"),
474 System.getProperty("java.vm.vendor")
475 }
476 )
477 );
478 pListener.trace(
479 MessageLoader.getLevel(Messages.CONFIGURATION_URL),
480 origin,
481 MessageFormat.format(
482 MessageLoader.getMessage(Messages.CONFIGURATION_URL),
483 new Object[] { WBEMConfiguration.getActiveConfigURL() }
484 )
485 );
486 if (!WBEMConfiguration.isConfigurationLoadSuccessful()) {
487 pListener.trace(
488 MessageLoader.getLevel(Messages.CONFIGURATION_LOAD_FAILED),
489 origin,
490 MessageLoader.getMessage(Messages.CONFIGURATION_LOAD_FAILED)
491 );
492 if (WBEMConfiguration.getConfigurationLoadException() != null) {
493 pListener.trace(
494 MessageLoader.getLevel(Messages.EXCEPTION_DURING_CONFIGURATION_LOAD),
495 origin,
496 MessageLoader.getMessage(Messages.EXCEPTION_DURING_CONFIGURATION_LOAD),
497 WBEMConfiguration.getConfigurationLoadException()
498 );
499 }
500 }
501 }
502
503
504
505
506
507
508
509
510 public synchronized void removeLogListener(LogListener pListener) {
511 ArrayList<LogListener> newListeners = new ArrayList<LogListener>(this.iLogListeners);
512 if (!newListeners.remove(pListener)) return;
513 this.iLogListeners = newListeners;
514
515 if (this.iInternalListenerLogFile != null && this.iInternalListenerLogFile.equals(pListener)) {
516
517 this.iInternalListenerLogFile = null;
518 this.iNumInternalLogListeners--;
519 } else if (this.iInternalListenerLogConsole != null && this.iInternalListenerLogConsole.equals(pListener)) {
520
521 this.iInternalListenerLogConsole = null;
522 this.iNumInternalLogListeners--;
523 } else {
524
525 this.iNumExternalLogListeners--;
526 }
527 }
528
529
530
531
532
533 public synchronized void clearLogListeners() {
534 this.iLogListeners = new ArrayList<LogListener>();
535 removeHandlers(Logger.getLogger(CONSOLE_LOGGER));
536 removeHandlers(Logger.getLogger(FILE_LOGGER));
537
538 this.iInternalListenerLogFile = null;
539 this.iInternalListenerLogConsole = null;
540 this.iNumInternalLogListeners = 0;
541 this.iNumExternalLogListeners = 0;
542 }
543
544
545
546
547
548
549
550 public List<LogListener> getLogListeners() {
551 return this.iLogListeners;
552 }
553
554
555
556
557
558
559
560
561 public synchronized void addTraceListener(TraceListener pListener) {
562 if (pListener == null) return;
563 sendGreetings(pListener);
564 ArrayList<TraceListener> newListeners = new ArrayList<TraceListener>(this.iTraceListeners);
565 newListeners.add(pListener);
566 this.iTraceListeners = newListeners;
567
568 if (
569 (this.iInternalListenerTraceFile != null && this.iInternalListenerTraceFile.equals(pListener)) ||
570 (this.iInternalListenerTraceConsole != null && this.iInternalListenerTraceConsole.equals(pListener))
571 ) {
572 this.iNumInternalTraceListeners++;
573 } else {
574 this.iNumExternalTraceListeners++;
575 }
576 }
577
578
579
580
581
582
583
584
585 public synchronized void removeTraceListener(TraceListener pListener) {
586 ArrayList<TraceListener> newListeners = new ArrayList<TraceListener>(this.iTraceListeners);
587 if (!newListeners.remove(pListener)) return;
588 this.iTraceListeners = newListeners;
589
590 if (this.iInternalListenerTraceFile != null && this.iInternalListenerTraceFile.equals(pListener)) {
591
592 this.iInternalListenerTraceFile = null;
593 this.iNumInternalTraceListeners--;
594 } else if (this.iInternalListenerTraceConsole != null && this.iInternalListenerTraceConsole.equals(pListener)) {
595
596 this.iInternalListenerTraceConsole = null;
597 this.iNumInternalTraceListeners--;
598 } else {
599
600 this.iNumExternalTraceListeners--;
601 }
602 }
603
604
605
606
607
608 public synchronized void clearTraceListeners() {
609 this.iTraceListeners = new ArrayList<TraceListener>();
610 removeHandlers(Logger.getLogger(TRACE_LOGGER));
611
612 this.iInternalListenerTraceFile = null;
613 this.iInternalListenerTraceConsole = null;
614 this.iNumInternalTraceListeners = 0;
615 this.iNumExternalTraceListeners = 0;
616 }
617
618
619
620
621
622
623
624 public List<TraceListener> getTraceListeners() {
625 return this.iTraceListeners;
626 }
627
628
629
630
631
632
633
634
635 public synchronized void addCIMXMLTraceListener(CIMXMLTraceListener pListener) {
636 if (pListener == null) return;
637 ArrayList<CIMXMLTraceListener> newListeners = new ArrayList<CIMXMLTraceListener>(this.iCIMXMLTraceListeners);
638 newListeners.add(pListener);
639 this.iCIMXMLTraceListeners = newListeners;
640 }
641
642
643
644
645
646
647
648
649 public synchronized void removeCIMXMLTraceListener(CIMXMLTraceListener pListener) {
650 ArrayList<CIMXMLTraceListener> newListeners = new ArrayList<CIMXMLTraceListener>(this.iCIMXMLTraceListeners);
651 if (!newListeners.remove(pListener)) return;
652 this.iCIMXMLTraceListeners = newListeners;
653 }
654
655
656
657
658 public synchronized void clearCIMXMLTraceListeners() {
659 if (this.iCIMXMLTraceListeners.size() > 0) this.iCIMXMLTraceListeners = new ArrayList<CIMXMLTraceListener>();
660 }
661
662
663
664
665
666
667 public List<CIMXMLTraceListener> getCIMXMLTraceListeners() {
668 return this.iCIMXMLTraceListeners;
669 }
670
671
672
673
674
675
676
677 public void message(String pKey) {
678 message(pKey, (Object[]) null);
679 }
680
681
682
683
684
685
686
687
688
689 public void message(String pKey, Object pParameter) {
690 message(pKey, new Object[] { pParameter });
691 }
692
693
694
695
696
697
698
699
700
701 public void message(String pKey, Object[] pParameters) {
702 try {
703 final String message = MessageLoader.getMessage(pKey);
704 final String localMessage = MessageLoader.getLocalizedMessage(pKey);
705 final Level level = MessageLoader.getLevel(pKey);
706 if (isLoggableTrace(level)) {
707 final List<TraceListener> traceListeners = getTraceListeners();
708 StackTraceElement caller = getCaller();
709 for (int i = 0; i < traceListeners.size(); ++i) {
710 traceListeners.get(i).trace(level, caller, pKey + " " + MessageFormat.format(message, pParameters));
711 }
712 }
713 final List<LogListener> logListeners = getLogListeners();
714 for (int i = 0; i < logListeners.size(); ++i) {
715 logListeners.get(i).log(level, pKey, localMessage, pParameters);
716 }
717 } catch (Exception e) {
718
719 }
720 }
721
722
723
724
725
726
727
728
729
730
731 public void trace(Level pLevel, String pMessage) {
732 try {
733 if (isLoggableTrace(pLevel)) {
734 final List<TraceListener> traceListeners = getTraceListeners();
735 StackTraceElement caller = getCaller();
736 for (int i = 0; i < traceListeners.size(); ++i) {
737 traceListeners.get(i).trace(pLevel, caller, pMessage);
738 }
739 }
740 } catch (Exception e) {
741
742 }
743 }
744
745
746
747
748
749
750
751
752
753
754
755
756 public void trace(Level pLevel, String pMessage, Throwable pThrown) {
757 try {
758 if (isLoggableTrace(pLevel)) {
759 final List<TraceListener> traceListeners = getTraceListeners();
760 StackTraceElement caller = getCaller();
761 for (int i = 0; i < traceListeners.size(); ++i) {
762 traceListeners.get(i).trace(pLevel, caller, pMessage, pThrown);
763 }
764 }
765 } catch (Exception e) {
766
767 }
768 }
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783 public void traceCIMXML(Level pLevel, String pMessage, boolean pOutgoing) {
784 try {
785 if (this.iCIMXMLTraceListeners.size() > 0) {
786 final List<CIMXMLTraceListener> traceListeners = getCIMXMLTraceListeners();
787 for (int i = 0; i < traceListeners.size(); ++i) {
788 traceListeners.get(i).traceCIMXML(pLevel, pMessage, pOutgoing);
789 }
790 }
791 } catch (Exception e) {
792
793 }
794 }
795
796
797
798
799 public void entry() {
800 trace(Level.FINEST, "Entering method");
801 }
802
803
804
805
806 public void exit() {
807 trace(Level.FINEST, "Exiting method");
808 }
809
810
811
812
813
814
815
816
817 public OutputStream getXmlTraceStream() {
818 return this.iXmlTraceStream;
819 }
820
821
822
823
824
825
826
827
828
829 public void setXmlTraceStream(OutputStream pStream) {
830 this.iXmlTraceStream = pStream;
831 }
832
833
834
835
836
837
838
839 private void initXmlTraceFile() {
840 try {
841 if (WBEMConfiguration.getGlobalConfiguration().isCimXmlTracingEnabled()) {
842 String filename = WBEMConfiguration.getGlobalConfiguration().getCimXmlTraceStream();
843 if (filename != null && filename.length() > 0 && this.iXmlTraceFile == null && getXmlTraceStream() == null) {
844 if (filename.equalsIgnoreCase("System.out")) {
845 this.iXmlTraceFile = System.out;
846 } else if (filename.equalsIgnoreCase("System.err")) {
847 this.iXmlTraceFile = System.err;
848 } else {
849 try {
850 this.iXmlTraceFile = new FileOutputStream(filename);
851 } catch (IOException e) {
852 trace(
853 Level.FINE,
854 "Unable to open " + WBEMConfigurationProperties.CIMXML_TRACE_STREAM + "=" + filename,
855 e
856 );
857 }
858 }
859 setXmlTraceStream(this.iXmlTraceFile);
860 }
861 }
862 } catch (Exception e) {
863
864 }
865 }
866
867
868
869
870
871
872
873
874 private StackTraceElement getCaller() {
875 StackTraceElement[] stack = (new Throwable()).getStackTrace();
876 for (int i = 0; i < stack.length; ++i) {
877 StackTraceElement frame = stack[i];
878 String cname = frame.getClassName();
879 if (!this.iTHIS_CLASS.equals(cname) && !this.iTHROWABLE.equals(cname)) {
880 return frame;
881 }
882 }
883 return null;
884 }
885
886
887
888
889
890
891
892 private void removeHandlers(Logger pLogger) {
893 Handler[] handlers = pLogger.getHandlers();
894 for (int i = 0; i < handlers.length; ++i) {
895 pLogger.removeHandler(handlers[i]);
896 handlers[i].close();
897 }
898 }
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917 public boolean isLoggableTrace(Level pLevel) {
918
919
920 if (this.iTraceListeners.size() == 0 || pLevel.intValue() == Level.OFF.intValue()) return false;
921
922
923
924 if (this.iNumExternalTraceListeners > 0) return true;
925
926
927
928 if (this.iNumInternalTraceListeners > 0) {
929 int level = Level.OFF.intValue();
930 if (this.iInternalListenerTraceFile != null) {
931 level = this.iInternalLevelTraceFile;
932 }
933 if (this.iInternalListenerTraceConsole != null && level > this.iInternalLevelConsole) {
934 level = this.iInternalLevelConsole;
935 }
936 return level <= pLevel.intValue();
937 }
938
939 return true;
940 }
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959 public boolean isLoggableMessage(Level pLevel) {
960
961 if (isLoggableTrace(pLevel)) return true;
962
963
964
965 if (this.iLogListeners.size() == 0 || pLevel.intValue() == Level.OFF.intValue()) return false;
966
967
968
969 if (this.iNumExternalLogListeners > 0) return true;
970
971
972
973 if (this.iNumInternalLogListeners > 0) {
974 int level = Level.OFF.intValue();
975 if (this.iInternalListenerLogFile != null) {
976 level = this.iInternalLevelLogFile;
977 }
978 if (this.iInternalListenerLogConsole != null && level > this.iInternalLevelConsole) {
979 level = this.iInternalLevelConsole;
980 }
981 return level <= pLevel.intValue();
982 }
983
984 return true;
985 }
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004 public boolean isLoggableCIMXMLTrace(Level pLevel) {
1005
1006
1007 if (this.iCIMXMLTraceListeners.size() == 0 || pLevel.intValue() == Level.OFF.intValue()) return false;
1008
1009 return true;
1010 }
1011 }