feat: adding composite alarm type

Adding composite alarm type, using existing topic in alarmsactions,
adding tests

Author: ralfonsoreyes

.husky/.gitignore

@@ -1 +1 @@
-_
+_

jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  roots: ['<rootDir>/src'],
+  testRegex: '(/_test_/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?|ts)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  testPathIgnorePatterns: ['node_modules'],
+  testTimeout: 10000,
+  testEnvironment: 'node',
+};

package.json

@@ -26,6 +26,7 @@
     "lodash.upperfirst": "^4.3.1"
   },
   "devDependencies": {
+    "@types/jest": "^27.3.1",
     "@commitlint/config-conventional": "^11.0.0",
     "commitlint": "^11.0.0",
     "eslint": "^7.19.0",
@@ -44,10 +45,5 @@
   },
   "engines": {
     "node": ">=8.10.0"
-  },
-  "jest": {
-    "testMatch": [
-      "<rootDir>/src/**/*.test.js"
-    ]
   }
 }

src/index.js

@@ -568,6 +568,101 @@ class AlertsPlugin {
     this.addCfResources(cf);
   }
 
+  _getCfResourceAndName(prefix, definitionName) {
+    const service = this.serverless.service;
+    const provider = service.provider;
+    const stage = this.options.stage;
+    const region = this.options.region || provider.region;
+    const capitalDefinitionName = upperFirst(definitionName);
+    return {
+      cfResource: `Alerts${prefix}${capitalDefinitionName}`,
+      cfName: `${service.service}-${stage}-${region}-${capitalDefinitionName}`,
+    };
+  }
+
+  _getFilteredResourcesAsArray(resourcesKeys) {
+    const resources =
+      this.serverless.service.provider.compiledCloudFormationTemplate.Resources;
+    return Object.keys(resources)
+      .filter(
+        (resource) =>
+          !resourcesKeys ||
+          resourcesKeys.length === 0 ||
+          resourcesKeys.indexOf(resource) !== -1
+      )
+      .map((key) => resources[key]);
+  }
+
+  _resolveAlarmRules(definition) {
+    const alarmsToInclude = this._getFilteredResourcesAsArray(
+      definition.alarmsToInclude
+    )
+      .filter(
+        (resource) =>
+          resource.Type === 'AWS::CloudWatch::Alarm' &&
+          resource.Properties.enabled !== false
+      )
+      .map((resource) => resource.Properties.AlarmName);
+
+    const alarmRule = alarmsToInclude
+      .map((alarmToInclude) => `ALARM(${alarmToInclude})`)
+      .join(' OR ');
+
+    return alarmRule;
+  }
+
+  _resolveAlarmActions(definition) {
+    if (!definition.alarmsActions?.length){
+      return [];
+    }
+
+    const resourcesObj =
+      this.serverless.service.provider.compiledCloudFormationTemplate.Resources;
+    const resourcesCfNames = Object.keys(resourcesObj)
+
+    const topicsToInclude = []
+    for (const alarmAction of definition.alarmsActions) {
+      if (resourcesCfNames.indexOf(alarmAction) !== -1) {
+        const resource = resourcesObj[alarmAction]
+        if (resource.Type === 'AWS::SNS::Topic' && resource.Properties.enabled !== false) {
+          topicsToInclude.push({ Ref: alarmAction })
+        }
+      }
+    }
+    return topicsToInclude;
+  }
+
+  compileCompositeAlarms(config, definitions, alertTopics) {
+    Object.keys(definitions).forEach((definitionName) => {
+      const definition = definitions[definitionName];
+      if (definition.type === 'composite' && definition.enabled !== false) {
+        const alarmRule = this._resolveAlarmRules(definition);
+        // only create the composite alarm if there is at least one alarm to include
+        if (alarmRule !== '') {
+          const cf = {};
+          const { cfResource, cfName } = this._getCfResourceAndName(
+            'Composite',
+            definitionName
+          );
+          const alarmActions = this._resolveAlarmActions(definition);
+          const compositeAlarm = {
+            Type: 'AWS::CloudWatch::CompositeAlarm',
+            Properties: {
+              AlarmName: cfName,
+              AlarmDescription: definition.description,
+              ActionsEnabled: definition.actionsEnabled,
+              AlarmRule: this._resolveAlarmRules(definition),
+              AlarmActions: alarmActions,
+            },
+          };
+
+          cf[cfResource] = compositeAlarm;
+          this.addCfResources(cf);
+        }
+      }
+    });
+  }
+
   compile() {
     const config = this.getConfig();
     if (!config) {
@@ -587,6 +682,8 @@ class AlertsPlugin {
 
     this.compileAlarms(config, definitions, alertTopics);
 
+    this.compileCompositeAlarms(config, definitions, alertTopics);
+
     if (config.dashboards) {
       this.compileDashboards(config.dashboards);
     }

src/index.test.js

@@ -5,9 +5,9 @@ const Plugin = require('./index');
 
 const testServicePath = path.join(__dirname, '.tmp');
 
-const pluginFactory = (alarmsConfig, s) => {
+const pluginFactory = (alarmsConfig, s, functionsToUse) => {
   const stage = s || 'dev';
-  const functions = {
+  const functions = functionsToUse || {
     foo: {
       name: 'foo',
     },
@@ -47,6 +47,7 @@ const pluginFactory = (alarmsConfig, s) => {
   };
   return new Plugin(serverless, {
     stage,
+    region: 'local-test',
   });
 };
 
@@ -1629,4 +1630,185 @@ describe('#index', () => {
       });
     });
   });
+
+  describe('#compileCompositeAlarms', () => {
+    const config = {
+      definitions: {
+        successRateDrop: {
+          type: 'successRate',
+          nameTemplate: '$[functionName]-successRateDrop',
+          period: 300, //5min
+          evaluationPeriods: 3,
+          datapointsToAlarm: 3,
+          threshold: 99,
+          comparisonOperator: 'LessThanThreshold',
+          treatMissingData: 'breaching',
+        },
+        compositeSuccessAlarm: {
+          type: 'composite',
+          description: 'A compile success alarm',
+          actionsEnabled: true,
+          alarmsToInclude: [
+            'FooSuccessRateDropAlarm'
+          ],
+          alarmsActions: [
+            'AwsAlertsPagingTopic'
+          ]
+        },
+      },
+      alarms: [
+        'successRateDrop'
+      ],
+      topics: {
+        paging: {
+          topic: 'api-paging-alarm-topic-test',
+          notifications:[
+            {
+              protocol: 'email',
+              endpoint: 'test@email.com',
+            }
+          ]
+        }
+      },
+    };
+
+    const functions = {
+      foo: {
+        name: 'foo',
+      },
+      foo1: {
+        name: 'foo1',
+      },
+    }
+
+    it('should compile only foo function alarms into composite', () => {
+      const plugin = pluginFactory(config, 'dev', functions);
+
+      plugin.compile();
+
+      const resources = plugin.serverless.service.provider.compiledCloudFormationTemplate.Resources
+      expect(Object.keys(resources)).toHaveLength(4)
+      expect(
+        plugin.serverless.service.provider.compiledCloudFormationTemplate
+          .Resources
+      ).toMatchObject({
+        FooSuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        Foo1SuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        AwsAlertsPagingTopic: {
+          Type: 'AWS::SNS::Topic',
+        },
+        AlertsCompositeCompositeSuccessAlarm: {
+          Type: 'AWS::CloudWatch::CompositeAlarm',
+          Properties: expect.objectContaining({
+            AlarmRule: 'ALARM(fooservice-dev-foo-successRateDrop)',
+            AlarmActions: [{ Ref: 'AwsAlertsPagingTopic' }],
+          }),
+        },
+      });
+    });
+
+    it('should compile all function alarms into composite', () => {
+      const innerConfig = {
+        ...config,
+        definitions: {
+          ...config.definitions,
+          compositeSuccessAlarm: {
+            ...config.definitions.compositeSuccessAlarm,
+            alarmsToInclude: undefined,
+          }
+        }
+      }
+      const plugin = pluginFactory(innerConfig, 'dev', functions);
+
+      plugin.compile();
+
+      const resources = plugin.serverless.service.provider.compiledCloudFormationTemplate.Resources
+      expect(Object.keys(resources)).toHaveLength(4)
+      expect(
+        plugin.serverless.service.provider.compiledCloudFormationTemplate
+          .Resources
+      ).toMatchObject({
+        FooSuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        Foo1SuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        AwsAlertsPagingTopic: {
+          Type: 'AWS::SNS::Topic',
+        },
+        AlertsCompositeCompositeSuccessAlarm: {
+          Type: 'AWS::CloudWatch::CompositeAlarm',
+          Properties: expect.objectContaining({
+            AlarmRule: 'ALARM(fooservice-dev-foo-successRateDrop) OR ALARM(fooservice-dev-foo1-successRateDrop)',
+            AlarmActions: [{ Ref: 'AwsAlertsPagingTopic' }],
+          }),
+        },
+      });
+    });
+
+    it('should skip composite alarms that are marked disabled', () => {
+      const innerConfig = {
+        ...config,
+        definitions: {
+          ...config.definitions,
+          compositeSuccessAlarm: {
+            ...config.definitions.compositeSuccessAlarm,
+            enabled: false,
+          }
+        }
+      }
+      const plugin = pluginFactory(innerConfig, 'dev', functions);
+
+      plugin.compile();
+
+      const resources = plugin.serverless.service.provider.compiledCloudFormationTemplate.Resources
+      expect(Object.keys(resources)).toHaveLength(3)
+      expect(
+        plugin.serverless.service.provider.compiledCloudFormationTemplate
+          .Resources
+      ).toMatchObject({
+        FooSuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        Foo1SuccessRateDropAlarm: {
+          Type: 'AWS::CloudWatch::Alarm',
+        },
+        AwsAlertsPagingTopic: {
+          Type: 'AWS::SNS::Topic',
+        },
+      });
+    });
+
+    it('should skip composite alarms if all alarms are disabled', () => {
+      const innerConfig = {
+        ...config,
+        definitions: {
+          ...config.definitions,
+          successRateDrop: {
+            ...config.definitions.successRateDrop,
+            enabled: false,
+          }
+        }
+      }
+      const plugin = pluginFactory(innerConfig, 'dev', functions);
+
+      plugin.compile();
+
+      const resources = plugin.serverless.service.provider.compiledCloudFormationTemplate.Resources
+      expect(Object.keys(resources)).toHaveLength(1)
+      expect(
+        plugin.serverless.service.provider.compiledCloudFormationTemplate
+          .Resources
+      ).toMatchObject({
+        AwsAlertsPagingTopic: {
+          Type: 'AWS::SNS::Topic',
+        },
+      });
+    });
+  });
 });