Adjusted the code format

Author: Stephen-Bao

src/jmh/java/software/amazon/cloudwatchlogs/emf/MetricsLoggerBenchmark.java

@@ -80,8 +80,8 @@ public void measureAllMethods() {
     }
 
     /**
-     * Each thread publishes 1000 metrics, 10 threads in total.
-     * no lock: 0.949 ms/op; RW lock: 3.823 ms/op; S lock: 3.078 ms/op
+     * Each thread publishes 1000 metrics, 10 threads in total. no lock: 0.949 ms/op; RW lock: 3.823
+     * ms/op; S lock: 3.078 ms/op
      *
      * @throws InterruptedException
      */
@@ -91,8 +91,8 @@ public void measurePutMetricWith10Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread publishes 1000 metrics, 20 threads in total.
-     * no lock: 1.860 ms/op; RW lock: 9.806 ms/op; S lock: 7.929 ms/op
+     * Each thread publishes 1000 metrics, 20 threads in total. no lock: 1.860 ms/op; RW lock: 9.806
+     * ms/op; S lock: 7.929 ms/op
      *
      * @throws InterruptedException
      */
@@ -102,8 +102,8 @@ public void measurePutMetricWith20Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread publishes 1000 metrics, 50 threads in total.
-     * no lock: 6.548 ms/op; RW lock: 28.754 ms/op; S lock: 24.700 ms/op
+     * Each thread publishes 1000 metrics, 50 threads in total. no lock: 6.548 ms/op; RW lock:
+     * 28.754 ms/op; S lock: 24.700 ms/op
      *
      * @throws InterruptedException
      */
@@ -113,8 +113,8 @@ public void measurePutMetricWith50Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread publishes 1000 metrics, 200 threads in total.
-     * no lock: 37.662 ms/op; RW lock: 135.824 ms/op; S lock: 114.467 ms/op
+     * Each thread publishes 1000 metrics, 200 threads in total. no lock: 37.662 ms/op; RW lock:
+     * 135.824 ms/op; S lock: 114.467 ms/op
      *
      * @throws InterruptedException
      */
@@ -124,8 +124,8 @@ public void measurePutMetricWith200Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread publishes 1000 metrics, 500 threads in total.
-     * no lock: 90.148 ms/op; RW lock: 345.197 ms/op; S lock: 287.908 ms/op
+     * Each thread publishes 1000 metrics, 500 threads in total. no lock: 90.148 ms/op; RW lock:
+     * 345.197 ms/op; S lock: 287.908 ms/op
      *
      * @throws InterruptedException
      */
@@ -137,8 +137,8 @@ public void measurePutMetricWith500Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread flushes 100 times, 10 threads in total.
-     * no lock: 12.900 ms/op; RW lock: 25.015 ms/op; S lock: 24.778 ms/op
+     * Each thread flushes 100 times, 10 threads in total. no lock: 12.900 ms/op; RW lock: 25.015
+     * ms/op; S lock: 24.778 ms/op
      *
      * @throws InterruptedException
      */
@@ -148,8 +148,8 @@ public void measureFlushWith10Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread flushes 100 times, 20 threads in total.
-     * no lock: 20.824 ms/op; RW lock: 47.123 ms/op; S lock: 48.511 ms/op
+     * Each thread flushes 100 times, 20 threads in total. no lock: 20.824 ms/op; RW lock: 47.123
+     * ms/op; S lock: 48.511 ms/op
      *
      * @throws InterruptedException
      */
@@ -159,8 +159,8 @@ public void measureFlushWith20Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread flushes 100 times, 50 threads in total.
-     * no lock: 77.463 ms/op; RW lock: 121.857 ms/op; S lock: 125.212 ms/op
+     * Each thread flushes 100 times, 50 threads in total. no lock: 77.463 ms/op; RW lock: 121.857
+     * ms/op; S lock: 125.212 ms/op
      *
      * @throws InterruptedException
      */
@@ -170,8 +170,8 @@ public void measureFlushWith50Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread flushes 100 times, 200 threads in total.
-     * no lock: 390.252 ms/op; RW lock: 474.439 ms/op; S lock: 488.809 ms/op
+     * Each thread flushes 100 times, 200 threads in total. no lock: 390.252 ms/op; RW lock: 474.439
+     * ms/op; S lock: 488.809 ms/op
      *
      * @throws InterruptedException
      */
@@ -181,8 +181,8 @@ public void measureFlushWith200Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread flushes 100 times, 500 threads in total.
-     * no lock: 300.280 ms/op; RW lock: 1161.098 ms/op; S lock: 1247.972 ms/op
+     * Each thread flushes 100 times, 500 threads in total. no lock: 300.280 ms/op; RW lock:
+     * 1161.098 ms/op; S lock: 1247.972 ms/op
      *
      * @throws InterruptedException
      */
