Refactor slightly for readability; add locking to avoid very unlikely but very confusing corruption of the static data we use to display the multiple instantiations

Author: tjquinno

metrics/providers/micrometer/src/main/java/io/helidon/metrics/providers/micrometer/MMeterRegistry.java

@@ -17,16 +17,18 @@
 
 import java.lang.System.Logger.Level;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.StringJoiner;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -83,6 +85,7 @@ class MMeterRegistry implements io.helidon.metrics.api.MeterRegistry {
 
     private static volatile StackTraceElement[] originalCreationStackTrace;
     private static volatile boolean hasLoggedFirstMultiInstantiationWarning = false;
+    private static final Lock WARNING_INFO_LOCK = new ReentrantLock();
 
     private final io.micrometer.core.instrument.MeterRegistry delegate;
 
@@ -123,22 +126,7 @@ private MMeterRegistry(io.micrometer.core.instrument.MeterRegistry delegate,
         this.clock = clock;
         this.metricsFactory = metricsFactory;
         this.metricsConfig = metricsConfig;
-        if (originalCreationStackTrace == null) {
-            originalCreationStackTrace = Thread.currentThread().getStackTrace();
-        } else if (metricsConfig.warnOnMultipleRegistries()) {
-            if (!hasLoggedFirstMultiInstantiationWarning) {
-                hasLoggedFirstMultiInstantiationWarning = true;
-                LOGGER.log(Level.WARNING,
-                           "Unexpected duplicate instantiation\nOriginal instantiation from:\n{0}\n\nAdditional instantiation "
-                                   + "from:\n{1}",
-                           Arrays.toString(originalCreationStackTrace),
-                           Arrays.toString(Thread.currentThread().getStackTrace()));
-            } else {
-                LOGGER.log(Level.WARNING,
-                           "Unexpected additional instantiation from:\n{0}",
-                           Arrays.toString(Thread.currentThread().getStackTrace()));
-            }
-        }
+        checkMultipleInstantiations(metricsConfig);
     }
 
     static Builder builder(
@@ -583,6 +571,45 @@ static void clearMultipleInstantiationInfo() {
         originalCreationStackTrace = null;
     }
 
+    private static void checkMultipleInstantiations(MetricsConfig metricsConfig) {
+        /*
+        We have not seen cases where multiple instantiations occur concurrently, but it's possible. Locking guards against the
+        very rare but probably very confusing possibility of our attempt at clarifying where multiple instantiations are occurring
+        actually getting corrupted by concurrent access to the static fields.
+         */
+        WARNING_INFO_LOCK.lock();
+        try {
+            if (originalCreationStackTrace == null) {
+                originalCreationStackTrace = Thread.currentThread().getStackTrace();
+            } else if (metricsConfig.warnOnMultipleRegistries()) {
+                if (!hasLoggedFirstMultiInstantiationWarning) {
+                    hasLoggedFirstMultiInstantiationWarning = true;
+                    LOGGER.log(Level.WARNING,
+                               "Unexpected duplicate instantiation\n"
+                                       + "Original instantiation from:\n{0}\n\n"
+                                       + "Additional instantiation from:\n{1}\n",
+
+                               stackTraceToString(originalCreationStackTrace),
+                               stackTraceToString(Thread.currentThread().getStackTrace()));
+                } else {
+                    LOGGER.log(Level.WARNING,
+                               "Unexpected additional instantiation from:\n{0}\n",
+                               stackTraceToString(Thread.currentThread().getStackTrace()));
+                }
+            }
+        } finally {
+            WARNING_INFO_LOCK.unlock();
+        }
+    }
+
+    private static String stackTraceToString(StackTraceElement[] stackTraceElements) {
+        StringJoiner joiner = new StringJoiner("\n");
+        for (StackTraceElement element : stackTraceElements) {
+            joiner.add(element.toString());
+        }
+        return joiner.toString();
+    }
+
     private io.helidon.metrics.api.Meter noopMeterIfDisabled(io.helidon.metrics.api.Meter.Builder<?, ?> builder) {
         if (!isMeterEnabled(builder.name(), builder.tags(), builder.scope())) {