Add support for ALB alarms and dashboard

.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
         run: npm i -g npm@^7
       - run: npm ci
       - run: npm run audit
-      - run: npm test
+      - run: cd serverless-plugin && npm test
       - name: Coveralls Parallel
         uses: coverallsapp/github-action@master
         with:

README.md

@@ -18,7 +18,8 @@ SLIC Watch provides a CloudWatch Dashboard and Alarms for:
  7. ECS (Fargate or EC2)
  8. SNS
  9. EventBridge
-
+ 10. Application Load Balancer
+
 Currently, SLIC Watch is available as a Serverless Framework plugin. Serverless Framework v2 and v3 are supported.
 
 ## Getting Started
@@ -171,6 +172,20 @@ EventBridge Rule dashboard widgets show:
 |--|--|
 |![FailedInvocations](https://raw.githubusercontent.com/fourtheorem/slic-watch/main/docs/eventBridgeFailedInvocations.png)|![Invocations](https://raw.githubusercontent.com/fourtheorem/slic-watch/main/docs/eventBridgeInvocations.png)|
 
+### Application Load Balancer
+
+Application Load Balancer alarms are created for:
+1. HTTP Code  ELB 5XX Count
+2. Rejected Connection Count
+3. HTTP Code Target 5XX Count
+4. UnHealthy Host Count
+5. Lambda Internal Error
+6. Lambda User Error
+
+Application Load Balancer dashboard widgets show:
+|--|--||--|--||--|--|
+|![HTTPCode_ELB_5XX_Count]() |![RejectedConnectionCount]() |![HTTPCode_Target_5XX_Count]() |![UnHealthyHostCount]() |![LambdaInternalError]() |![LambdaUserError]()|
+
 ## Configuration
 
 Configuration is entirely optional - SLIC Watch provides defaults that work out of the box.

lerna.json

@@ -1,7 +1,8 @@
 {
   "packages": [
     "serverless-plugin",
-    "serverless-test-project"
+    "serverless-test-project",
+    "serverless-test-project-alb"
   ],
   "version": "1.3.0"
 }

serverless-plugin/alarms-alb.js

@@ -0,0 +1,309 @@
+'use strict'
+
+const { makeResourceName, getStatisticName } = require('./util')
+/**
+   * Given CloudFormation syntax for an Target Group, derive CloudFormation syntax for
+   * the LoadBalancer LogicalId name
+   *
+   * @param  loadBalancerResources  syntax for an Load Balancer Application
+   * @returns CloudFormation syntax for the Load Balancer Resources
+   */
+function resolveLoadBalancerLogicalIdName (loadBalancerResources) {
+  for (const key in loadBalancerResources) {
+    if (loadBalancerResources[key].Type === 'AWS::ElasticLoadBalancingV2::LoadBalancer') {
+      return key
+    }
+  }
+}
+
+/**
+ * @param {object} albAlarmConfig The fully resolved alarm configuration
+ */
+module.exports = function ALBlarms (albAlarmConfig, context) {
+  return {
+    createALBAlarms
+  }
+
+  /**
+   * Add all required Application Load Balancer alarms to the provided CloudFormation template
+   * based on the resources found within
+   *
+   * @param {CloudFormationTemplate} cfTemplate A CloudFormation template object
+   */
+  function createALBAlarms (cfTemplate) {
+    const loadBalancerResources = cfTemplate.getResourcesByType(
+      'AWS::ElasticLoadBalancingV2::LoadBalancer'
+    )
+
+    for (const [loadBalancerResourceName, loadBalancerResource] of Object.entries(loadBalancerResources)) {
+      if (albAlarmConfig.HTTPCode_ELB_5XX_Count && albAlarmConfig.HTTPCode_ELB_5XX_Count.enabled) {
+        const httpCodeELB5XXCount = createHTTPCodeELB5XXCountAlarm(
+          loadBalancerResourceName,
+          loadBalancerResource,
+          albAlarmConfig.HTTPCode_ELB_5XX_Count
+        )
+        cfTemplate.addResource(httpCodeELB5XXCount.resourceName, httpCodeELB5XXCount.resource)
+      }
+
+      if (albAlarmConfig.RejectedConnectionCount && albAlarmConfig.RejectedConnectionCount.enabled) {
+        const rejectedConnectionCount = createRejectedConnectionCountAlarm(
+          loadBalancerResourceName,
+          loadBalancerResource,
+          albAlarmConfig.RejectedConnectionCount
+        )
+        cfTemplate.addResource(rejectedConnectionCount.resourceName, rejectedConnectionCount.resource)
+      }
+    }
+
+    const targetGroupResources = cfTemplate.getResourcesByType(
+      'AWS::ElasticLoadBalancingV2::TargetGroup'
+    )
+    for (const [targetGroupResourceName, targetGroupResource] of Object.entries(targetGroupResources)) {
+      const loadBalancerName = resolveLoadBalancerLogicalIdName(loadBalancerResources)
+
+      if (albAlarmConfig.HTTPCode_Target_5XX_Count && albAlarmConfig.HTTPCode_Target_5XX_Count.enabled) {
+        const httpCodeTarget5XXCount = createHTTPCodeTarget5XXCountAlarm(
+          targetGroupResourceName,
+          targetGroupResource,
+          loadBalancerName,
+          albAlarmConfig.HTTPCode_Target_5XX_Count
+        )
+        cfTemplate.addResource(httpCodeTarget5XXCount.resourceName, httpCodeTarget5XXCount.resource)
+      }
+      if (albAlarmConfig.UnHealthyHostCount && albAlarmConfig.UnHealthyHostCount.enabled) {
+        const unHealthyHostCount = createUnHealthyHostCountAlarm(
+          targetGroupResourceName,
+          targetGroupResource,
+          loadBalancerName,
+          albAlarmConfig.UnHealthyHostCount
+        )
+        cfTemplate.addResource(unHealthyHostCount.resourceName, unHealthyHostCount.resource)
+      }
+      if (albAlarmConfig.LambdaInternalError && albAlarmConfig.LambdaInternalError.enabled) {
+        const lambdaInternalError = createLambdaInternalErrorAlarm(
+          targetGroupResourceName,
+          targetGroupResource,
+          loadBalancerName,
+          albAlarmConfig.LambdaInternalError
+        )
+        cfTemplate.addResource(lambdaInternalError.resourceName, lambdaInternalError.resource)
+      }
+      if (albAlarmConfig.LambdaUserError && albAlarmConfig.LambdaUserError.enabled) {
+        const lambdaUserError = createLambdaUserErrorAlarm(
+          targetGroupResourceName,
+          targetGroupResource,
+          loadBalancerName,
+          albAlarmConfig.LambdaUserError
+        )
+        cfTemplate.addResource(lambdaUserError.resourceName, lambdaUserError.resource)
+      }
+    }
+  }
+
+  function createLoadBalancerAlarm (
+    alarmName,
+    alarmDescription,
+    loadBalancerResourceName, // Logical ID of the CloudFormation Load Balancer Resource
+    comparisonOperator,
+    threshold,
+    metricName,
+    statistic,
+    period,
+    extendedStatistic,
+    evaluationPeriods,
+    treatMissingData
+  ) {
+    const loadBalancerFullName = { 'Fn::GetAtt': [loadBalancerResourceName, 'LoadBalancerFullName'] }
+    console.log(loadBalancerFullName)
+    const metricProperties = {
+      Dimensions: [{ Name: 'LoadBalancer', Value: loadBalancerFullName }],
+      MetricName: metricName,
+      Namespace: 'AWS/ApplicationELB',
+      Period: period,
+      Statistic: statistic,
+      ExtendedStatistic: extendedStatistic
+    }
+
+    return {
+      Type: 'AWS::CloudWatch::Alarm',
+      Properties: {
+        ActionsEnabled: true,
+        AlarmActions: context.alarmActions,
+        AlarmName: alarmName,
+        AlarmDescription: alarmDescription,
+        EvaluationPeriods: evaluationPeriods,
+        ComparisonOperator: comparisonOperator,
+        Threshold: threshold,
+        TreatMissingData: treatMissingData,
+        ...metricProperties
+      }
+    }
+  }
+
+  function createLoadBalancerTargetAlarm (
+    alarmName,
+    alarmDescription,
+    targetGroupResourceName, // Logical ID of the CloudFormation Target Group Resource
+    loadBalancerName,
+    comparisonOperator,
+    threshold,
+    metricName,
+    statistic,
+    period,
+    extendedStatistic,
+    evaluationPeriods,
+    treatMissingData
+  ) {
+    const targetGroupFullName = { 'Fn::GetAtt': [targetGroupResourceName, 'TargetGroupFullName'] }
+    console.log(targetGroupFullName)
+    const loadBalancerFullName = { 'Fn::GetAtt': [loadBalancerName, 'LoadBalancerFullName'] }
+    const metricProperties = {
+      Dimensions: [{ Name: 'TargetGroup', Value: targetGroupFullName }, { Name: 'LoadBalancer', Value: loadBalancerFullName }],
+      MetricName: metricName,
+      Namespace: 'AWS/ApplicationELB',
+      Period: period,
+      Statistic: statistic,
+      ExtendedStatistic: extendedStatistic
+    }
+
+    return {
+      Type: 'AWS::CloudWatch::Alarm',
+      Properties: {
+        ActionsEnabled: true,
+        AlarmActions: context.alarmActions,
+        AlarmName: alarmName,
+        AlarmDescription: alarmDescription,
+        EvaluationPeriods: evaluationPeriods,
+        ComparisonOperator: comparisonOperator,
+        Threshold: threshold,
+        TreatMissingData: treatMissingData,
+        ...metricProperties
+      }
+    }
+  }
+
+  function createHTTPCodeELB5XXCountAlarm (loadBalancerResourceName, loadBalancerResource, config) {
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', loadBalancerResourceName, 'HTTPCodeELB5XXCount'),
+      resource: createLoadBalancerAlarm(
+        `LoadBalancerHTTPCodeELB5XXCountAlarm_${loadBalancerResourceName}`,
+        `LoadBalancer HTTP Code ELB 5XX Count ${getStatisticName(config)} for ${loadBalancerResourceName} breaches ${threshold}`,
+        loadBalancerResourceName,
+        config.ComparisonOperator,
+        threshold,
+        'HTTPCode_ELB_5XX_Count', // metricName
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+
+  function createRejectedConnectionCountAlarm (loadBalancerResourceName, loadBalancerResource, config) {
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', loadBalancerResourceName, 'RejectedConnectionCount'),
+      resource: createLoadBalancerAlarm(
+        `LoadBalancerRejectedConnectionCountAlarm_${loadBalancerResourceName}`,
+        `LoadBalancer Rejected Connection Count ${getStatisticName(config)} for ${loadBalancerResourceName} breaches ${threshold}`,
+        loadBalancerResourceName,
+        config.ComparisonOperator,
+        threshold,
+        'RejectedConnectionCount', // metricName
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+
+  function createHTTPCodeTarget5XXCountAlarm (targetGroupResourceName, targetGroupResource, loadBalancerName, config) {
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', targetGroupResourceName, 'HTTPCodeTarget5XXCount'),
+      resource: createLoadBalancerTargetAlarm(
+        `LoadBalancerHTTPCodeTarget5XXCountAlarm_${targetGroupResourceName}`,
+        `LoadBalancer HTTP Code Target 5XX Count ${getStatisticName(config)} for ${targetGroupResourceName} breaches ${threshold}`,
+        targetGroupResourceName,
+        loadBalancerName,
+        config.ComparisonOperator,
+        threshold,
+        'HTTPCode_Target_5XX_Count',
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+
+  function createUnHealthyHostCountAlarm (targetGroupResourceName, targetGroupResource, loadBalancerName, config) {
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', targetGroupResourceName, 'UnHealthyHostCount'),
+      resource: createLoadBalancerTargetAlarm(
+        `LoadBalancerUnHealthyHostCountAlarm_${targetGroupResourceName}`,
+        `LoadBalancer UnHealthy Host Count ${getStatisticName(config)} for ${targetGroupResourceName} breaches ${threshold}`,
+        targetGroupResourceName,
+        loadBalancerName,
+        config.ComparisonOperator,
+        threshold,
+        'UnHealthyHostCount',
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+
+  function createLambdaInternalErrorAlarm (targetGroupResourceName, targetGroupResource, loadBalancerName, config) {
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', targetGroupResourceName, 'LambdaInternalError'),
+      resource: createLoadBalancerTargetAlarm(
+        `LoadBalancerLambdaInternalErrorAlarm_${targetGroupResourceName}`,
+        `LoadBalancer Lambda Internal Error ${getStatisticName(config)} for ${targetGroupResourceName} breaches ${threshold}`,
+        targetGroupResourceName,
+        loadBalancerName,
+        config.ComparisonOperator,
+        threshold,
+        'LambdaInternalError',
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+
+  function createLambdaUserErrorAlarm (targetGroupResourceName, targetGroupResource, loadBalancerName, config) {
+    console.log(loadBalancerName)
+    const threshold = config.Threshold
+    return {
+      resourceName: makeResourceName('LoadBalancer', targetGroupResourceName, 'LambdaUserError'),
+      resource: createLoadBalancerTargetAlarm(
+        `LoadBalancerLambdaUserErrorAlarm_${targetGroupResourceName}`,
+        `LoadBalancer Lambda User Error ${getStatisticName(config)} for ${targetGroupResourceName} breaches ${threshold}`,
+        targetGroupResourceName,
+        loadBalancerName,
+        config.ComparisonOperator,
+        threshold,
+        'LambdaUserError',
+        config.Statistic,
+        config.Period,
+        config.ExtendedStatistic,
+        config.EvaluationPeriods,
+        config.TreatMissingData
+      )
+    }
+  }
+}

serverless-plugin/alarms.js

@@ -12,6 +12,7 @@ const sqsAlarms = require('./alarms-sqs')
 const ecsAlarms = require('./alarms-ecs')
 const snsAlarms = require('./alarms-sns')
 const ruleAlarms = require('./alarms-eventbridge')
+const albAlarms = require('./alarms-alb')
 
 module.exports = function alarms (serverless, alarmConfig, functionAlarmConfigs, context) {
   const {
@@ -23,7 +24,8 @@ module.exports = function alarms (serverless, alarmConfig, functionAlarmConfigs,
     Lambda: lambdaConfig,
     ECS: ecsConfig,
     SNS: snsConfig,
-    Events: ruleConfig
+    Events: ruleConfig,
+    ApplicationELB: albConfig
   } = cascade(alarmConfig)
 
   const cascadedFunctionAlarmConfigs = applyAlarmConfig(lambdaConfig, functionAlarmConfigs)
@@ -37,6 +39,7 @@ module.exports = function alarms (serverless, alarmConfig, functionAlarmConfigs,
   const { createSNSAlarms } = snsAlarms(snsConfig, context, serverless)
   const { createRuleAlarms } = ruleAlarms(ruleConfig, context, serverless)
 
+  const { createALBAlarms } = albAlarms(albConfig, context, serverless)
   return {
     addAlarms
   }
@@ -58,6 +61,7 @@ module.exports = function alarms (serverless, alarmConfig, functionAlarmConfigs,
       ecsConfig.enabled && createECSAlarms(cfTemplate)
       snsConfig.enabled && createSNSAlarms(cfTemplate)
       ruleConfig.enabled && createRuleAlarms(cfTemplate)
+      albConfig.enabled && createALBAlarms(cfTemplate)
     }
   }
 }