Added Statistic Set Metric Type

Author: lksfrnz

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

@@ -30,7 +30,9 @@
 import software.amazon.cloudwatchlogs.emf.exception.InvalidMetricException;
 import software.amazon.cloudwatchlogs.emf.exception.InvalidNamespaceException;
 import software.amazon.cloudwatchlogs.emf.exception.InvalidTimestampException;
+import software.amazon.cloudwatchlogs.emf.model.AggregationType;
 import software.amazon.cloudwatchlogs.emf.model.DimensionSet;
+import software.amazon.cloudwatchlogs.emf.model.Metric;
 import software.amazon.cloudwatchlogs.emf.model.MetricsContext;
 import software.amazon.cloudwatchlogs.emf.model.StorageResolution;
 import software.amazon.cloudwatchlogs.emf.model.Unit;
@@ -45,6 +47,7 @@ public class MetricsLogger {
     private MetricsContext context;
     private CompletableFuture<Environment> environmentFuture;
     private EnvironmentProvider environmentProvider;
+    @Getter @Setter private volatile AggregationType defaultAggregationType = AggregationType.NONE;
     /**
      * 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
@@ -191,18 +194,23 @@ public MetricsLogger resetDimensions(boolean useDefault) {
      * @param value is the value of the metric
      * @param unit is the unit of the metric value
      * @param storageResolution is the resolution of the metric
+     * @param aggregationType is the aggregation type of the metric
      * @see <a
      *     href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#high-resolution-metrics">CloudWatch
      *     High Resolution Metrics</a>
      * @return the current logger
      * @throws InvalidMetricException if the metric is invalid
      */
     public MetricsLogger putMetric(
-            String key, double value, Unit unit, StorageResolution storageResolution)
+            String key,
+            double value,
+            Unit unit,
+            StorageResolution storageResolution,
+            AggregationType aggregationType)
             throws InvalidMetricException {
         rwl.readLock().lock();
         try {
-            this.context.putMetric(key, value, unit, storageResolution);
+            this.context.putMetric(key, value, unit, storageResolution, aggregationType);
             return this;
         } finally {
             rwl.readLock().unlock();
@@ -225,7 +233,7 @@ public MetricsLogger putMetric(
      */
     public MetricsLogger putMetric(String key, double value, StorageResolution storageResolution)
             throws InvalidMetricException {
-        this.putMetric(key, value, Unit.NONE, storageResolution);
+        this.putMetric(key, value, Unit.NONE, storageResolution, defaultAggregationType);
         return this;
     }
 
@@ -242,7 +250,7 @@ public MetricsLogger putMetric(String key, double value, StorageResolution stora
      */
     public MetricsLogger putMetric(String key, double value, Unit unit)
             throws InvalidMetricException {
-        this.putMetric(key, value, unit, StorageResolution.STANDARD);
+        this.putMetric(key, value, unit, StorageResolution.STANDARD, defaultAggregationType);
         return this;
     }
 
@@ -257,10 +265,111 @@ public MetricsLogger putMetric(String key, double value, Unit unit)
      * @throws InvalidMetricException if the metric is invalid
      */
     public MetricsLogger putMetric(String key, double value) throws InvalidMetricException {
-        this.putMetric(key, value, Unit.NONE, StorageResolution.STANDARD);
+        this.putMetric(key, value, Unit.NONE, StorageResolution.STANDARD, defaultAggregationType);
+        return this;
+    }
+
+    /**
+     * Put a metric value. This value will be emitted to CloudWatch Metrics asynchronously and does
+     * not contribute to your account TPS limits. The value will also be available in your
+     * CloudWatch Logs
+     *
+     * @param key is the name of the metric
+     * @param value is the value of the metric
+     * @param unit is the unit of the metric value
+     * @param storageResolution is the resolution of the metric
+     * @see <a
+     *     href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#high-resolution-metrics">CloudWatch
+     *     High Resolution Metrics</a>
+     * @return the current logger
+     * @throws InvalidMetricException if the metric is invalid
+     */
+    public MetricsLogger putMetric(
+            String key, double value, Unit unit, StorageResolution storageResolution)
+            throws InvalidMetricException {
+        this.putMetric(key, value, Unit.NONE, storageResolution, defaultAggregationType);
+        return this;
+    }
+
+    /**
+     * Put a metric value. This value will be emitted to CloudWatch Metrics asynchronously and does
+     * not contribute to your account TPS limits. The value will also be available in your
+     * CloudWatch Logs
+     *
+     * @param key is the name of the metric
+     * @param value is the value of the metric
+     * @param storageResolution is the resolution of the metric
+     * @param aggregationType is the aggregation type of the metric
+     * @see <a
+     *     href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html#high-resolution-metrics">CloudWatch
+     *     High Resolution Metrics</a>
+     * @return the current logger
+     * @throws InvalidMetricException if the metric is invalid
+     */
+    public MetricsLogger putMetric(
+            String key,
+            double value,
+            StorageResolution storageResolution,
+            AggregationType aggregationType)
+            throws InvalidMetricException {
+        this.putMetric(key, value, Unit.NONE, storageResolution, aggregationType);
+        return this;
+    }
+
+    /**
+     * Put a metric value. This value will be emitted to CloudWatch Metrics asynchronously and does
+     * not contribute to your account TPS limits. The value will also be available in your
+     * CloudWatch Logs
+     *
+     * @param key is the name of the metric
+     * @param value is the value of the metric
+     * @param unit is the unit of the metric value
+     * @param aggregationType is the aggregation type of the metric
+     * @return the current logger
+     * @throws InvalidMetricException if the metric is invalid
+     */
+    public MetricsLogger putMetric(
+            String key, double value, Unit unit, AggregationType aggregationType)
+            throws InvalidMetricException {
+        this.putMetric(key, value, unit, StorageResolution.STANDARD, aggregationType);
+        return this;
+    }
+
+    /**
+     * Put a metric value. This value will be emitted to CloudWatch Metrics asynchronously and does
+     * not contribute to your account TPS limits. The value will also be available in your
+     * CloudWatch Logs
+     *
+     * @param key the name of the metric
+     * @param value the value of the metric
+     * @param aggregationType is the aggregation type of the metric
+     * @return the current logger
+     * @throws InvalidMetricException if the metric is invalid
+     */
+    public MetricsLogger putMetric(String key, double value, AggregationType aggregationType)
+            throws InvalidMetricException {
+        this.putMetric(key, value, Unit.NONE, StorageResolution.STANDARD, aggregationType);
         return this;
     }
 
+    /**
+     * Set a metric value, if a metric already has the same key it will be overwitten. This value
+     * will be emitted to CloudWatch Metrics asynchronously and does not contribute to your account
+     * TPS limits. The value will also be available in your CloudWatch Logs
+     *
+     * @param key the name of the metric
+     * @param value the value of the metric
+     * @return the current logger
+     * @throws InvalidMetricException if the metric is invalid
+     */
+    public MetricsLogger setMetric(String key, Metric value) {
+        return applyReadLock(
+                () -> {
+                    this.context.setMetric(key, value);
+                    return this;
+                });
+    }
+
     /**
      * Add a custom key-value pair to the Metadata object.
      *

src/main/java/software/amazon/cloudwatchlogs/emf/model/AggregationType.java

@@ -0,0 +1,33 @@
+/*
+ *   Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *   Licensed 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
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   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 software.amazon.cloudwatchlogs.emf.model;
+
+public enum AggregationType {
+    NONE(60),
+    STATISTIC_SET(1),
+    UNKNOWN_TO_SDK_VERSION(-1);
+
+    private final int value;
+
+    AggregationType(final int newValue) {
+        value = newValue;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+}

src/main/java/software/amazon/cloudwatchlogs/emf/model/Metric.java

@@ -41,15 +41,15 @@ public abstract class Metric<V> {
     @JsonProperty("Unit")
     @JsonSerialize(using = UnitSerializer.class)
     @JsonDeserialize(using = UnitDeserializer.class)
-    protected Unit unit;
+    protected Unit unit = Unit.NONE;
 
     @JsonProperty("StorageResolution")
     @JsonInclude(
             value = JsonInclude.Include.CUSTOM,
             valueFilter =
                     StorageResolutionFilter.class) // Do not serialize when valueFilter is true
     @JsonSerialize(using = StorageResolutionSerializer.class)
-    protected StorageResolution storageResolution;
+    protected StorageResolution storageResolution = StorageResolution.STANDARD;
 
     @JsonIgnore @Getter protected V values;
 
@@ -58,6 +58,9 @@ protected Object getFormattedValues() {
         return this.getValues();
     }
 
+    /** @return true if the values of this metric are valid, false otherwise. */
+    public abstract boolean hasValidValues();
+
     /**
      * Creates a Metric with the first {@code size} values of the current metric
      *
@@ -109,6 +112,10 @@ public T storageResolution(StorageResolution storageResolution) {
             return getThis();
         }
 
+        public boolean hasValidValues() {
+            return build().hasValidValues();
+        }
+
         protected Metric getMetricValuesOverSize(int size) {
             return build().getMetricValuesOverSize(size);
         }

src/main/java/software/amazon/cloudwatchlogs/emf/model/MetricDefinition.java

@@ -82,6 +82,11 @@ protected Object getFormattedValues() {
         return values.size() == 1 ? values.get(0) : values;
     }
 
+    @Override
+    public boolean hasValidValues() {
+        return values != null && !values.isEmpty();
+    }
+
     public static class MetricDefinitionBuilder
             extends Metric.MetricBuilder<List<Double>, MetricDefinitionBuilder> {
 

src/main/java/software/amazon/cloudwatchlogs/emf/model/MetricDirective.java

@@ -69,31 +69,44 @@ void putDimensionSet(DimensionSet dimensionSet) {
 
     // Helper method for testing putMetric()
     void putMetric(String key, double value) {
-        putMetric(key, value, Unit.NONE, StorageResolution.STANDARD);
+        putMetric(key, value, Unit.NONE, StorageResolution.STANDARD, AggregationType.NONE);
     }
 
     // Helper method for testing putMetric()
     void putMetric(String key, double value, Unit unit) {
-        putMetric(key, value, unit, StorageResolution.STANDARD);
+        putMetric(key, value, unit, StorageResolution.STANDARD, AggregationType.NONE);
     }
 
     // Helper method for testing serialization
     void putMetric(String key, double value, StorageResolution storageResolution) {
-        putMetric(key, value, Unit.NONE, storageResolution);
+        putMetric(key, value, Unit.NONE, storageResolution, AggregationType.NONE);
     }
 
-    void putMetric(String key, double value, Unit unit, StorageResolution storageResolution) {
+    void putMetric(
+            String key,
+            double value,
+            Unit unit,
+            StorageResolution storageResolution,
+            AggregationType aggregationType) {
         metrics.compute(
                 key,
                 (k, v) -> {
                     if (v == null) {
-                        MetricDefinition.MetricDefinitionBuilder builder =
-                                MetricDefinition.builder()
+                        switch (aggregationType) {
+                            case STATISTIC_SET:
+                                return StatisticSet.builder()
                                         .name(k)
                                         .unit(unit)
                                         .storageResolution(storageResolution)
                                         .addValue(value);
-                        return builder;
+                            case NONE:
+                            default:
+                                return MetricDefinition.builder()
+                                        .name(k)
+                                        .unit(unit)
+                                        .storageResolution(storageResolution)
+                                        .addValue(value);
+                        }
                     } else if (v instanceof Metric.MetricBuilder) {
                         ((Metric.MetricBuilder) v).addValue(value);
                         return v;
@@ -106,6 +119,18 @@ void putMetric(String key, double value, Unit unit, StorageResolution storageRes
                 });
     }
 
+    /**
+     * Sets a metric to the given value. If a metric with the same name already exists, it will be
+     * overwritten.
+     *
+     * @param key the name of the metric
+     * @param value the value of the metric
+     */
+    void setMetric(String key, Metric value) {
+        value.setName(key);
+        metrics.put(key, value);
+    }
+
     @JsonProperty("Metrics")
     Collection<Metric> getAllMetrics() {
         return metrics.values();