HDDS-9377. Implement some metrics with RW-lock instead of synchronization

hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/ContainerClientMetrics.java

@@ -23,14 +23,14 @@
 import org.apache.hadoop.hdds.scm.pipeline.PipelineID;
 import org.apache.hadoop.metrics2.annotation.Metric;
 import org.apache.hadoop.metrics2.annotation.Metrics;
-import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
 import org.apache.hadoop.metrics2.lib.Interns;
 import org.apache.hadoop.metrics2.lib.MetricsRegistry;
 import org.apache.hadoop.metrics2.lib.MutableCounterLong;
-import org.apache.hadoop.metrics2.lib.MutableQuantiles;
-import org.apache.hadoop.metrics2.lib.MutableRate;
 import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.metrics.MutableQuantiles;
+import org.apache.hadoop.ozone.metrics.MutableRate;
 import org.apache.hadoop.ozone.util.MetricUtil;
+import org.apache.hadoop.ozone.metrics.MetricsSystem;
 
 import java.util.Map;
 import java.util.UUID;
@@ -85,7 +85,7 @@ public final class ContainerClientMetrics {
   public static synchronized ContainerClientMetrics acquire() {
     if (instance == null) {
       instanceCount++;
-      instance = DefaultMetricsSystem.instance().register(
+      instance = MetricsSystem.instance().register(
           SOURCE_NAME + instanceCount,
           "Ozone Client Metrics", new ContainerClientMetrics());
     }
@@ -100,7 +100,7 @@ public static synchronized void release() {
     referenceCount--;
     if (referenceCount == 0) {
       instance.stop();
-      DefaultMetricsSystem.instance().unregisterSource(
+      MetricsSystem.instance().unregisterSource(
           SOURCE_NAME + instanceCount);
       instance = null;
     }
@@ -123,36 +123,37 @@ private ContainerClientMetrics() {
     int[] intervals = {60, 300, 900};
     for (int i = 0; i < intervals.length; i++) {
       int interval = intervals[i];
-      listBlockLatency[i] = registry
-          .newQuantiles("listBlockLatency" + interval
+      listBlockLatency[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "listBlockLatency" + interval
                   + "s", "ListBlock latency in microseconds", "ops",
               "latency", interval);
-      getBlockLatency[i] = registry
-          .newQuantiles("getBlockLatency" + interval
+      getBlockLatency[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "getBlockLatency" + interval
                   + "s", "GetBlock latency in microseconds", "ops",
               "latency", interval);
-      getCommittedBlockLengthLatency[i] = registry
-          .newQuantiles("getCommittedBlockLengthLatency" + interval
+      getCommittedBlockLengthLatency[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "getCommittedBlockLengthLatency" + interval
                   + "s", "GetCommittedBlockLength latency in microseconds",
               "ops", "latency", interval);
-      readChunkLatency[i] = registry
-          .newQuantiles("readChunkLatency" + interval
+      readChunkLatency[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "readChunkLatency" + interval
                   + "s", "ReadChunk latency in microseconds", "ops",
               "latency", interval);
-      getSmallFileLatency[i] = registry
-          .newQuantiles("getSmallFileLatency" + interval
+      getSmallFileLatency[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "getSmallFileLatency" + interval
                   + "s", "GetSmallFile latency in microseconds", "ops",
               "latency", interval);
-      hsyncLatencyNs[i] = registry
-          .newQuantiles("hsyncLatency" + interval
+      hsyncLatencyNs[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "hsyncLatency" + interval
                   + "s", "client hsync latency in nanoseconds", "ops",
               "latency", interval);
-      omHsyncLatencyNs[i] = registry
-          .newQuantiles("omHsyncLatency" + interval
+      omHsyncLatencyNs[i] = MetricsSystem.registerNewMutableQuantiles(registry,
+          "omHsyncLatency" + interval
                   + "s", "client hsync latency to OM in nanoseconds", "ops",
               "latency", interval);
-      datanodeHsyncLatencyNs[i] = registry
-          .newQuantiles("dnHsyncLatency" + interval
+      datanodeHsyncLatencyNs[i] = MetricsSystem.registerNewMutableQuantiles(
+          registry,
+          "dnHsyncLatency" + interval
                   + "s", "client hsync latency to DN in nanoseconds", "ops",
               "latency", interval);
     }

hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientMetrics.java

@@ -25,14 +25,13 @@
 import org.apache.hadoop.metrics2.MetricsCollector;
 import org.apache.hadoop.metrics2.MetricsRecordBuilder;
 import org.apache.hadoop.metrics2.MetricsSource;
-import org.apache.hadoop.metrics2.MetricsSystem;
 import org.apache.hadoop.metrics2.annotation.Metric;
 import org.apache.hadoop.metrics2.annotation.Metrics;
-import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
 import org.apache.hadoop.metrics2.lib.MetricsRegistry;
 import org.apache.hadoop.metrics2.lib.MutableCounterLong;
 import org.apache.hadoop.ozone.OzoneConfigKeys;
 import org.apache.hadoop.ozone.util.PerformanceMetrics;
+import org.apache.hadoop.ozone.metrics.MetricsSystem;
 
 import java.util.EnumMap;
 
@@ -79,9 +78,8 @@ public void init() {
   }
 
   public static XceiverClientMetrics create() {
-    DefaultMetricsSystem.initialize(SOURCE_NAME);
-    MetricsSystem ms = DefaultMetricsSystem.instance();
-    return ms.register(SOURCE_NAME, "Storage Container Client Metrics",
+    MetricsSystem.initialize(SOURCE_NAME);
+    return MetricsSystem.register(SOURCE_NAME, "Storage Container Client Metrics",
         new XceiverClientMetrics());
   }
 
@@ -131,7 +129,7 @@ public void reset() {
 
   public void unRegister() {
     IOUtils.closeQuietly(containerOpsLatency.values());
-    MetricsSystem ms = DefaultMetricsSystem.instance();
+    org.apache.hadoop.metrics2.MetricsSystem ms = MetricsSystem.instance();
     ms.unregisterSource(SOURCE_NAME);
   }
 

hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/grpc/metrics/GrpcMetrics.java

@@ -28,14 +28,14 @@
 import org.apache.hadoop.metrics2.lib.Interns;
 import org.apache.hadoop.metrics2.lib.MutableCounterLong;
 import org.apache.hadoop.metrics2.lib.MetricsRegistry;
-import org.apache.hadoop.metrics2.lib.MutableQuantiles;
-import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
-import org.apache.hadoop.metrics2.lib.MutableRate;
 import org.apache.hadoop.ozone.OzoneConfigKeys;
 import org.apache.hadoop.ozone.OzoneConsts;
+import org.apache.hadoop.ozone.metrics.MutableQuantiles;
 import org.apache.hadoop.ozone.util.MetricUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.apache.hadoop.ozone.metrics.MetricsSystem;
+import org.apache.hadoop.ozone.metrics.MutableRate;
 
 /**
  * Class which maintains metrics related to using GRPC.
@@ -72,11 +72,11 @@ public GrpcMetrics(Configuration conf) {
           new MutableQuantiles[intervals.length];
       for (int i = 0; i < intervals.length; i++) {
         int interval = intervals[i];
-        grpcQueueTimeMillisQuantiles[i] = registry
-            .newQuantiles("grpcQueueTime" + interval
+        grpcQueueTimeMillisQuantiles[i] = MetricsSystem
+            .registerNewMutableQuantiles(registry, "grpcQueueTime" + interval
                     + "s", "grpc queue time in millisecond", "ops",
                 "latency", interval);
-        grpcProcessingTimeMillisQuantiles[i] = registry.newQuantiles(
+        grpcProcessingTimeMillisQuantiles[i] = MetricsSystem.registerNewMutableQuantiles(registry,
             "grpcProcessingTime" + interval + "s",
             "grpc processing time in millisecond",
             "ops", "latency", interval);
@@ -92,15 +92,15 @@ public GrpcMetrics(Configuration conf) {
    */
   public static synchronized GrpcMetrics create(Configuration conf) {
     GrpcMetrics metrics = new GrpcMetrics(conf);
-    return DefaultMetricsSystem.instance().register(SOURCE_NAME,
+    return MetricsSystem.instance().register(SOURCE_NAME,
         "Metrics for using gRPC", metrics);
   }
 
   /**
    * Unregister the metrics instance.
    */
   public void unRegister() {
-    DefaultMetricsSystem.instance().unregisterSource(SOURCE_NAME);
+    MetricsSystem.instance().unregisterSource(SOURCE_NAME);
     MetricUtil.stop(grpcProcessingTimeMillisQuantiles);
     MetricUtil.stop(grpcQueueTimeMillisQuantiles);
   }
@@ -202,7 +202,7 @@ public long getUnknownMessagesSent() {
   public long getUnknownMessagesReceived() {
     return unknownMessagesReceived.value();
   }
-  
+
   MutableRate getGrpcQueueTime() {
     return grpcQueueTime;
   }

hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/metrics/CustomMetricsFactory.java

@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.ozone.metrics;
+
+import org.apache.hadoop.metrics2.MetricsInfo;
+import org.apache.hadoop.metrics2.annotation.Metric;
+import org.apache.hadoop.metrics2.lib.DefaultMetricsFactory;
+import org.apache.hadoop.metrics2.lib.MutableMetric;
+import org.apache.hadoop.metrics2.lib.MutableMetricsFactory;
+
+import java.lang.reflect.Field;
+
+/**
+ * Custom factory to create the objects to measure cluster metrics.
+ */
+public class CustomMetricsFactory
+    extends MutableMetricsFactory {
+
+  private static final MutableMetricsFactory INSTANCE =
+      new CustomMetricsFactory();
+
+  /**
+   * Get {@link MutableMetricsFactory} instance.
+   * @return {@link MutableMetricsFactory} instance
+   */
+  public static MutableMetricsFactory getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * Register as factory for {@link DefaultMetricsFactory} instance.
+   */
+  public static void registerAsDefaultMutableMetricsFactory() {
+    DefaultMetricsFactory.INSTANCE.setInstance(INSTANCE);
+  }
+
+  @Override
+  protected MutableMetric newForField(Field field, Metric annotation) {
+    MetricsInfo info = getInfo(annotation, field);
+    final Class<?> cls = field.getType();
+    if (cls == MutableStat.class) {
+      return new MutableStat(info.name(), info.description(), annotation.sampleName(), annotation.valueName(),
+          annotation.always());
+    }
+
+    if (cls == MutableRate.class) {
+      return new MutableRate(info.name(), info.description(),
+          annotation.always());
+    }
+    if (cls == MutableQuantiles.class) {
+      return new MutableQuantiles(info.name(), annotation.about(),
+          annotation.sampleName(), annotation.valueName(),
+          annotation.interval());
+    }
+    return null;
+  }
+
+}