fix(metrics): Support multiple addMetric() call with the same metric name

Author: ijemmy

packages/metrics/package-lock.json

@@ -10,7 +10,7 @@
     "commit": "commit",
     "test": "jest --group=unit --detectOpenHandles --coverage --verbose",
     "test:e2e": "jest --group=e2e",
-    "watch": "jest --watch",
+    "watch": "jest --group=unit --watch ",
     "build": "tsc",
     "lint": "eslint --ext .ts --fix --no-error-on-unmatched-pattern src tests",
     "format": "eslint --fix --ext .ts --fix --no-error-on-unmatched-pattern src tests",

packages/metrics/package.json

@@ -311,7 +311,7 @@ class Metrics implements MetricsInterface {
     if (!this.namespace) console.warn('Namespace should be defined, default used');
 
     const metricValues = Object.values(this.storedMetrics).reduce(
-      (result: { [key: string]: number }, { name, value }: { name: string; value: number }) => {
+      (result: { [key: string]: number | number[] }, { name, value }: { name: string; value: number | number[] }) => {
         result[name] = value;
 
         return result;
@@ -390,6 +390,19 @@ class Metrics implements MetricsInterface {
     return <EnvironmentVariablesService> this.envVarsService;
   }
 
+  private isNewMetric(name: string, unit: MetricUnit): boolean {
+    if (this.storedMetrics[name]){
+      // Inconsistent units indicates a bug or typos. We want to flag this to users early early
+      if (this.storedMetrics[name].unit !== unit) {
+        throw new Error('The same metric name has been added before with a different unit.');
+      }
+      
+      return false;
+    } else {
+      return true;
+    }
+  }
+
   private setCustomConfigService(customConfigService?: ConfigServiceInterface): void {
     this.customConfigService = customConfigService ? customConfigService : undefined;
   }
@@ -430,12 +443,22 @@ class Metrics implements MetricsInterface {
     if (Object.keys(this.storedMetrics).length >= MAX_METRICS_SIZE) {
       this.purgeStoredMetrics();
     }
-    this.storedMetrics[name] = {
-      unit,
-      value,
-      name,
-    };
+
+    if (this.isNewMetric(name, unit)) {
+      this.storedMetrics[name] = {
+        unit,
+        value,
+        name,
+      };
+    } else {
+      const storedMetric = this.storedMetrics[name];
+      if (!Array.isArray(storedMetric.value)) {
+        storedMetric.value = [storedMetric.value];
+      }
+      storedMetric.value.push(value);
+    }
   }
+
 }
 
 export { Metrics, MetricUnits };

packages/metrics/src/Metrics.ts

@@ -59,7 +59,7 @@ type ExtraOptions = {
 type StoredMetric = {
   name: string
   unit: MetricUnit
-  value: number
+  value: number | number[]
 };
 
 type StoredMetrics = {

packages/metrics/src/types/Metrics.ts

@@ -435,6 +435,55 @@ describe('Class: Metrics', () => {
       expect(serializedMetrics._aws.CloudWatchMetrics[0].Namespace).toBe(DEFAULT_NAMESPACE);
       expect(console.warn).toHaveBeenNthCalledWith(1, 'Namespace should be defined, default used');
     });
+
+    test('Should contain a metric value if added once', ()=> {
+      const metrics = new Metrics();
+      
+      metrics.addMetric('test_name', MetricUnits.Count, 1);
+      const serializedMetrics = metrics.serializeMetrics();
+
+      expect(serializedMetrics._aws.CloudWatchMetrics[0].Metrics.length).toBe(1);
+      
+      expect(serializedMetrics['test_name']).toBe(1);
+    });
+
+    test('Should convert multiple metrics with the same name and unit into an array', ()=> {
+      const metrics = new Metrics();
+      
+      metrics.addMetric('test_name', MetricUnits.Count, 2);
+      metrics.addMetric('test_name', MetricUnits.Count, 1);
+      const serializedMetrics = metrics.serializeMetrics();
+
+      expect(serializedMetrics._aws.CloudWatchMetrics[0].Metrics.length).toBe(1);
+      expect(serializedMetrics['test_name']).toStrictEqual([ 2, 1 ]);
+    });
+
+    test('Should throw an error if the same metric name is added again with a different unit', ()=> {
+      const metrics = new Metrics();
+      
+      metrics.addMetric('test_name', MetricUnits.Count, 2);
+      try {
+        metrics.addMetric('test_name', MetricUnits.Seconds, 10);
+      } catch (e) {
+        expect((<Error>e).message).toBe('The same metric name has been added before with a different unit.');
+      }
+    });
+
+    test('Should contain multiple metric values if added with multiple names', ()=> {
+      const metrics = new Metrics();
+      
+      metrics.addMetric('test_name', MetricUnits.Count, 1);
+      metrics.addMetric('test_name2', MetricUnits.Count, 2);
+      const serializedMetrics = metrics.serializeMetrics();
+
+      expect(serializedMetrics._aws.CloudWatchMetrics[0].Metrics).toStrictEqual([
+        { Name: 'test_name', Unit: 'Count' },
+        { Name: 'test_name2', Unit: 'Count' },
+      ]);
+      
+      expect(serializedMetrics['test_name']).toBe(1);
+      expect(serializedMetrics['test_name2']).toBe(2);
+    });
   });
 
   describe('Feature: Clearing Metrics ', () => {

packages/metrics/tests/unit/Metrics.test.ts

@@ -44,14 +44,47 @@ describe('Middy middleware', () => {
       succeed: () => console.log('Succeeded!'),
     };
 
+    test('when a metrics instance receive multiple metrics with the same name, it prints multiple values in an array format', async () => {
+      // Prepare
+      const metrics = new Metrics({ namespace:'serverlessAirline', service:'orders' });
+
+      const lambdaHandler = (): void => {
+        metrics.addMetric('successfulBooking', MetricUnits.Count, 2);
+        metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
+      };
+
+      const handler = middy(lambdaHandler).use(logMetrics(metrics));
+      
+      // Act
+      await handler(event, context, () => console.log('Lambda invoked!'));
+      
+      // Assess
+      expect(console.log).toHaveBeenNthCalledWith(1, JSON.stringify({
+        '_aws': {
+          'Timestamp': 1466424490000,
+          'CloudWatchMetrics': [{
+            'Namespace': 'serverlessAirline',
+            'Dimensions': [
+              ['service']
+            ],
+            'Metrics': [{ 'Name': 'successfulBooking', 'Unit': 'Count' }],
+          }],
+        },
+        'service': 'orders',
+        'successfulBooking': [
+          2,
+          1,
+        ],
+      }));
+    });
+
     test('when a metrics instance is passed WITH custom options, it prints the metrics in the stdout', async () => {
 
       // Prepare
       const metrics = new Metrics({ namespace:'serverlessAirline', service:'orders' });
 
       const lambdaHandler = (): void => {
         metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
-        metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
       };
       const metricsOptions: ExtraOptions = {
         raiseOnEmptyMetrics: true,
@@ -107,7 +140,6 @@ describe('Middy middleware', () => {
 
       const lambdaHandler = (): void => {
         metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
-        metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
       };
 
       const handler = middy(lambdaHandler).use(logMetrics(metrics));
@@ -140,7 +172,6 @@ describe('Middy middleware', () => {
 
       const lambdaHandler = (): void => {
         metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
-        metrics.addMetric('successfulBooking', MetricUnits.Count, 1);
       };
       const metricsOptions: ExtraOptions = {
         raiseOnEmptyMetrics: true