test(metrics): add array input for middleware

Author: saragerion

packages/metrics/src/middleware/middy.ts

@@ -2,23 +2,30 @@ import type { Metrics } from '../Metrics';
 import middy from '@middy/core';
 import { ExtraOptions } from '../types';
 
-const logMetrics = (metrics: Metrics, options: ExtraOptions = {}): middy.MiddlewareObj => {
+const logMetrics = (target: Metrics | Metrics[], options: ExtraOptions = {}): middy.MiddlewareObj => {
+  const metricsInstances = target instanceof Array ? target : [target];
+
   const logMetricsBefore = async (request: middy.Request): Promise<void> => {
-    metrics.setFunctionName(request.context.functionName);
-    const { raiseOnEmptyMetrics, defaultDimensions, captureColdStartMetric } = options;
-    if (raiseOnEmptyMetrics !== undefined) {
-      metrics.raiseOnEmptyMetrics();
-    }
-    if (defaultDimensions !== undefined) {
-      metrics.setDefaultDimensions(defaultDimensions);
-    }
-    if (captureColdStartMetric !== undefined) {
-      metrics.captureColdStartMetric();
-    }
+    metricsInstances.forEach((metrics: Metrics) => {
+      metrics.setFunctionName(request.context.functionName);
+      const { raiseOnEmptyMetrics, defaultDimensions, captureColdStartMetric } = options;
+      if (raiseOnEmptyMetrics !== undefined) {
+        metrics.raiseOnEmptyMetrics();
+      }
+      if (defaultDimensions !== undefined) {
+        metrics.setDefaultDimensions(defaultDimensions);
+      }
+      if (captureColdStartMetric !== undefined) {
+        metrics.captureColdStartMetric();
+      }
+    });
+
   };
 
   const logMetricsAfter = async (): Promise<void> => {
-    metrics.purgeStoredMetrics();
+    metricsInstances.forEach((metrics: Metrics) => {
+      metrics.purgeStoredMetrics();
+    });
   };
 
   return {

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

@@ -229,7 +229,7 @@ describe('Class: Metrics', () => {
     test('Cold start metric should only be written out once and flushed automatically', async () => {
       const metrics = new Metrics({ namespace: 'test' });
 
-      const handler = async (_event, _context): Promise<void> => {
+      const handler = async (_event: unknown, _context: unknown): Promise<void> => {
         // Should generate only one log
         metrics.captureColdStartMetric();
       };
@@ -363,7 +363,7 @@ describe('Class: Metrics', () => {
       expect.assertions(1);
 
       const metrics = new Metrics({ namespace: 'test' });
-      const handler = async (_event, _context): Promise<void> => {
+      const handler = async (_event: unknown, _context: unknown): Promise<void> => {
         metrics.raiseOnEmptyMetrics();
         // Logic goes here
         metrics.purgeStoredMetrics();

packages/metrics/tests/unit/middleware/middy.test.ts

@@ -142,6 +142,59 @@ describe('Middy middleware', () => {
 
     });
 
+    test('when an array of Metrics instances is passed, 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
+      };
+      const handler = middy(lambdaHandler).use(logMetrics([metrics], metricsOptions));
+      const event = { foo: 'bar' };
+      const getRandomInt = (): number => Math.floor(Math.random() * 1000000000);
+
+      const awsRequestId = getRandomInt().toString();
+      const context = {
+        callbackWaitsForEmptyEventLoop: true,
+        functionVersion: '$LATEST',
+        functionName: 'foo-bar-function',
+        memoryLimitInMB: '128',
+        logGroupName: '/aws/lambda/foo-bar-function',
+        logStreamName: '2021/03/09/[$LATEST]abcdef123456abcdef123456abcdef123456',
+        invokedFunctionArn: 'arn:aws:lambda:eu-central-1:123456789012:function:foo-bar-function',
+        awsRequestId: awsRequestId,
+        getRemainingTimeInMillis: () => 1234,
+        done: () => console.log('Done!'),
+        fail: () => console.log('Failed!'),
+        succeed: () => console.log('Succeeded!'),
+      };
+
+      // 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': 1,
+      }));
+
+    });
+
   });
 
 });