@@ -194,9 +194,9 @@ public void measureFlushWith500Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 10 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 7.215 ms/op;
-     * RW lock: 32.159; S lock: 34.226
+     * Each thread executes all methods 100 times, 10 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 7.215 ms/op; RW lock:
+     * 32.159; S lock: 34.226
      *
      * @throws InterruptedException
      */
@@ -206,9 +206,9 @@ public void measureAllMethodsWith10Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 20 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 11.833 ms/op;
-     * RW lock: 60.510 ms/op; S lock: 75.125 ms/op
+     * Each thread executes all methods 100 times, 20 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 11.833 ms/op; RW lock:
+     * 60.510 ms/op; S lock: 75.125 ms/op
      *
      * @throws InterruptedException
      */
@@ -218,9 +218,9 @@ public void measureAllMethodsWith20Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 50 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 36.051 ms/op;
-     * RW lock: 150.022 ms/op; S lock: 244.934 ms/op
+     * Each thread executes all methods 100 times, 50 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 36.051 ms/op; RW lock:
+     * 150.022 ms/op; S lock: 244.934 ms/op
      *
      * @throws InterruptedException
      */
@@ -230,9 +230,9 @@ public void measureAllMethodsWith50Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 200 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 108.775 ms/op;
-     * RW lock: 629.826 ms/op; S lock: 1220.959 ms/op
+     * Each thread executes all methods 100 times, 200 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 108.775 ms/op; RW lock:
+     * 629.826 ms/op; S lock: 1220.959 ms/op
      *
      * @throws InterruptedException
      */
@@ -244,9 +244,9 @@ public void measureAllMethodsWith200Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 500 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 335.183 ms/op;
-     * RW lock: 1741.003 ms/op; S lock: 4192.327 ms/op
+     * Each thread executes all methods 100 times, 500 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 335.183 ms/op; RW lock:
+     * 1741.003 ms/op; S lock: 4192.327 ms/op
      *
      * @throws InterruptedException
      */
@@ -258,9 +258,9 @@ public void measureAllMethodsWith500Threads() throws InterruptedException {
     }
 
     /**
-     * Each thread executes all methods 100 times, 1000 threads in total.
-     * no lock (need to sync getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 575.339 ms/op;
-     * RW lock: 3230.403 ms/op; S lock: 13519.459 ms/op
+     * Each thread executes all methods 100 times, 1000 threads in total. no lock (need to sync
+     * getAllDimensions() & getAllDimensionKeys() in MetricsDirective): 575.339 ms/op; RW lock:
+     * 3230.403 ms/op; S lock: 13519.459 ms/op
      *
      * @throws InterruptedException
      */

src/main/java/software/amazon/cloudwatchlogs/emf/logger/MetricsLogger.java

@@ -20,7 +20,6 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
-
 import lombok.extern.slf4j.Slf4j;
 import software.amazon.cloudwatchlogs.emf.environment.Environment;
 import software.amazon.cloudwatchlogs.emf.environment.EnvironmentProvider;
