Menu
▾
▴
[Sblim-commit] jsr48-client/src/org/sblim/cimclient/internal/logging LogAndTraceBroker.java, 1.23, 1.24
|
From: Dave B. <bla...@us...> - 2012-02-20 17:47:58
|
Update of /cvsroot/sblim/jsr48-client/src/org/sblim/cimclient/internal/logging
In directory vz-cvs-3.sog:/tmp/cvs-serv30389/src/org/sblim/cimclient/internal/logging
Modified Files:
LogAndTraceBroker.java
Log Message:
3484014 - Add LogAndTraceBroker.isLoggable for message/trace
Index: LogAndTraceBroker.java
===================================================================
RCS file: /cvsroot/sblim/jsr48-client/src/org/sblim/cimclient/internal/logging/LogAndTraceBroker.java,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- LogAndTraceBroker.java 17 Jan 2012 14:11:11 -0000 1.23
+++ LogAndTraceBroker.java 20 Feb 2012 17:47:56 -0000 1.24
@@ -26,6 +26,7 @@
* 3252669 2011-03-28 blaschke-oss setXmlTraceStream blindly closes previous stream
* 3400209 2011-08-31 blaschke-oss Highlighted Static Analysis (PMD) issues
* 3469018 2012-01-03 blaschke-oss Properties not passed to CIMIndicationHandler
+ * 3484014 2012-02-03 blaschke-oss Add LogAndTraceBroker.isLoggable for message/trace
*/
package org.sblim.cimclient.internal.logging;
@@ -111,6 +112,28 @@
private final String iTHROWABLE = Throwable.class.getName();
+ private int iInternalLevelConsole = Level.OFF.intValue();
+
+ private int iInternalLevelLogFile = Level.OFF.intValue();
+
+ private int iInternalLevelTraceFile = Level.OFF.intValue();
+
+ private LogListener iInternalListenerLogConsole = null;
+
+ private LogListener iInternalListenerLogFile = null;
+
+ private TraceListener iInternalListenerTraceConsole = null;
+
+ private TraceListener iInternalListenerTraceFile = null;
+
+ private int iNumInternalLogListeners = 0;
+
+ private int iNumExternalLogListeners = 0;
+
+ private int iNumInternalTraceListeners = 0;
+
+ private int iNumExternalTraceListeners = 0;
+
private LogAndTraceBroker() {
this.iLogListeners = new ArrayList<LogListener>();
this.iTraceListeners = new ArrayList<TraceListener>();
@@ -133,7 +156,9 @@
logger.addHandler(handler);
logger.setLevel(level);
logger.setUseParentHandlers(false);
- addLogListener(new LogListener() {
+ this.iInternalLevelConsole = level.intValue();
+ if (this.iInternalListenerLogConsole != null) removeLogListener(this.iInternalListenerLogConsole);
+ this.iInternalListenerLogConsole = new LogListener() {
public void log(Level pLevel, String pMessageKey, String pMessage,
Object[] pParameters) {
@@ -141,7 +166,8 @@
record.setParameters(pParameters);
logger.log(record);
}
- });
+ };
+ addLogListener(this.iInternalListenerLogConsole);
}
} catch (Exception e) {
// Don't crash for logging
@@ -159,7 +185,9 @@
logger.addHandler(handler);
logger.setLevel(level);
logger.setUseParentHandlers(false);
- addLogListener(new LogListener() {
+ this.iInternalLevelLogFile = level.intValue();
+ if (this.iInternalListenerLogFile != null) removeLogListener(this.iInternalListenerLogFile);
+ this.iInternalListenerLogFile = new LogListener() {
public void log(Level pLevel, String pMessageKey, String pMessage,
Object[] pParameters) {
@@ -167,7 +195,8 @@
record.setParameters(pParameters);
logger.log(record);
}
- });
+ };
+ addLogListener(this.iInternalListenerLogFile);
}
} catch (Exception e) {
// Don't crash for logging
@@ -183,7 +212,9 @@
logger.addHandler(handler);
logger.setLevel(level);
logger.setUseParentHandlers(false);
- addTraceListener(new TraceListener() {
+ this.iInternalLevelConsole = level.intValue();
+ if (this.iInternalListenerTraceConsole != null) removeTraceListener(this.iInternalListenerTraceConsole);
+ this.iInternalListenerTraceConsole = new TraceListener() {
public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage) {
LogRecord record = new LogRecord(pLevel, pMessage);
@@ -198,7 +229,8 @@
record.setThrown(pThrown);
logger.log(record);
}
- });
+ };
+ addTraceListener(this.iInternalListenerTraceConsole);
}
} catch (Exception e) {
// Don't crash for logging
@@ -216,7 +248,9 @@
logger.addHandler(handler);
logger.setLevel(level);
logger.setUseParentHandlers(false);
- addTraceListener(new TraceListener() {
+ this.iInternalLevelTraceFile = level.intValue();
+ if (this.iInternalListenerTraceFile != null) removeTraceListener(this.iInternalListenerTraceFile);
+ this.iInternalListenerTraceFile = new TraceListener() {
public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage) {
LogRecord record = new LogRecord(pLevel, pMessage);
@@ -231,7 +265,8 @@
record.setThrown(pThrown);
logger.log(record);
}
- });
+ };
+ addTraceListener(this.iInternalListenerTraceFile);
}
} catch (Exception e) {
// Don't crash for logging
@@ -246,10 +281,20 @@
* The listener
*/
public synchronized void addLogListener(LogListener pListener) {
+ if (pListener == null) return;
sendGreetings(pListener);
ArrayList<LogListener> newListeners = new ArrayList<LogListener>(this.iLogListeners);
newListeners.add(pListener);
this.iLogListeners = newListeners;
+
+ if ((this.iInternalListenerLogFile != null && this.iInternalListenerLogFile
+ .equals(pListener))
+ || (this.iInternalListenerLogConsole != null && this.iInternalListenerLogConsole
+ .equals(pListener))) {
+ this.iNumInternalLogListeners++;
+ } else {
+ this.iNumExternalLogListeners++;
+ }
}
private void loadVersionTxt() {
@@ -356,8 +401,23 @@
*/
public synchronized void removeLogListener(LogListener pListener) {
ArrayList<LogListener> newListeners = new ArrayList<LogListener>(this.iLogListeners);
- newListeners.remove(pListener);
+ if (!newListeners.remove(pListener)) return;
this.iLogListeners = newListeners;
+
+ if (this.iInternalListenerLogFile != null
+ && this.iInternalListenerLogFile.equals(pListener)) {
+ // Removing internal log listener for file
+ this.iInternalListenerLogFile = null;
+ this.iNumInternalLogListeners--;
+ } else if (this.iInternalListenerLogConsole != null
+ && this.iInternalListenerLogConsole.equals(pListener)) {
+ // Removing internal log listener for console
+ this.iInternalListenerLogConsole = null;
+ this.iNumInternalLogListeners--;
+ } else {
+ // Removing user log listener
+ this.iNumExternalLogListeners--;
+ }
}
/**
@@ -368,6 +428,11 @@
this.iLogListeners = new ArrayList<LogListener>();
removeHandlers(Logger.getLogger(CONSOLE_LOGGER));
removeHandlers(Logger.getLogger(FILE_LOGGER));
+
+ this.iInternalListenerLogFile = null;
+ this.iInternalListenerLogConsole = null;
+ this.iNumInternalLogListeners = 0;
+ this.iNumExternalLogListeners = 0;
}
/**
@@ -388,10 +453,20 @@
* The listener
*/
public synchronized void addTraceListener(TraceListener pListener) {
+ if (pListener == null) return;
sendGreetings(pListener);
ArrayList<TraceListener> newListeners = new ArrayList<TraceListener>(this.iTraceListeners);
newListeners.add(pListener);
this.iTraceListeners = newListeners;
+
+ if ((this.iInternalListenerTraceFile != null && this.iInternalListenerTraceFile
+ .equals(pListener))
+ || (this.iInternalListenerTraceConsole != null && this.iInternalListenerTraceConsole
+ .equals(pListener))) {
+ this.iNumInternalTraceListeners++;
+ } else {
+ this.iNumExternalTraceListeners++;
+ }
}
/**
@@ -403,8 +478,23 @@
*/
public synchronized void removeTraceListener(TraceListener pListener) {
ArrayList<TraceListener> newListeners = new ArrayList<TraceListener>(this.iTraceListeners);
- newListeners.remove(pListener);
+ if (!newListeners.remove(pListener)) return;
this.iTraceListeners = newListeners;
+
+ if (this.iInternalListenerTraceFile != null
+ && this.iInternalListenerTraceFile.equals(pListener)) {
+ // Removing internal tracelistener for file
+ this.iInternalListenerTraceFile = null;
+ this.iNumInternalTraceListeners--;
+ } else if (this.iInternalListenerTraceConsole != null
+ && this.iInternalListenerTraceConsole.equals(pListener)) {
+ // Removing internal trace listener for console
+ this.iInternalListenerTraceConsole = null;
+ this.iNumInternalTraceListeners--;
+ } else {
+ // Removing user trace listener
+ this.iNumExternalTraceListeners--;
+ }
}
/**
@@ -414,6 +504,11 @@
public synchronized void clearTraceListeners() {
this.iTraceListeners = new ArrayList<TraceListener>();
removeHandlers(Logger.getLogger(TRACE_LOGGER));
+
+ this.iInternalListenerTraceFile = null;
+ this.iInternalListenerTraceConsole = null;
+ this.iNumInternalTraceListeners = 0;
+ this.iNumExternalTraceListeners = 0;
}
/**
@@ -599,4 +694,90 @@
}
}
+ /**
+ * Checks whether there are trace listeners installed that will log a trace
+ * message with the specified level. Use this method to determine if a
+ * trace() method call could result in logging before preparing the
+ * information to be logged. For example:
+ *
+ * <pre>
+ * if (logger.isLoggableTrace(Level.WARNING) {
+ * // Prepare info for logging
+ * logger.trace(Level.WARNING, ...
+ * </pre>
+ *
+ * @param pLevel
+ * The <code>Level</code> of the trace message.
+ * @return <code>true</code> if trace message could be logged,
+ * <code>false</code> otherwise.
+ */
+ public boolean isLoggableTrace(Level pLevel) {
+ // If there are no trace listeners or specified level is OFF, message
+ // will not be logged
+ if (this.iTraceListeners.size() == 0 || pLevel.intValue() == Level.OFF.intValue()) return false;
+
+ // If there are external trace listeners, message could be logged (user
+ // can alter level at will, so we do not know what it is)
+ if (this.iNumExternalTraceListeners > 0) return true;
+
+ // If there are internal trace listeners, determine if message will be
+ // logged
+ if (this.iNumInternalTraceListeners > 0) {
+ int level = Level.OFF.intValue();
+ if (this.iInternalListenerTraceFile != null) {
+ level = this.iInternalLevelTraceFile;
+ }
+ if (this.iInternalListenerTraceConsole != null && level > this.iInternalLevelConsole) {
+ level = this.iInternalLevelConsole;
+ }
+ return level <= pLevel.intValue();
+ }
+
+ return true;
+ }
+
+ /**
+ * Checks whether there are log listeners installed that will log a message
+ * with the specified level. Use this method to determine if a message()
+ * method call could result in logging before preparing the information to
+ * be logged. For example:
+ *
+ * <pre>
+ * if (logger.isLoggableMessage(Level.WARNING) {
+ * // Prepare info for logging
+ * logger.message(Level.WARNING, ...
+ * </pre>
+ *
+ * @param pLevel
+ * The <code>Level</code> of the message.
+ * @return <code>true</code> if message could be logged, <code>false</code>
+ * otherwise.
+ */
+ public boolean isLoggableMessage(Level pLevel) {
+ // If message is traceable, message could be logged
+ if (isLoggableTrace(pLevel)) return true;
+
+ // If there are no log listeners or specified level is OFF, message
+ // will not be logged
+ if (this.iLogListeners.size() == 0 || pLevel.intValue() == Level.OFF.intValue()) return false;
+
+ // If there are external log listeners, message could be logged (user
+ // can alter level at will, so we do not know what it is)
+ if (this.iNumExternalLogListeners > 0) return true;
+
+ // If there are internal log listeners, determine if message will be
+ // logged
+ if (this.iNumInternalLogListeners > 0) {
+ int level = Level.OFF.intValue();
+ if (this.iInternalListenerLogFile != null) {
+ level = this.iInternalLevelLogFile;
+ }
+ if (this.iInternalListenerLogConsole != null && level > this.iInternalLevelConsole) {
+ level = this.iInternalLevelConsole;
+ }
+ return level <= pLevel.intValue();
+ }
+
+ return true;
+ }
}
|
