Hadoop Common
  1. Hadoop Common
  2. HADOOP-7055

Update of commons logging libraries causes EventCounter to count logging events incorrectly

    Details

    • Type: Bug Bug
    • Status: Closed
    • Priority: Major Major
    • Resolution: Fixed
    • Affects Version/s: 0.21.0, 0.21.1, 0.22.0, 0.23.0
    • Fix Version/s: 0.23.0
    • Component/s: metrics
    • Labels:
      None
    • Hadoop Flags:
      Reviewed

      Description

      Hadoop 0.20.2 uses commons logging 1.0.4. EventCounter works correctly with this version of commons logging. Hadoop 0.21.0 uses commons logging 1.1.1 which causes EventCounter to count logging events incorrectly. I have verified it with Hadoop 0.21.0. After start-up of hadoop, I checked jvmmetrics.log after several minutes. In every metrics record, "logError=0, logFatal=0, logInfo=3, logWarn=0" was shown. The following text is an example.

      jvm.metrics: hostName=jingguolin, processName=DataNode, sessionId=, gcCount=3, gcTimeMillis=31, logError=0, logFatal=0, logInfo=3, logWarn=0, maxMemoryM=888.9375, memHeapCommittedM=38.0625, memHeapUsedM=3.6539612, memNonHeapCommittedM=18.25, memNonHeapUsedM=11.335686, threadsBlocked=0, threadsNew=0, threadsRunnable=8, threadsTerminated=0, threadsTimedWaiting=6, threadsWaiting=6

      Then I stopped hadoop and replaced commons logging 1.1.1 with 1.0.4. After the re-start of hadoop, a lot of logging events showed up in jvmmetrics.log.

      I have checked the source code of Log4JLogger for both 1.0.4 (http://svn.apache.org/viewvc/commons/proper/logging/tags/LOGGING_1_0_4/src/java/org/apache/commons/logging/impl/Log4JLogger.java?view=markup) and 1.1.1 (http://svn.apache.org/viewvc/commons/proper/logging/tags/commons-logging-1.1.1/src/java/org/apache/commons/logging/impl/Log4JLogger.java?view=markup). For 1.0.4, Level instances such as Level.INFO are used to construct LoggingEvent. But for 1.1.1, Priority instances such as Priority.INFO are used to construct LoggingEvent. So 1.1.1 version's event.getLevel() always returns Priority instances. EventCounter append method's "==" check always fails between a Level instance and a Priority instance. For "logInfo=3" metrics records produced by commons logging 1.1.1., I think that these 3 logging events are produced by log4j code directly instead of through commons logging API. The following code is EventCounter's append method.

      public void append(LoggingEvent event) {
      Level level = event.getLevel();
      if (level == Level.INFO)

      { counts.incr(INFO); }

      else if (level == Level.WARN)

      { counts.incr(WARN); }

      else if (level == Level.ERROR)

      { counts.incr(ERROR); }

      else if (level == Level.FATAL)

      { counts.incr(FATAL); }

      }

        Issue Links

          Activity

          Hide
          Eli Collins added a comment -

          Good catch Jingguo. Sounds like append needs to check Priority rather than Level? Seems like we shouldn't need to check both given that we've updated the library.

          Show
          Eli Collins added a comment - Good catch Jingguo. Sounds like append needs to check Priority rather than Level? Seems like we shouldn't need to check both given that we've updated the library.
          Hide
          Jingguo Yao added a comment -

          Yes. But we need to make sure that no log4j API is used directly for logging. log4j API uses Level instances such as Level.INFO to create LoggingEvent. Otherwise, such kind of logging will not be taken into account by EventCounter. And Level instances such as Priority.INFO are deprecated in log4j.

          Another option is to use equals instead of ==. Priority has the following equals method.

          /**
          Two priorities are equal if their level fields are equal.
          @since 1.2
          */
          public
          boolean equals(Object o) {
          if(o instanceof Priority)

          { Priority r = (Priority) o; return (this.level == r.level); }

          else

          { return false; }

          }

          Level does not define equals method by itself. So it inherits this method. This method will return true if level fields (int type) are equal. It will return true for things like Level.INFO and Priority.INFO. So LoggingEvent created by both commons logging API and log4j API will be taken into account for this option. The downside for this option is that equals check is slow than == check.

          And there are some mistakes in my original comment. Let me correct them here.

          For 1.0.4, Level instances such as Level.INFO are used to construct LoggingEvent. But for 1.1.1, Level instances such as Priority.INFO are used to construct LoggingEvent. Level.INFO and Priority.INFO are different Level instances. 1.1.1 version's event.getLevel() always returns Level instances from Priority. So EventCounter append method's "==" check always fails between different Level instances from Level and Priority.

          public class Priority

          { //... final static public Priority INFO = new Level(INFO_INT, "INFO", 6); //... }

          public class Level extends Priority implements Serializable

          { //... final static public Level INFO = new Level(INFO_INT, "INFO", 6); //... }
          Show
          Jingguo Yao added a comment - Yes. But we need to make sure that no log4j API is used directly for logging. log4j API uses Level instances such as Level.INFO to create LoggingEvent. Otherwise, such kind of logging will not be taken into account by EventCounter. And Level instances such as Priority.INFO are deprecated in log4j. Another option is to use equals instead of ==. Priority has the following equals method. /** Two priorities are equal if their level fields are equal. @since 1.2 */ public boolean equals(Object o) { if(o instanceof Priority) { Priority r = (Priority) o; return (this.level == r.level); } else { return false; } } Level does not define equals method by itself. So it inherits this method. This method will return true if level fields (int type) are equal. It will return true for things like Level.INFO and Priority.INFO. So LoggingEvent created by both commons logging API and log4j API will be taken into account for this option. The downside for this option is that equals check is slow than == check. And there are some mistakes in my original comment. Let me correct them here. For 1.0.4, Level instances such as Level.INFO are used to construct LoggingEvent. But for 1.1.1, Level instances such as Priority.INFO are used to construct LoggingEvent. Level.INFO and Priority.INFO are different Level instances. 1.1.1 version's event.getLevel() always returns Level instances from Priority. So EventCounter append method's "==" check always fails between different Level instances from Level and Priority. public class Priority { //... final static public Priority INFO = new Level(INFO_INT, "INFO", 6); //... } public class Level extends Priority implements Serializable { //... final static public Level INFO = new Level(INFO_INT, "INFO", 6); //... }
          Hide
          Luke Lu added a comment -

          This looks like a regression in the common log 1.1.1 implementation (passes in Priority.* instances instead of recommended Level.) to me. Priority. are deprecated and they should just use Level.* everywhere.

          In any case, using equals is a reasonable fix that works with all cases and the performance overhead is negligible compared with actual logging by time the appender is triggered.

          Show
          Luke Lu added a comment - This looks like a regression in the common log 1.1.1 implementation (passes in Priority.* instances instead of recommended Level. ) to me. Priority. are deprecated and they should just use Level.* everywhere. In any case, using equals is a reasonable fix that works with all cases and the performance overhead is negligible compared with actual logging by time the appender is triggered.
          Hide
          Jingguo Yao added a comment -

          When EventCounter appender is triggered, it only updates its counts field. So equals overhead is not negligible compared to the actual logging which is counts field updating in this case.

          But if we think that the overhead incurred by equals is negligible on the overall performance, we can use equals.

          Show
          Jingguo Yao added a comment - When EventCounter appender is triggered, it only updates its counts field. So equals overhead is not negligible compared to the actual logging which is counts field updating in this case. But if we think that the overhead incurred by equals is negligible on the overall performance, we can use equals.
          Hide
          Luke Lu added a comment -

          When EventCounter appender is triggered, it only updates its counts field. So equals overhead is not negligible compared to the actual logging which is counts field updating in this case.

          When the appender is triggered, a new LoggingEvent object is created and at least one synchronization happened which is probably 100x more expensive then the method call. Note, updating the counts field is a synchronized call, which is about 30x more expensive then the equals call. If don't believe it, just benchmark it and make sure you have at least two threads doing the update, so jvm doesn't elide the locks.

          Show
          Luke Lu added a comment - When EventCounter appender is triggered, it only updates its counts field. So equals overhead is not negligible compared to the actual logging which is counts field updating in this case. When the appender is triggered, a new LoggingEvent object is created and at least one synchronization happened which is probably 100x more expensive then the method call. Note, updating the counts field is a synchronized call, which is about 30x more expensive then the equals call. If don't believe it, just benchmark it and make sure you have at least two threads doing the update, so jvm doesn't elide the locks.
          Hide
          Jingguo Yao added a comment -

          Per Luke's suggestion, use equals instead of == for Level check.

          Show
          Jingguo Yao added a comment - Per Luke's suggestion, use equals instead of == for Level check.
          Hide
          Hadoop QA added a comment -

          -1 overall. Here are the results of testing the latest attachment
          http://issues.apache.org/jira/secure/attachment/12474763/HADOOP-7055.patch
          against trunk revision 1094750.

          +1 @author. The patch does not contain any @author tags.

          -1 tests included. The patch doesn't appear to include any new or modified tests.
          Please justify why no new tests are needed for this patch.
          Also please list what manual steps were performed to verify this patch.

          +1 javadoc. The javadoc tool did not generate any warning messages.

          +1 javac. The applied patch does not increase the total number of javac compiler warnings.

          +1 findbugs. The patch does not introduce any new Findbugs (version 1.3.9) warnings.

          +1 release audit. The applied patch does not increase the total number of release audit warnings.

          +1 core tests. The patch passed core unit tests.

          +1 contrib tests. The patch passed contrib unit tests.

          +1 system test framework. The patch passed system test framework compile.

          Test results: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//testReport/
          Findbugs warnings: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//artifact/trunk/build/test/findbugs/newPatchFindbugsWarnings.html
          Console output: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//console

          This message is automatically generated.

          Show
          Hadoop QA added a comment - -1 overall. Here are the results of testing the latest attachment http://issues.apache.org/jira/secure/attachment/12474763/HADOOP-7055.patch against trunk revision 1094750. +1 @author. The patch does not contain any @author tags. -1 tests included. The patch doesn't appear to include any new or modified tests. Please justify why no new tests are needed for this patch. Also please list what manual steps were performed to verify this patch. +1 javadoc. The javadoc tool did not generate any warning messages. +1 javac. The applied patch does not increase the total number of javac compiler warnings. +1 findbugs. The patch does not introduce any new Findbugs (version 1.3.9) warnings. +1 release audit. The applied patch does not increase the total number of release audit warnings. +1 core tests. The patch passed core unit tests. +1 contrib tests. The patch passed contrib unit tests. +1 system test framework. The patch passed system test framework compile. Test results: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//testReport/ Findbugs warnings: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//artifact/trunk/build/test/findbugs/newPatchFindbugsWarnings.html Console output: https://hudson.apache.org/hudson/job/PreCommit-HADOOP-Build/365//console This message is automatically generated.

            People

            • Assignee:
              Jingguo Yao
              Reporter:
              Jingguo Yao
            • Votes:
              0 Vote for this issue
              Watchers:
              2 Start watching this issue

              Dates

              • Created:
                Updated:
                Resolved:

                Time Tracking

                Estimated:
                Original Estimate - 0.5h
                0.5h
                Remaining:
                Remaining Estimate - 0.5h
                0.5h
                Logged:
                Time Spent - Not Specified
                Not Specified

                  Development