@@ -39,9 +38,10 @@ public class MetricsLogger {
     private CompletableFuture<Environment> environmentFuture;
     private EnvironmentProvider environmentProvider;
     /**
-     * This lock is used to create an internal sync context for flush() method in multi-threaded situations.
-     * Flush() acquires write lock, other methods (accessing mutable shared data with flush()) acquires read lock.
-     * This makes sure flush() is executed exclusively, while other methods can be executed concurrently.
+     * This lock is used to create an internal sync context for flush() method in multi-threaded
+     * situations. Flush() acquires write lock, other methods (accessing mutable shared data with
+     * flush()) acquires read lock. This makes sure flush() is executed exclusively, while other
+     * methods can be executed concurrently.
      */
     private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
 
@@ -98,10 +98,11 @@ public void flush() {
      * @return the current logger
      */
     public MetricsLogger putProperty(String key, Object value) {
-        return applyReadLock(() -> {
-            this.context.putProperty(key, value);
-            return this;
-        });
+        return applyReadLock(
+                () -> {
+                    this.context.putProperty(key, value);
+                    return this;
+                });
     }
 
     /**
@@ -116,10 +117,11 @@ public MetricsLogger putProperty(String key, Object value) {
      * @return the current logger
      */
     public MetricsLogger putDimensions(DimensionSet dimensions) {
-        return applyReadLock(() -> {
-            context.putDimension(dimensions);
-            return this;
-        });
+        return applyReadLock(
+                () -> {
+                    context.putDimension(dimensions);
+                    return this;
+                });
     }
 
     /**
@@ -132,10 +134,11 @@ public MetricsLogger putDimensions(DimensionSet dimensions) {
      * @return the current logger
      */
     public MetricsLogger setDimensions(DimensionSet... dimensionSets) {
-        return applyReadLock(() -> {
-            context.setDimensions(dimensionSets);
-            return this;
-        });
+        return applyReadLock(
+                () -> {
+                    context.setDimensions(dimensionSets);
+                    return this;
+                });
     }
 
     /**
@@ -149,10 +152,11 @@ public MetricsLogger setDimensions(DimensionSet... dimensionSets) {
      * @return the current logger
      */
     public MetricsLogger putMetric(String key, double value, Unit unit) {
-        return applyReadLock(() -> {
-            this.context.putMetric(key, value, unit);
-            return this;
-        });
+        return applyReadLock(
+                () -> {
+                    this.context.putMetric(key, value, unit);
+                    return this;
+                });
     }
 
     /**
@@ -180,10 +184,11 @@ public MetricsLogger putMetric(String key, double value) {
      * @return the current logger
      */
     public MetricsLogger putMetadata(String key, Object value) {
-        return applyReadLock(() -> {
-            this.context.putMetadata(key, value);
-            return this;
-        });
+        return applyReadLock(
+                () -> {
+                    this.context.putMetadata(key, value);
+                    return this;
+                });
     }
 
     /**

src/test/java/software/amazon/cloudwatchlogs/emf/logger/MetricsLoggerThreadSafetyTest.java

@@ -64,7 +64,9 @@ public void testConcurrentPutProperty() throws InterruptedException {
                                     Thread.sleep(targetTimestampToRun - System.currentTimeMillis());
                                     for (int j = 0; j < 1000; j++) {
                                         int propertyId = 1000 * id + j;
-                                        logger.putProperty("Property-" + propertyId, String.valueOf(propertyId));
+                                        logger.putProperty(
+                                                "Property-" + propertyId,
+                                                String.valueOf(propertyId));
                                     }
                                 } catch (Throwable e) {
                                     throwable = e; // ensure no exceptions are thrown
@@ -98,7 +100,9 @@ public void testConcurrentPutDimension() throws InterruptedException {
                                     Thread.sleep(targetTimestampToRun - System.currentTimeMillis());
                                     for (int j = 0; j < 1000; j++) {
                                         int dimensionId = 1000 * id + j;
-                                        logger.putDimensions(DimensionSet.of("Dim", String.valueOf(dimensionId)));
+                                        logger.putDimensions(
+                                                DimensionSet.of(
+                                                        "Dim", String.valueOf(dimensionId)));
                                     }
                                 } catch (Throwable e) {
                                     throwable = e;
@@ -144,7 +148,9 @@ public void testConcurrentPutDimensionAfterSetDimension() throws InterruptedExce
                                     Thread.sleep(targetTimestampToRun - System.currentTimeMillis());
                                     for (int j = 0; j < 1000; j++) {
                                         int dimensionId = 1000 * id + j + 1;
-                                        logger.putDimensions(DimensionSet.of("Dim", String.valueOf(dimensionId)));
+                                        logger.putDimensions(
+                                                DimensionSet.of(
+                                                        "Dim", String.valueOf(dimensionId)));
                                     }
                                 } catch (Throwable e) {
                                     throwable = e;
@@ -355,7 +361,7 @@ public void testConcurrentFlushAndMethodsOtherThanPutMetric() throws Interrupted
     @After
     public void tearDown() throws Throwable {
         if (throwable != null) throw throwable;
-        throwable = null;  // reset throwable to prevent repeat throwing
+        throwable = null; // reset throwable to prevent repeat throwing
     }
 
     private Map<String, Object> parseRootNode(String event) throws JsonProcessingException {

src/test/java/software/amazon/cloudwatchlogs/emf/model/MetricDirectiveThreadSafetyTest.java

@@ -13,15 +13,22 @@ public class MetricDirectiveThreadSafetyTest {
     public void testConcurrentPutMetricWithDifferentKey() throws InterruptedException {
         MetricDirective metricDirective = new MetricDirective();
         Thread[] threads = new Thread[100];
-        long targetTimestampToRun = System.currentTimeMillis() + 500; // all threads should target running on this timestamp
+        long targetTimestampToRun =
+                System.currentTimeMillis()
+                        + 500; // all threads should target running on this timestamp
 
         for (int i = 0; i < 100; i++) {
             final int id = i;
             threads[i] =
                     new Thread(
                             () -> {
                                 try {
-                                    Thread.sleep(targetTimestampToRun - System.currentTimeMillis());  // try to make all threads run at same time
+                                    Thread.sleep(
+                                            targetTimestampToRun
+                                                    - System.currentTimeMillis()); // try to make
+                                    // all threads
+                                    // run at same
+                                    // time
                                     for (int j = 0; j < 1000; j++) {
                                         int metricId = 1000 * id + j;
                                         metricDirective.putMetric("Metric-" + metricId, metricId);