Fix: cleanup JUL agent state on sessiond disconnect

[lttng-ust.git] / liblttng-ust-jul / org / lttng / ust / jul / LTTngLogHandler.java

diff --git a/liblttng-ust-jul/org/lttng/ust/jul/LTTngLogHandler.java b/liblttng-ust-jul/org/lttng/ust/jul/LTTngLogHandler.java
index d2d5587489b26ff4797967756c35c4cef87e0ec3..ddeb5eb3b36e9e04cba608cbd0a17539a948c265 100644 (file)
--- a/liblttng-ust-jul/org/lttng/ust/jul/LTTngLogHandler.java
+++ b/liblttng-ust-jul/org/lttng/ust/jul/LTTngLogHandler.java
@@ -22,6 +22,7 @@ import java.util.logging.Handler;
 import java.util.logging.LogRecord;
 import java.util.logging.LogManager;
 import java.util.logging.Level;
+import java.util.ArrayList;
 import java.util.HashMap;
 
 import org.lttng.ust.jul.LTTngUst;
@@ -34,37 +35,23 @@ class LTTngLogLevelABI {
        public static final int LOGLEVEL_TYPE_SINGLE = 2;
 }
 
-class LTTngLogLevel {
-       /* Event name on which this loglevel is applied on. */
-       private String event_name;
-       /* This level is a JUL int level value. */
-       private int level;
-       private int type;
-
-       public LTTngLogLevel(String event_name, int level, int type) {
-               this.event_name = event_name;
-               this.type = type;
-               this.level = level;
-       }
-
-       public String getName() {
-               return this.event_name;
-       }
-
-       public int getLevel() {
-               return this.level;
-       }
+public class LTTngLogHandler extends Handler {
+       /*
+        * Indicate if the enable all event has been seen and if yes logger that we
+        * enabled should use the loglevel/type below.
+        */
+       public int logLevelUseAll = 0;
+       public ArrayList<LTTngLogLevel> logLevelsAll =
+               new ArrayList<LTTngLogLevel>();
 
-       public int getType() {
-               return this.type;
-       }
-}
+       /* Am I a root Log Handler. */
+       public int is_root = 0;
 
-public class LTTngLogHandler extends Handler {
        public LogManager logManager;
 
-       private HashMap<String, LTTngLogLevel> logLevels =
-               new HashMap<String, LTTngLogLevel>();
+       /* Indexed by name and corresponding LTTngEvent. */
+       private HashMap<String, LTTngEvent> eventMap =
+               new HashMap<String, LTTngEvent>();
 
        public LTTngLogHandler(LogManager logManager) {
                super();
@@ -75,10 +62,33 @@ public class LTTngLogHandler extends Handler {
                LTTngUst.init();
        }
 
-       public void setLogLevel(String event_name, int level, int type) {
-               LTTngLogLevel lttngLogLevel = new LTTngLogLevel(event_name, level,
-                               type);
-               logLevels.put(event_name, lttngLogLevel);
+       /**
+        * Add event to handler hash map if new.
+        *
+        * @return 0 if it did not exist else 1.
+        */
+       public int setEvent(LTTngEvent new_event) {
+               LTTngEvent event;
+
+               event = eventMap.get(new_event.name);
+               if (event == null) {
+                       eventMap.put(new_event.name, new_event);
+                       /* Did not exists. */
+                       return 0;
+               } else {
+                       /* Add new event loglevel to existing event. */
+                       event.logLevels.addAll(new_event.logLevels);
+                       /* Already exists. */
+                       return 1;
+               }
+       }
+
+       /*
+        * Cleanup this handler state meaning put it back to a vanilla state.
+        */
+       public void clear() {
+               this.eventMap.clear();
+               this.logLevelsAll.clear();
        }
 
        @Override
@@ -90,29 +100,41 @@ public class LTTngLogHandler extends Handler {
        @Override
        public void publish(LogRecord record) {
                int fire_tp = 0, rec_log_level, ev_type, ev_log_level;
+               LTTngEvent event;
                LTTngLogLevel lttngLogLevel;
-               String event_name = record.getLoggerName();
-
-               lttngLogLevel = logLevels.get(event_name);
-               if (lttngLogLevel != null) {
-                       rec_log_level = record.getLevel().intValue();
-                       ev_log_level = lttngLogLevel.getLevel();
-                       ev_type = lttngLogLevel.getType();
-
-                       switch (ev_type) {
-                       case LTTngLogLevelABI.LOGLEVEL_TYPE_RANGE:
-                               if (ev_log_level <= rec_log_level) {
+               String logger_name = record.getLoggerName();
+
+               /* Get back the event if any and check for loglevel. */
+               event = eventMap.get(logger_name);
+               if (event != null) {
+                       for (LTTngLogLevel ev_log : event.logLevels) {
+                               /* Get record and event log level. */
+                               rec_log_level = record.getLevel().intValue();
+                               ev_log_level = ev_log.level;
+
+                               switch (ev_log.type) {
+                               case LTTngLogLevelABI.LOGLEVEL_TYPE_RANGE:
+                                       if (ev_log_level <= rec_log_level) {
+                                               fire_tp = 1;
+                                       }
+                                       break;
+                               case LTTngLogLevelABI.LOGLEVEL_TYPE_SINGLE:
+                                       if (ev_log_level == rec_log_level) {
+                                               fire_tp = 1;
+                                       }
+                                       break;
+                               case LTTngLogLevelABI.LOGLEVEL_TYPE_ALL:
                                        fire_tp = 1;
+                                       break;
                                }
-                               break;
-                       case LTTngLogLevelABI.LOGLEVEL_TYPE_SINGLE:
-                               if (ev_log_level == rec_log_level) {
-                                       fire_tp = 1;
+
+                               /*
+                                * If we match, stop right now else continue to the next
+                                * loglevel contained in the event.
+                                */
+                               if (fire_tp == 1) {
+                                       break;
                                }
-                               break;
-                       case LTTngLogLevelABI.LOGLEVEL_TYPE_ALL:
-                               fire_tp = 1;
-                               break;
                        }
                } else {
                        /* No loglevel attached thus fire tracepoint. */
@@ -128,9 +150,16 @@ public class LTTngLogHandler extends Handler {
                 * caller is used for the event name, the raw message is taken, the
                 * loglevel of the record and the thread ID.
                 */
-               LTTngUst.tracepoint(record.getMessage(), record.getLoggerName(),
-                               record.getSourceClassName(), record.getSourceMethodName(),
-                               record.getMillis(), record.getLevel().intValue(),
-                               record.getThreadID());
+               if (this.is_root == 1) {
+                       LTTngUst.tracepointS(record.getMessage(),
+                                       record.getLoggerName(), record.getSourceClassName(),
+                                       record.getSourceMethodName(), record.getMillis(),
+                                       record.getLevel().intValue(), record.getThreadID());
+               } else {
+                       LTTngUst.tracepointU(record.getMessage(),
+                                       record.getLoggerName(), record.getSourceClassName(),
+                                       record.getSourceMethodName(), record.getMillis(),
+                                       record.getLevel().intValue(), record.getThreadID());
+               }
        }
 }