Make NoopScope metric scope really a no-op operation (#312)

When workflow client code don't provide a metric scope, a default "NoopScope"
is instantiated by cadence client framework. With the current implementation of
NoopScope, a single threaded executor is indirectly created by RootScopeBuilder
for reporting empty metrics at regular interval. This executor is never shutdown.

The side effect is that a client process that just launches a workflow and returns
from main method will stay alive due to the non daemon thread of this executor.

NoopScope rewritten to not launch any reporting threads.

Author: pgoron

src/main/java/com/uber/cadence/internal/metrics/NoopScope.java

@@ -20,63 +20,92 @@
 import com.uber.m3.tally.Buckets;
 import com.uber.m3.tally.Capabilities;
 import com.uber.m3.tally.CapableOf;
-import com.uber.m3.tally.RootScopeBuilder;
+import com.uber.m3.tally.Counter;
+import com.uber.m3.tally.Gauge;
+import com.uber.m3.tally.Histogram;
 import com.uber.m3.tally.Scope;
-import com.uber.m3.tally.StatsReporter;
+import com.uber.m3.tally.Stopwatch;
+import com.uber.m3.tally.Timer;
 import com.uber.m3.util.Duration;
 import java.util.Map;
 
-public final class NoopScope {
-  private static class NoopReporter implements StatsReporter {
-
-    @Override
-    public void reportCounter(String name, Map<String, String> tags, long value) {}
-
-    @Override
-    public void reportGauge(String name, Map<String, String> tags, double value) {}
-
-    @Override
-    public void reportTimer(String name, Map<String, String> tags, Duration interval) {}
-
-    @Override
-    public void reportHistogramValueSamples(
-        String name,
-        Map<String, String> tags,
-        Buckets buckets,
-        double bucketLowerBound,
-        double bucketUpperBound,
-        long samples) {}
-
-    @Override
-    public void reportHistogramDurationSamples(
-        String name,
-        Map<String, String> tags,
-        Buckets buckets,
-        Duration bucketLowerBound,
-        Duration bucketUpperBound,
-        long samples) {}
-
-    @Override
-    public Capabilities capabilities() {
-      return CapableOf.REPORTING_TAGGING;
-    }
+public final class NoopScope implements Scope {
+  private static Scope noopScope;
+  private static Counter noopCounter;
+  private static Gauge noopGauge;
+  private static Timer noopTimer;
+  private static Histogram noopHistogram;
 
-    @Override
-    public void flush() {}
+  @Override
+  public Counter counter(String name) {
+    return noopCounter;
+  }
 
-    @Override
-    public void close() {}
+  @Override
+  public Gauge gauge(String name) {
+    return noopGauge;
   }
 
-  private NoopScope() {}
+  @Override
+  public Timer timer(String name) {
+    return noopTimer;
+  }
+
+  @Override
+  public Histogram histogram(String name, Buckets buckets) {
+    return noopHistogram;
+  }
+
+  @Override
+  public Scope tagged(Map<String, String> tags) {
+    return this;
+  }
+
+  @Override
+  public Scope subScope(String name) {
+    return this;
+  }
+
+  @Override
+  public Capabilities capabilities() {
+    return CapableOf.NONE;
+  }
 
-  private static Scope instance;
+  @Override
+  public void close() {}
+
+  private NoopScope() {}
 
   public static synchronized Scope getInstance() {
-    if (instance == null) {
-      instance =
-          new RootScopeBuilder().reporter(new NoopReporter()).reportEvery(Duration.ofMinutes(1));
+    if (noopScope == null) {
+      noopCounter = delta -> {};
+      noopGauge = value -> {};
+      noopTimer =
+          new Timer() {
+            @Override
+            public void record(Duration interval) {}
+
+            @Override
+            public Stopwatch start() {
+              return new Stopwatch(0, stopwatchStart -> {});
+            }
+          };
+      noopHistogram =
+          new Histogram() {
+            @Override
+            public void recordValue(double value) {}
+
+            @Override
+            public void recordDuration(Duration value) {}
+
+            @Override
+            public Stopwatch start() {
+              return new Stopwatch(0, stopwatchStart -> {});
+            }
+          };
+
+      noopScope = new NoopScope();
     }
-    return instance;
+    return noopScope;
   }
 }