@cdklabs/multi-az-observability 0.0.0-alpha.0

package/lib/services/BasicServiceMultiAZObservability.js

@@ -0,0 +1,504 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicServiceMultiAZObservability = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const constructs_1 = require("constructs");
+const AvailabilityAndLatencyAlarmsAndRules_1 = require("../alarmsandrules/AvailabilityAndLatencyAlarmsAndRules");
+const AvailabilityZoneMapper_1 = require("../azmapper/AvailabilityZoneMapper");
+const BasicServiceDashboard_1 = require("../dashboards/BasicServiceDashboard");
+const AvailabilityAndLatencyMetrics_1 = require("../metrics/AvailabilityAndLatencyMetrics");
+const OutlierDetectionFunction_1 = require("../outlier-detection/OutlierDetectionFunction");
+const OutlierDetectionAlgorithm_1 = require("../utilities/OutlierDetectionAlgorithm");
+const StackWithDynamicSource_1 = require("../utilities/StackWithDynamicSource");
+/**
+ * Basic observability for a service using metrics from
+ * ALBs and NAT Gateways
+ */
+class BasicServiceMultiAZObservability extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Initialize class properties
+        this.serviceName = props.serviceName;
+        this.applicationLoadBalancers = props.applicationLoadBalancers;
+        this.natGateways = props.natGateways;
+        this._natGWZonalIsolatedImpactAlarms = {};
+        this._albZonalIsolatedImpactAlarms = {};
+        this.aggregateZonalIsolatedImpactAlarms = {};
+        this._packetDropsPerZone = {};
+        this._faultsPerZone = {};
+        let outlierThreshold;
+        if (!props.outlierThreshold) {
+            switch (props.outlierDetectionAlgorithm) {
+                case OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.CHI_SQUARED:
+                    outlierThreshold = 0.05;
+                    break;
+                case OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.IQR:
+                    outlierThreshold = 1.5;
+                    break;
+                case OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.MAD:
+                    outlierThreshold = 3;
+                    break;
+                case OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.STATIC:
+                    outlierThreshold = 0.7;
+                    break;
+                case OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.Z_SCORE:
+                    outlierThreshold = 2;
+                    break;
+            }
+        }
+        else {
+            outlierThreshold = props.outlierThreshold;
+        }
+        // Create the AZ mapper resource to translate AZ names to ids
+        this.azMapper = new AvailabilityZoneMapper_1.AvailabilityZoneMapper(this, 'AvailabilityZoneMapper');
+        if (props.outlierDetectionAlgorithm != OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.STATIC) {
+            let outlierDetectionStack = new StackWithDynamicSource_1.StackWithDynamicSource(this, 'OutlierDetectionStack', {
+                assetsBucketsParameterName: props.assetsBucketParameterName,
+                assetsBucketPrefixParameterName: props.assetsBucketPrefixParameterName,
+            });
+            this.outlierDetectionFunction = new OutlierDetectionFunction_1.OutlierDetectionFunction(outlierDetectionStack, 'OutlierDetectionFunction', {}).function;
+        }
+        // Create metrics and alarms for just load balancers if they were provided
+        if (this.applicationLoadBalancers !== undefined &&
+            this.applicationLoadBalancers != null) {
+            this.doAlbMetrics(props, outlierThreshold);
+        }
+        // Create NAT Gateway metrics and alarms
+        if (this.natGateways !== undefined && this.natGateways != null) {
+            this.doNatGatewayMetrics(props, outlierThreshold);
+        }
+        let counter = 1;
+        // Go through the ALB zonal isolated impact alarms and see if there is a NAT GW
+        // isolated impact alarm for the same AZ ID, if so, create a composite alarm with both
+        // otherwise create a composite alarm with just the ALB
+        Object.keys(this._albZonalIsolatedImpactAlarms).forEach((az) => {
+            let tmp = [];
+            tmp.push(this._albZonalIsolatedImpactAlarms[az]);
+            if (this._natGWZonalIsolatedImpactAlarms[az] !== undefined &&
+                this._natGWZonalIsolatedImpactAlarms[az] != null) {
+                tmp.push(this._natGWZonalIsolatedImpactAlarms[az]);
+            }
+            let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(az.substring(az.length - 1));
+            this.aggregateZonalIsolatedImpactAlarms[az] = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + counter++ + 'AggregateIsolatedImpactAlarm', {
+                compositeAlarmName: availabilityZoneId + '-aggregate-isolated-impact',
+                alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(...tmp),
+                actionsEnabled: false,
+            });
+        });
+        // In case there were AZs with only a NAT GW and no ALB, create a composite alarm
+        // for the NAT GW metrics
+        Object.keys(this._natGWZonalIsolatedImpactAlarms).forEach((az) => {
+            // If we don't yet have an isolated impact alarm for this AZ, proceed
+            if (this.aggregateZonalIsolatedImpactAlarms[az] === undefined ||
+                this.aggregateZonalIsolatedImpactAlarms[az] == null) {
+                let tmp = [];
+                tmp.push(this._natGWZonalIsolatedImpactAlarms[az]);
+                if (this._albZonalIsolatedImpactAlarms[az] !== undefined &&
+                    this.albZonalIsolatedImpactAlarms != null) {
+                    tmp.push(this.albZonalIsolatedImpactAlarms[az]);
+                }
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(az.substring(az.length - 1));
+                this.aggregateZonalIsolatedImpactAlarms[az] = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + counter++ + 'AggregateIsolatedImpactAlarm', {
+                    compositeAlarmName: availabilityZoneId + '-aggregate-isolated-impact',
+                    alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(...tmp),
+                    actionsEnabled: false,
+                });
+            }
+        });
+        this.albZonalIsolatedImpactAlarms = this._albZonalIsolatedImpactAlarms;
+        this.natGWZonalIsolatedImpactAlarms = this._natGWZonalIsolatedImpactAlarms;
+        // Should we create the dashboard
+        if (props.createDashboard == true) {
+            this.dashboard = new BasicServiceDashboard_1.BasicServiceDashboard(this, 'BasicServiceDashboard', {
+                serviceName: props.serviceName.toLowerCase(),
+                zonalAggregateIsolatedImpactAlarms: this.aggregateZonalIsolatedImpactAlarms,
+                zonalLoadBalancerIsolatedImpactAlarms: this.albZonalIsolatedImpactAlarms,
+                zonalNatGatewayIsolatedImpactAlarms: this.natGWZonalIsolatedImpactAlarms,
+                interval: props.interval,
+                zonalLoadBalancerFaultRateMetrics: this._faultsPerZone,
+                zonalNatGatewayPacketDropMetrics: this._packetDropsPerZone,
+                azMapper: this.azMapper,
+            }).dashboard;
+        }
+    }
+    doAlbMetrics(props, outlierThreshold) {
+        // Collect total fault count metrics per AZ
+        let albZoneFaultCountMetrics = {};
+        // Create fault rate alarms per AZ indicating at least 1 ALB
+        // in the AZ saw a fault rate that exceeded the threshold
+        let faultRatePercentageAlarms = {};
+        let keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar('');
+        // Iterate each ALB
+        this.applicationLoadBalancers.forEach((alb) => {
+            // Iterate each AZ in the VPC
+            alb.vpc?.availabilityZones.forEach((az, index) => {
+                let azLetter = az.substring(az.length - 1);
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+                faultRatePercentageAlarms[azLetter] = [];
+                // 5xx responses from targets
+                let target5xx = alb.metrics.httpCodeTarget(aws_elasticloadbalancingv2_1.HttpCodeTarget.TARGET_5XX_COUNT, {
+                    dimensionsMap: {
+                        AvailabilityZone: az,
+                        LoadBalancer: alb
+                            .loadBalancerFullName,
+                    },
+                    label: availabilityZoneId,
+                    period: props.period,
+                });
+                // 5xx responses from ELB
+                let elb5xx = alb.metrics.httpCodeElb(aws_elasticloadbalancingv2_1.HttpCodeElb.ELB_5XX_COUNT, {
+                    dimensionsMap: {
+                        AvailabilityZone: az,
+                        LoadBalancer: alb
+                            .loadBalancerFullName,
+                    },
+                    label: availabilityZoneId,
+                    period: props.period,
+                });
+                // 2xx responses from targets
+                let target2xx = alb.metrics.httpCodeTarget(aws_elasticloadbalancingv2_1.HttpCodeTarget.TARGET_2XX_COUNT, {
+                    dimensionsMap: {
+                        AvailabilityZone: az,
+                        LoadBalancer: alb
+                            .loadBalancerFullName,
+                    },
+                    label: availabilityZoneId,
+                    period: props.period,
+                });
+                // 3xx responses from targets
+                let target3xx = alb.metrics.httpCodeTarget(aws_elasticloadbalancingv2_1.HttpCodeTarget.TARGET_3XX_COUNT, {
+                    dimensionsMap: {
+                        AvailabilityZone: az,
+                        LoadBalancer: alb
+                            .loadBalancerFullName,
+                    },
+                    label: availabilityZoneId,
+                    period: props.period,
+                });
+                // 3xx responess from ELB
+                let elb3xx = alb.metrics.httpCodeElb(aws_elasticloadbalancingv2_1.HttpCodeElb.ELB_3XX_COUNT, {
+                    dimensionsMap: {
+                        AvailabilityZone: az,
+                        LoadBalancer: alb
+                            .loadBalancerFullName,
+                    },
+                    label: availabilityZoneId,
+                    period: props.period,
+                });
+                // Create metrics for total fault count from this ALB
+                let usingMetrics = {};
+                usingMetrics[`${keyPrefix}1`] = target5xx;
+                usingMetrics[`${keyPrefix}2`] = elb5xx;
+                if (albZoneFaultCountMetrics[azLetter] === undefined ||
+                    albZoneFaultCountMetrics[azLetter] == null) {
+                    albZoneFaultCountMetrics[azLetter] = [];
+                }
+                albZoneFaultCountMetrics[azLetter].push(new aws_cloudwatch_1.MathExpression({
+                    expression: `(${keyPrefix}1 + ${keyPrefix}2)`,
+                    usingMetrics: usingMetrics,
+                    label: availabilityZoneId + ' ' + alb.loadBalancerArn + ' fault count',
+                    period: props.period,
+                }));
+                // Create metrics to calculate fault rate for this ALB
+                usingMetrics = {};
+                usingMetrics[`${keyPrefix}1`] = target2xx;
+                usingMetrics[`${keyPrefix}2`] = target3xx;
+                usingMetrics[`${keyPrefix}3`] = elb3xx;
+                usingMetrics[`${keyPrefix}4`] = target5xx;
+                usingMetrics[`${keyPrefix}5`] = elb5xx;
+                // The ALB fault rate
+                let faultRate = new aws_cloudwatch_1.MathExpression({
+                    expression: `((${keyPrefix}4+${keyPrefix}5)/(${keyPrefix}1+${keyPrefix}2+${keyPrefix}3+${keyPrefix}4+${keyPrefix}5)) * 100`,
+                    usingMetrics: usingMetrics,
+                    label: availabilityZoneId + ' ' + alb.loadBalancerArn + ' fault rate',
+                    period: props.period,
+                });
+                let threshold = props.faultCountPercentageThreshold ?? 5;
+                // Create a fault rate alarm for the ALB
+                let faultRateAlarm = new aws_cloudwatch_1.Alarm(this, 'AZ' + index + keyPrefix + 'FaultRatePercentageAlarm', {
+                    alarmName: availabilityZoneId + '-' + alb.loadBalancerArn + '-fault-rate',
+                    actionsEnabled: false,
+                    metric: faultRate,
+                    evaluationPeriods: props.evaluationPeriods,
+                    datapointsToAlarm: props.datapointsToAlarm,
+                    threshold: threshold,
+                    comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+                });
+                // Add this ALB's fault rate alarm
+                faultRatePercentageAlarms[azLetter].push(faultRateAlarm);
+                // Get next unique key
+                keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+            });
+        });
+        // Iterate AZs for the ALB fault count metrics
+        Object.keys(albZoneFaultCountMetrics).forEach((azLetter) => {
+            let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+            keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+            let counter = 1;
+            let usingMetrics = {};
+            // Add each ALB's fault count metrics to the dictionary
+            albZoneFaultCountMetrics[azLetter].forEach((metric) => {
+                usingMetrics[`${keyPrefix}${counter++}`] = metric;
+            });
+            // Sum the total faults for the availability zone across all ALBs
+            let totalFaultsPerZone = new aws_cloudwatch_1.MathExpression({
+                expression: Object.keys(usingMetrics).join('+'),
+                usingMetrics: usingMetrics,
+                label: availabilityZoneId + ' fault count',
+                period: props.period,
+            });
+            keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+            counter = 1;
+            // Assign the total faults per zone to the dictionary
+            this._faultsPerZone[azLetter] = totalFaultsPerZone;
+        });
+        keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+        let tmp = {};
+        Object.keys(this._faultsPerZone).forEach((azLetter, index) => {
+            tmp[`${keyPrefix}${index}`] = this._faultsPerZone[azLetter];
+        });
+        // Calculate the total faults in the region by adding all AZs together
+        let totalFaults = new aws_cloudwatch_1.MathExpression({
+            expression: Object.keys(tmp).join('+'),
+            usingMetrics: tmp,
+            label: aws_cdk_lib_1.Fn.sub('${AWS::Region} fault count'),
+            period: props.period,
+        });
+        if (props.outlierDetectionAlgorithm == OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.STATIC) {
+            // Finally, iterate back through each AZ
+            Object.keys(this._faultsPerZone).forEach((azLetter, index) => {
+                keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+                // Determine if AZ is an outlier for faults by exceeding
+                // a static threshold
+                let outlierMetrics;
+                // These metrics will give the percent of faults for the AZ
+                let usingMetrics = {};
+                usingMetrics[`${keyPrefix}1`] = this._faultsPerZone[azLetter];
+                usingMetrics[`${keyPrefix}2`] = totalFaults;
+                outlierMetrics = new aws_cloudwatch_1.MathExpression({
+                    expression: `${keyPrefix}1 / ${keyPrefix}2`,
+                    usingMetrics: usingMetrics,
+                });
+                let azIsOutlierForFaults = new aws_cloudwatch_1.Alarm(this, 'AZ' + index + 'FaultCountOutlierAlarm', {
+                    alarmName: availabilityZoneId + '-fault-count-outlier',
+                    metric: outlierMetrics,
+                    threshold: outlierThreshold,
+                    evaluationPeriods: props.evaluationPeriods,
+                    datapointsToAlarm: props.datapointsToAlarm,
+                    actionsEnabled: false,
+                    treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+                    comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                });
+                // Create isolated AZ impact alarms by determining
+                // if the AZ is an outlier for fault count and at least
+                // one ALB exceeds the fault rate threshold provided
+                this._albZonalIsolatedImpactAlarms[azLetter] = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + index + 'IsolatedFaultCountImpact', {
+                    compositeAlarmName: availabilityZoneId + '-isolated-fault-count-impact',
+                    alarmRule: aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForFaults, aws_cloudwatch_1.AlarmRule.anyOf(...faultRatePercentageAlarms[azLetter])),
+                });
+            });
+        }
+        else {
+            let allAZs = Array.from(new Set(this.applicationLoadBalancers.flatMap((x) => {
+                return x.vpc.availabilityZones;
+            })));
+            allAZs.forEach((az, index) => {
+                let azLetter = az.substring(az.length - 1);
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+                let azIsOutlierForFaults = AvailabilityAndLatencyAlarmsAndRules_1.AvailabilityAndLatencyAlarmsAndRules.createZonalFaultRateOutlierAlarmForAlb(this, props.applicationLoadBalancers, availabilityZoneId, outlierThreshold, this.outlierDetectionFunction, props.outlierDetectionAlgorithm, this.azMapper, index, props.evaluationPeriods, props.datapointsToAlarm, '');
+                // In addition to being an outlier for fault count, make sure
+                // the fault count is substantial enough to trigger the alarm
+                // by making sure at least 1 ALB sees packet loss that exceeds the threshold
+                let azIsOutlierAndSeesImpact = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + index + 'ALBIsolatedImpact', {
+                    compositeAlarmName: availabilityZoneId + '-isolated-fault-count-impact',
+                    alarmRule: aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForFaults, aws_cloudwatch_1.AlarmRule.anyOf(...faultRatePercentageAlarms[azLetter])),
+                });
+                // Record these so they can be used in dashboard or for combination
+                // with AZ
+                this._albZonalIsolatedImpactAlarms[azLetter] = azIsOutlierAndSeesImpact;
+            });
+        }
+    }
+    doNatGatewayMetrics(props, outlierThreshold) {
+        let keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar('');
+        // Collect alarms for packet drops exceeding a threshold per NAT GW
+        let packetDropPercentageAlarms = {};
+        // For each AZ, create metrics for each NAT GW
+        Object.entries(this.natGateways).forEach((entry, index) => {
+            // The number of packet drops for each NAT GW in the AZ
+            let packetDropMetricsForAZ = {};
+            let az = entry[0];
+            let azLetter = az.substring(az.length - 1);
+            let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+            packetDropPercentageAlarms[azLetter] = [];
+            // Iterate through each NAT GW in the current AZ
+            entry[1].forEach((natgw) => {
+                // Calculate packet drops
+                let packetDropCount = new aws_cloudwatch_1.Metric({
+                    metricName: 'PacketsDropCount',
+                    namespace: 'AWS/NATGateway',
+                    statistic: 'Sum',
+                    unit: aws_cloudwatch_1.Unit.COUNT,
+                    label: availabilityZoneId + ' packet drops',
+                    dimensionsMap: {
+                        NatGatewayId: natgw.attrNatGatewayId,
+                    },
+                    period: props.period,
+                });
+                // Calculate packets in from source
+                let packetsInFromSourceCount = new aws_cloudwatch_1.Metric({
+                    metricName: 'PacketsInFromSource',
+                    namespace: 'AWS/NATGateway',
+                    statistic: 'Sum',
+                    unit: aws_cloudwatch_1.Unit.COUNT,
+                    label: availabilityZoneId + ' packets in from source',
+                    dimensionsMap: {
+                        NatGatewayId: natgw.attrNatGatewayId,
+                    },
+                    period: props.period,
+                });
+                // Calculate packets in from destination
+                let packetsInFromDestinationCount = new aws_cloudwatch_1.Metric({
+                    metricName: 'PacketsInFromDestination',
+                    namespace: 'AWS/NATGateway',
+                    statistic: 'Sum',
+                    unit: aws_cloudwatch_1.Unit.COUNT,
+                    label: availabilityZoneId + ' packets in from destination',
+                    dimensionsMap: {
+                        NatGatewayId: natgw.attrNatGatewayId,
+                    },
+                    period: props.period,
+                });
+                let usingMetrics = {};
+                usingMetrics[`${keyPrefix}1`] = packetDropCount;
+                usingMetrics[`${keyPrefix}2`] = packetsInFromSourceCount;
+                usingMetrics[`${keyPrefix}3`] = packetsInFromDestinationCount;
+                // Calculate a percentage of dropped packets for the NAT GW
+                let packetDropPercentage = new aws_cloudwatch_1.MathExpression({
+                    expression: `(${keyPrefix}1 / (${keyPrefix}2 + ${keyPrefix}3)) * 100`,
+                    usingMetrics: usingMetrics,
+                    label: availabilityZoneId + ' packet drop percentage',
+                    period: props.period,
+                });
+                let threshold = props.packetLossImpactPercentageThreshold ?? 0.01;
+                // Create an alarm for this NAT GW if packet drops exceed the specified threshold
+                let packetDropImpactAlarm = new aws_cloudwatch_1.Alarm(this, 'AZ' + (index + 1) + 'PacketDropImpactAlarm', {
+                    alarmName: availabilityZoneId +
+                        '-' +
+                        natgw.attrNatGatewayId +
+                        '-packet-drop-impact',
+                    actionsEnabled: false,
+                    metric: packetDropPercentage,
+                    threshold: threshold,
+                    comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+                    evaluationPeriods: props.evaluationPeriods,
+                    datapointsToAlarm: props.datapointsToAlarm,
+                });
+                // Collect all of the packet drop impact alarms for each
+                // NAT GW in this AZ, need to know at least 1 sees substantial
+                // enough impact to consider the AZ as impaired
+                packetDropPercentageAlarms[azLetter].push(packetDropImpactAlarm);
+                // Collect the packet drop metrics for this AZ so we can
+                // add them all together and count total packet drops
+                // for all NAT GWs in the AZ
+                packetDropMetricsForAZ[`m${index}`] = packetDropCount;
+            });
+            // Create a metric that adds up all packets drops from each
+            // NAT GW in the AZ
+            let packetDropsInThisAZ = new aws_cloudwatch_1.MathExpression({
+                expression: Object.keys(packetDropMetricsForAZ).join('+'),
+                usingMetrics: packetDropMetricsForAZ,
+                label: availabilityZoneId + ' dropped packets',
+                period: props.period,
+            });
+            // Record these so we can add them up
+            // and get a total amount of packet drops
+            // in the region across all AZs
+            this._packetDropsPerZone[azLetter] = packetDropsInThisAZ;
+        });
+        keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+        let tmp = {};
+        Object.keys(this._packetDropsPerZone).forEach((azLetter, index) => {
+            tmp[`${keyPrefix}${index}`] = this._packetDropsPerZone[azLetter];
+        });
+        // Calculate total packet drops for the region
+        let totalPacketDrops = new aws_cloudwatch_1.MathExpression({
+            expression: Object.keys(tmp).join('+'),
+            usingMetrics: tmp,
+            label: aws_cdk_lib_1.Fn.ref('AWS::Region') + ' dropped packets',
+            period: props.period,
+        });
+        if (props.outlierDetectionAlgorithm == OutlierDetectionAlgorithm_1.OutlierDetectionAlgorithm.STATIC) {
+            // Create outlier detection alarms by comparing packet
+            // drops in one AZ versus total packet drops in the region
+            Object.keys(this._packetDropsPerZone).forEach((azLetter, index) => {
+                let azIsOutlierForPacketDrops;
+                keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+                // Determine if AZ is an outlier for faults by exceeding
+                // a static threshold
+                let outlierMetrics;
+                // These metrics will give the percent of faults for the AZ
+                let usingMetrics = {};
+                usingMetrics[`${keyPrefix}1`] = this._packetDropsPerZone[azLetter];
+                usingMetrics[`${keyPrefix}2`] = totalPacketDrops;
+                outlierMetrics = new aws_cloudwatch_1.MathExpression({
+                    expression: `(${keyPrefix}1 / ${keyPrefix}2) * 100`,
+                    usingMetrics: usingMetrics,
+                    label: availabilityZoneId + ' percentage of dropped packets',
+                });
+                azIsOutlierForPacketDrops = new aws_cloudwatch_1.Alarm(this, 'AZ' + (index + 1) + 'NATGWDroppedPacketsOutlierAlarm', {
+                    metric: outlierMetrics,
+                    alarmName: availabilityZoneId + '-dropped-packets-outlier',
+                    evaluationPeriods: props.evaluationPeriods,
+                    datapointsToAlarm: props.datapointsToAlarm,
+                    threshold: outlierThreshold,
+                    actionsEnabled: false,
+                    treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+                    comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                });
+                // In addition to being an outlier for packet drops, make sure
+                // the packet loss is substantial enough to trigger the alarm
+                // by making sure at least 1 NAT GW sees packet loss more than 0.01%
+                let azIsOutlierAndSeesImpact = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + index + 'NATGWIsolatedImpact', {
+                    compositeAlarmName: availabilityZoneId + '-isolated-natgw-impact',
+                    alarmRule: aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForPacketDrops, aws_cloudwatch_1.AlarmRule.anyOf(...packetDropPercentageAlarms[azLetter])),
+                });
+                // Record these so they can be used in dashboard or for combination
+                // with AZ
+                this._natGWZonalIsolatedImpactAlarms[azLetter] =
+                    azIsOutlierAndSeesImpact;
+            });
+        }
+        else {
+            Object.keys(props.natGateways).forEach((az, index) => {
+                let azLetter = az.substring(az.length - 1);
+                let availabilityZoneId = this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);
+                // Iterate all NAT GWs in this AZ
+                let azIsOutlierForPacketDrops = AvailabilityAndLatencyAlarmsAndRules_1.AvailabilityAndLatencyAlarmsAndRules.createZonalFaultRateOutlierAlarmForNatGW(this, this.natGateways, availabilityZoneId, outlierThreshold, this.outlierDetectionFunction, props.outlierDetectionAlgorithm, this.azMapper, index, props.evaluationPeriods, props.datapointsToAlarm, '');
+                // In addition to being an outlier for packet drops, make sure
+                // the packet loss is substantial enough to trigger the alarm
+                // by making sure at least 1 NAT GW sees packet loss more than 0.01%
+                let azIsOutlierAndSeesImpact = new aws_cloudwatch_1.CompositeAlarm(this, 'AZ' + index + 'NATGWIsolatedImpact', {
+                    compositeAlarmName: availabilityZoneId + '-isolated-natgw-impact',
+                    alarmRule: aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForPacketDrops, aws_cloudwatch_1.AlarmRule.anyOf(...packetDropPercentageAlarms[azLetter])),
+                });
+                // Record these so they can be used in dashboard or for combination
+                // with AZ
+                this._natGWZonalIsolatedImpactAlarms[azLetter] =
+                    azIsOutlierAndSeesImpact;
+            });
+        }
+    }
+}
+exports.BasicServiceMultiAZObservability = BasicServiceMultiAZObservability;
+_a = JSII_RTTI_SYMBOL_1;
+BasicServiceMultiAZObservability[_a] = { fqn: "@cdklabs/multi-az-observability.BasicServiceMultiAZObservability", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BasicServiceMultiAZObservability.js","sourceRoot":"","sources":["../../src/services/BasicServiceMultiAZObservability.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\nimport { Fn } from 'aws-cdk-lib';\nimport {\n  Alarm,\n  AlarmRule,\n  ComparisonOperator,\n  CompositeAlarm,\n  Dashboard,\n  IAlarm,\n  IMetric,\n  MathExpression,\n  Metric,\n  TreatMissingData,\n  Unit,\n} from 'aws-cdk-lib/aws-cloudwatch';\nimport { CfnNatGateway } from 'aws-cdk-lib/aws-ec2';\nimport {\n  BaseLoadBalancer,\n  HttpCodeElb,\n  HttpCodeTarget,\n  IApplicationLoadBalancer,\n  ILoadBalancerV2,\n} from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport { IFunction } from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\nimport { IBasicServiceMultiAZObservability } from './IBasicServiceMultiAZObservability';\nimport { BasicServiceMultiAZObservabilityProps } from './props/BasicServiceMultiAZObservabilityProps';\nimport { AvailabilityAndLatencyAlarmsAndRules } from '../alarmsandrules/AvailabilityAndLatencyAlarmsAndRules';\nimport { AvailabilityZoneMapper } from '../azmapper/AvailabilityZoneMapper';\nimport { IAvailabilityZoneMapper } from '../azmapper/IAvailabilityZoneMapper';\nimport { BasicServiceDashboard } from '../dashboards/BasicServiceDashboard';\nimport { AvailabilityAndLatencyMetrics } from '../metrics/AvailabilityAndLatencyMetrics';\nimport { OutlierDetectionFunction } from '../outlier-detection/OutlierDetectionFunction';\nimport { OutlierDetectionAlgorithm } from '../utilities/OutlierDetectionAlgorithm';\nimport { StackWithDynamicSource } from '../utilities/StackWithDynamicSource';\n\n/**\n * Basic observability for a service using metrics from\n * ALBs and NAT Gateways\n */\nexport class BasicServiceMultiAZObservability\n  extends Construct\n  implements IBasicServiceMultiAZObservability {\n  /**\n   * The NAT Gateways being used in the service, each set of NAT Gateways\n   * are keyed by their Availability Zone Id\n   */\n  natGateways?: { [key: string]: CfnNatGateway[] };\n\n  /**\n   * The application load balancers being used by the service\n   */\n  applicationLoadBalancers?: IApplicationLoadBalancer[];\n\n  /**\n   * The name of the service\n   */\n  serviceName: string;\n\n  /**\n   * The alarms indicating if an AZ is an outlier for NAT GW\n   * packet loss and has isolated impact\n   */\n  natGWZonalIsolatedImpactAlarms?: { [key: string]: IAlarm };\n\n  /**\n   * The alarms indicating if an AZ is an outlier for ALB\n   * faults and has isolated impact\n   */\n  albZonalIsolatedImpactAlarms?: { [key: string]: IAlarm };\n\n  /**\n   * The alarms indicating if an AZ has isolated impact\n   * from either ALB or NAT GW metrics\n   */\n  aggregateZonalIsolatedImpactAlarms: { [key: string]: IAlarm };\n\n  /**\n   * The dashboard that is optionally created\n   */\n  dashboard?: Dashboard;\n\n  /**\n   * The chi-squared function\n   */\n  private outlierDetectionFunction?: IFunction;\n\n  private azMapper: IAvailabilityZoneMapper;\n\n  private _natGWZonalIsolatedImpactAlarms: { [key: string]: IAlarm };\n\n  private _albZonalIsolatedImpactAlarms: { [key: string]: IAlarm };\n\n  private _packetDropsPerZone: { [key: string]: IMetric };\n\n  private _faultsPerZone: { [key: string]: IMetric };\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: BasicServiceMultiAZObservabilityProps,\n  ) {\n    super(scope, id);\n\n    // Initialize class properties\n    this.serviceName = props.serviceName;\n    this.applicationLoadBalancers = props.applicationLoadBalancers;\n    this.natGateways = props.natGateways;\n    this._natGWZonalIsolatedImpactAlarms = {};\n    this._albZonalIsolatedImpactAlarms = {};\n    this.aggregateZonalIsolatedImpactAlarms = {};\n    this._packetDropsPerZone = {};\n    this._faultsPerZone = {};\n\n    let outlierThreshold: number;\n\n    if (!props.outlierThreshold) {\n      switch (props.outlierDetectionAlgorithm) {\n        case OutlierDetectionAlgorithm.CHI_SQUARED:\n          outlierThreshold = 0.05;\n          break;\n        case OutlierDetectionAlgorithm.IQR:\n          outlierThreshold = 1.5;\n          break;\n        case OutlierDetectionAlgorithm.MAD:\n          outlierThreshold = 3;\n          break;\n        case OutlierDetectionAlgorithm.STATIC:\n          outlierThreshold = 0.7;\n          break;\n        case OutlierDetectionAlgorithm.Z_SCORE:\n          outlierThreshold = 2;\n          break;\n      }\n    } else {\n      outlierThreshold = props.outlierThreshold;\n    }\n\n    // Create the AZ mapper resource to translate AZ names to ids\n    this.azMapper = new AvailabilityZoneMapper(this, 'AvailabilityZoneMapper');\n\n    if (props.outlierDetectionAlgorithm != OutlierDetectionAlgorithm.STATIC) {\n      let outlierDetectionStack: StackWithDynamicSource =\n        new StackWithDynamicSource(this, 'OutlierDetectionStack', {\n          assetsBucketsParameterName: props.assetsBucketParameterName,\n          assetsBucketPrefixParameterName:\n            props.assetsBucketPrefixParameterName,\n        });\n\n      this.outlierDetectionFunction = new OutlierDetectionFunction(\n        outlierDetectionStack,\n        'OutlierDetectionFunction',\n        {},\n      ).function;\n    }\n\n    // Create metrics and alarms for just load balancers if they were provided\n    if (\n      this.applicationLoadBalancers !== undefined &&\n      this.applicationLoadBalancers != null\n    ) {\n      this.doAlbMetrics(props, outlierThreshold);\n    }\n\n    // Create NAT Gateway metrics and alarms\n    if (this.natGateways !== undefined && this.natGateways != null) {\n      this.doNatGatewayMetrics(props, outlierThreshold);\n    }\n\n    let counter: number = 1;\n    // Go through the ALB zonal isolated impact alarms and see if there is a NAT GW\n    // isolated impact alarm for the same AZ ID, if so, create a composite alarm with both\n    // otherwise create a composite alarm with just the ALB\n    Object.keys(this._albZonalIsolatedImpactAlarms).forEach((az: string) => {\n      let tmp: IAlarm[] = [];\n      tmp.push(this._albZonalIsolatedImpactAlarms[az]);\n      if (\n        this._natGWZonalIsolatedImpactAlarms[az] !== undefined &&\n        this._natGWZonalIsolatedImpactAlarms[az] != null\n      ) {\n        tmp.push(this._natGWZonalIsolatedImpactAlarms[az]);\n      }\n      let availabilityZoneId: string =\n        this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(\n          az.substring(az.length - 1),\n        );\n\n      this.aggregateZonalIsolatedImpactAlarms[az] = new CompositeAlarm(\n        this,\n        'AZ' + counter++ + 'AggregateIsolatedImpactAlarm',\n        {\n          compositeAlarmName: availabilityZoneId + '-aggregate-isolated-impact',\n          alarmRule: AlarmRule.anyOf(...tmp),\n          actionsEnabled: false,\n        },\n      );\n    });\n\n    // In case there were AZs with only a NAT GW and no ALB, create a composite alarm\n    // for the NAT GW metrics\n    Object.keys(this._natGWZonalIsolatedImpactAlarms).forEach((az: string) => {\n      // If we don't yet have an isolated impact alarm for this AZ, proceed\n      if (\n        this.aggregateZonalIsolatedImpactAlarms[az] === undefined ||\n        this.aggregateZonalIsolatedImpactAlarms[az] == null\n      ) {\n        let tmp: IAlarm[] = [];\n        tmp.push(this._natGWZonalIsolatedImpactAlarms[az]);\n\n        if (\n          this._albZonalIsolatedImpactAlarms[az] !== undefined &&\n          this.albZonalIsolatedImpactAlarms != null\n        ) {\n          tmp.push(this.albZonalIsolatedImpactAlarms[az]);\n        }\n\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(\n            az.substring(az.length - 1),\n          );\n\n        this.aggregateZonalIsolatedImpactAlarms[az] = new CompositeAlarm(\n          this,\n          'AZ' + counter++ + 'AggregateIsolatedImpactAlarm',\n          {\n            compositeAlarmName:\n              availabilityZoneId + '-aggregate-isolated-impact',\n            alarmRule: AlarmRule.anyOf(...tmp),\n            actionsEnabled: false,\n          },\n        );\n      }\n    });\n\n    this.albZonalIsolatedImpactAlarms = this._albZonalIsolatedImpactAlarms;\n    this.natGWZonalIsolatedImpactAlarms = this._natGWZonalIsolatedImpactAlarms;\n\n    // Should we create the dashboard\n    if (props.createDashboard == true) {\n      this.dashboard = new BasicServiceDashboard(\n        this,\n        'BasicServiceDashboard',\n        {\n          serviceName: props.serviceName.toLowerCase(),\n          zonalAggregateIsolatedImpactAlarms:\n            this.aggregateZonalIsolatedImpactAlarms,\n          zonalLoadBalancerIsolatedImpactAlarms:\n            this.albZonalIsolatedImpactAlarms,\n          zonalNatGatewayIsolatedImpactAlarms:\n            this.natGWZonalIsolatedImpactAlarms,\n          interval: props.interval,\n          zonalLoadBalancerFaultRateMetrics: this._faultsPerZone,\n          zonalNatGatewayPacketDropMetrics: this._packetDropsPerZone,\n          azMapper: this.azMapper,\n        },\n      ).dashboard;\n    }\n  }\n\n  private doAlbMetrics(\n    props: BasicServiceMultiAZObservabilityProps,\n    outlierThreshold: number,\n  ) {\n    // Collect total fault count metrics per AZ\n    let albZoneFaultCountMetrics: { [key: string]: IMetric[] } = {};\n\n    // Create fault rate alarms per AZ indicating at least 1 ALB\n    // in the AZ saw a fault rate that exceeded the threshold\n    let faultRatePercentageAlarms: { [key: string]: IAlarm[] } = {};\n\n    let keyPrefix: string = AvailabilityAndLatencyMetrics.nextChar('');\n\n    // Iterate each ALB\n    this.applicationLoadBalancers!.forEach((alb) => {\n      // Iterate each AZ in the VPC\n      alb.vpc?.availabilityZones.forEach((az, index) => {\n        let azLetter = az.substring(az.length - 1);\n\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n        faultRatePercentageAlarms[azLetter] = [];\n\n        // 5xx responses from targets\n        let target5xx: IMetric = alb.metrics.httpCodeTarget(\n          HttpCodeTarget.TARGET_5XX_COUNT,\n          {\n            dimensionsMap: {\n              AvailabilityZone: az,\n              LoadBalancer: (alb as ILoadBalancerV2 as BaseLoadBalancer)\n                .loadBalancerFullName,\n            },\n            label: availabilityZoneId,\n            period: props.period,\n          },\n        );\n\n        // 5xx responses from ELB\n        let elb5xx: IMetric = alb.metrics.httpCodeElb(\n          HttpCodeElb.ELB_5XX_COUNT,\n          {\n            dimensionsMap: {\n              AvailabilityZone: az,\n              LoadBalancer: (alb as ILoadBalancerV2 as BaseLoadBalancer)\n                .loadBalancerFullName,\n            },\n            label: availabilityZoneId,\n            period: props.period,\n          },\n        );\n\n        // 2xx responses from targets\n        let target2xx: IMetric = alb.metrics.httpCodeTarget(\n          HttpCodeTarget.TARGET_2XX_COUNT,\n          {\n            dimensionsMap: {\n              AvailabilityZone: az,\n              LoadBalancer: (alb as ILoadBalancerV2 as BaseLoadBalancer)\n                .loadBalancerFullName,\n            },\n            label: availabilityZoneId,\n            period: props.period,\n          },\n        );\n\n        // 3xx responses from targets\n        let target3xx: IMetric = alb.metrics.httpCodeTarget(\n          HttpCodeTarget.TARGET_3XX_COUNT,\n          {\n            dimensionsMap: {\n              AvailabilityZone: az,\n              LoadBalancer: (alb as ILoadBalancerV2 as BaseLoadBalancer)\n                .loadBalancerFullName,\n            },\n            label: availabilityZoneId,\n            period: props.period,\n          },\n        );\n\n        // 3xx responess from ELB\n        let elb3xx: IMetric = alb.metrics.httpCodeElb(\n          HttpCodeElb.ELB_3XX_COUNT,\n          {\n            dimensionsMap: {\n              AvailabilityZone: az,\n              LoadBalancer: (alb as ILoadBalancerV2 as BaseLoadBalancer)\n                .loadBalancerFullName,\n            },\n            label: availabilityZoneId,\n            period: props.period,\n          },\n        );\n\n        // Create metrics for total fault count from this ALB\n        let usingMetrics: { [key: string]: IMetric } = {};\n        usingMetrics[`${keyPrefix}1`] = target5xx;\n        usingMetrics[`${keyPrefix}2`] = elb5xx;\n\n        if (\n          albZoneFaultCountMetrics[azLetter] === undefined ||\n          albZoneFaultCountMetrics[azLetter] == null\n        ) {\n          albZoneFaultCountMetrics[azLetter] = [];\n        }\n\n        albZoneFaultCountMetrics[azLetter].push(\n          new MathExpression({\n            expression: `(${keyPrefix}1 + ${keyPrefix}2)`,\n            usingMetrics: usingMetrics,\n            label:\n              availabilityZoneId + ' ' + alb.loadBalancerArn + ' fault count',\n            period: props.period,\n          }),\n        );\n\n        // Create metrics to calculate fault rate for this ALB\n        usingMetrics = {};\n        usingMetrics[`${keyPrefix}1`] = target2xx;\n        usingMetrics[`${keyPrefix}2`] = target3xx;\n        usingMetrics[`${keyPrefix}3`] = elb3xx;\n        usingMetrics[`${keyPrefix}4`] = target5xx;\n        usingMetrics[`${keyPrefix}5`] = elb5xx;\n\n        // The ALB fault rate\n        let faultRate: IMetric = new MathExpression({\n          expression: `((${keyPrefix}4+${keyPrefix}5)/(${keyPrefix}1+${keyPrefix}2+${keyPrefix}3+${keyPrefix}4+${keyPrefix}5)) * 100`,\n          usingMetrics: usingMetrics,\n          label: availabilityZoneId + ' ' + alb.loadBalancerArn + ' fault rate',\n          period: props.period,\n        });\n\n        let threshold: number = props.faultCountPercentageThreshold ?? 5;\n\n        // Create a fault rate alarm for the ALB\n        let faultRateAlarm: IAlarm = new Alarm(\n          this,\n          'AZ' + index + keyPrefix + 'FaultRatePercentageAlarm',\n          {\n            alarmName:\n              availabilityZoneId + '-' + alb.loadBalancerArn + '-fault-rate',\n            actionsEnabled: false,\n            metric: faultRate,\n            evaluationPeriods: props.evaluationPeriods,\n            datapointsToAlarm: props.datapointsToAlarm,\n            threshold: threshold,\n            comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,\n          },\n        );\n\n        // Add this ALB's fault rate alarm\n        faultRatePercentageAlarms[azLetter].push(faultRateAlarm);\n\n        // Get next unique key\n        keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n      });\n    });\n\n    // Iterate AZs for the ALB fault count metrics\n    Object.keys(albZoneFaultCountMetrics).forEach((azLetter) => {\n      let availabilityZoneId: string =\n        this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n      keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n\n      let counter: number = 1;\n      let usingMetrics: { [key: string]: IMetric } = {};\n\n      // Add each ALB's fault count metrics to the dictionary\n      albZoneFaultCountMetrics[azLetter].forEach((metric) => {\n        usingMetrics[`${keyPrefix}${counter++}`] = metric;\n      });\n\n      // Sum the total faults for the availability zone across all ALBs\n      let totalFaultsPerZone: IMetric = new MathExpression({\n        expression: Object.keys(usingMetrics).join('+'),\n        usingMetrics: usingMetrics,\n        label: availabilityZoneId + ' fault count',\n        period: props.period,\n      });\n\n      keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n      counter = 1;\n\n      // Assign the total faults per zone to the dictionary\n      this._faultsPerZone[azLetter] = totalFaultsPerZone;\n    });\n\n    keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n\n    let tmp: { [key: string]: IMetric } = {};\n    Object.keys(this._faultsPerZone).forEach((azLetter, index) => {\n      tmp[`${keyPrefix}${index}`] = this._faultsPerZone[azLetter];\n    });\n\n    // Calculate the total faults in the region by adding all AZs together\n    let totalFaults: IMetric = new MathExpression({\n      expression: Object.keys(tmp).join('+'),\n      usingMetrics: tmp,\n      label: Fn.sub('${AWS::Region} fault count'),\n      period: props.period,\n    });\n\n    if (props.outlierDetectionAlgorithm == OutlierDetectionAlgorithm.STATIC) {\n      // Finally, iterate back through each AZ\n      Object.keys(this._faultsPerZone).forEach((azLetter, index) => {\n        keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n        // Determine if AZ is an outlier for faults by exceeding\n        // a static threshold\n        let outlierMetrics: IMetric;\n\n        // These metrics will give the percent of faults for the AZ\n        let usingMetrics: { [key: string]: IMetric } = {};\n        usingMetrics[`${keyPrefix}1`] = this._faultsPerZone[azLetter];\n        usingMetrics[`${keyPrefix}2`] = totalFaults;\n        outlierMetrics = new MathExpression({\n          expression: `${keyPrefix}1 / ${keyPrefix}2`,\n          usingMetrics: usingMetrics,\n        });\n\n        let azIsOutlierForFaults: IAlarm = new Alarm(\n          this,\n          'AZ' + index + 'FaultCountOutlierAlarm',\n          {\n            alarmName: availabilityZoneId + '-fault-count-outlier',\n            metric: outlierMetrics,\n            threshold: outlierThreshold,\n            evaluationPeriods: props.evaluationPeriods,\n            datapointsToAlarm: props.datapointsToAlarm,\n            actionsEnabled: false,\n            treatMissingData: TreatMissingData.IGNORE,\n            comparisonOperator:\n              ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n          },\n        );\n\n        // Create isolated AZ impact alarms by determining\n        // if the AZ is an outlier for fault count and at least\n        // one ALB exceeds the fault rate threshold provided\n        this._albZonalIsolatedImpactAlarms[azLetter] = new CompositeAlarm(\n          this,\n          'AZ' + index + 'IsolatedFaultCountImpact',\n          {\n            compositeAlarmName:\n              availabilityZoneId + '-isolated-fault-count-impact',\n            alarmRule: AlarmRule.allOf(\n              azIsOutlierForFaults,\n              AlarmRule.anyOf(...faultRatePercentageAlarms[azLetter]),\n            ),\n          },\n        );\n      });\n    } else {\n      let allAZs: string[] = Array.from(\n        new Set(\n          this.applicationLoadBalancers!.flatMap((x) => {\n            return x.vpc!.availabilityZones;\n          }),\n        ),\n      );\n\n      allAZs.forEach((az: string, index: number) => {\n        let azLetter: string = az.substring(az.length - 1);\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n        let azIsOutlierForFaults: IAlarm =\n          AvailabilityAndLatencyAlarmsAndRules.createZonalFaultRateOutlierAlarmForAlb(\n            this,\n            props.applicationLoadBalancers!,\n            availabilityZoneId,\n            outlierThreshold,\n            this.outlierDetectionFunction!,\n            props.outlierDetectionAlgorithm,\n            this.azMapper,\n            index,\n            props.evaluationPeriods,\n            props.datapointsToAlarm,\n            '',\n          );\n\n        // In addition to being an outlier for fault count, make sure\n        // the fault count is substantial enough to trigger the alarm\n        // by making sure at least 1 ALB sees packet loss that exceeds the threshold\n        let azIsOutlierAndSeesImpact: IAlarm = new CompositeAlarm(\n          this,\n          'AZ' + index + 'ALBIsolatedImpact',\n          {\n            compositeAlarmName:\n              availabilityZoneId + '-isolated-fault-count-impact',\n            alarmRule: AlarmRule.allOf(\n              azIsOutlierForFaults,\n              AlarmRule.anyOf(...faultRatePercentageAlarms[azLetter]),\n            ),\n          },\n        );\n\n        // Record these so they can be used in dashboard or for combination\n        // with AZ\n        this._albZonalIsolatedImpactAlarms[azLetter] = azIsOutlierAndSeesImpact;\n      });\n    }\n  }\n\n  private doNatGatewayMetrics(\n    props: BasicServiceMultiAZObservabilityProps,\n    outlierThreshold: number,\n  ) {\n    let keyPrefix: string = AvailabilityAndLatencyMetrics.nextChar('');\n\n    // Collect alarms for packet drops exceeding a threshold per NAT GW\n    let packetDropPercentageAlarms: { [key: string]: IAlarm[] } = {};\n\n    // For each AZ, create metrics for each NAT GW\n    Object.entries(this.natGateways!).forEach((entry, index) => {\n      // The number of packet drops for each NAT GW in the AZ\n      let packetDropMetricsForAZ: { [key: string]: IMetric } = {};\n\n      let az: string = entry[0];\n      let azLetter: string = az.substring(az.length - 1);\n      let availabilityZoneId =\n        this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n      packetDropPercentageAlarms[azLetter] = [];\n\n      // Iterate through each NAT GW in the current AZ\n      entry[1].forEach((natgw) => {\n        // Calculate packet drops\n        let packetDropCount: IMetric = new Metric({\n          metricName: 'PacketsDropCount',\n          namespace: 'AWS/NATGateway',\n          statistic: 'Sum',\n          unit: Unit.COUNT,\n          label: availabilityZoneId + ' packet drops',\n          dimensionsMap: {\n            NatGatewayId: natgw.attrNatGatewayId,\n          },\n          period: props.period,\n        });\n\n        // Calculate packets in from source\n        let packetsInFromSourceCount: IMetric = new Metric({\n          metricName: 'PacketsInFromSource',\n          namespace: 'AWS/NATGateway',\n          statistic: 'Sum',\n          unit: Unit.COUNT,\n          label: availabilityZoneId + ' packets in from source',\n          dimensionsMap: {\n            NatGatewayId: natgw.attrNatGatewayId,\n          },\n          period: props.period,\n        });\n\n        // Calculate packets in from destination\n        let packetsInFromDestinationCount: IMetric = new Metric({\n          metricName: 'PacketsInFromDestination',\n          namespace: 'AWS/NATGateway',\n          statistic: 'Sum',\n          unit: Unit.COUNT,\n          label: availabilityZoneId + ' packets in from destination',\n          dimensionsMap: {\n            NatGatewayId: natgw.attrNatGatewayId,\n          },\n          period: props.period,\n        });\n\n        let usingMetrics: { [key: string]: IMetric } = {};\n        usingMetrics[`${keyPrefix}1`] = packetDropCount;\n        usingMetrics[`${keyPrefix}2`] = packetsInFromSourceCount;\n        usingMetrics[`${keyPrefix}3`] = packetsInFromDestinationCount;\n\n        // Calculate a percentage of dropped packets for the NAT GW\n        let packetDropPercentage: IMetric = new MathExpression({\n          expression: `(${keyPrefix}1 / (${keyPrefix}2 + ${keyPrefix}3)) * 100`,\n          usingMetrics: usingMetrics,\n          label: availabilityZoneId + ' packet drop percentage',\n          period: props.period,\n        });\n\n        let threshold: number =\n          props.packetLossImpactPercentageThreshold ?? 0.01;\n\n        // Create an alarm for this NAT GW if packet drops exceed the specified threshold\n        let packetDropImpactAlarm: IAlarm = new Alarm(\n          this,\n          'AZ' + (index + 1) + 'PacketDropImpactAlarm',\n          {\n            alarmName:\n              availabilityZoneId +\n              '-' +\n              natgw.attrNatGatewayId +\n              '-packet-drop-impact',\n            actionsEnabled: false,\n            metric: packetDropPercentage,\n            threshold: threshold,\n            comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,\n            evaluationPeriods: props.evaluationPeriods,\n            datapointsToAlarm: props.datapointsToAlarm,\n          },\n        );\n\n        // Collect all of the packet drop impact alarms for each\n        // NAT GW in this AZ, need to know at least 1 sees substantial\n        // enough impact to consider the AZ as impaired\n        packetDropPercentageAlarms[azLetter].push(packetDropImpactAlarm);\n\n        // Collect the packet drop metrics for this AZ so we can\n        // add them all together and count total packet drops\n        // for all NAT GWs in the AZ\n        packetDropMetricsForAZ[`m${index}`] = packetDropCount;\n      });\n\n      // Create a metric that adds up all packets drops from each\n      // NAT GW in the AZ\n      let packetDropsInThisAZ: IMetric = new MathExpression({\n        expression: Object.keys(packetDropMetricsForAZ).join('+'),\n        usingMetrics: packetDropMetricsForAZ,\n        label: availabilityZoneId + ' dropped packets',\n        period: props.period,\n      });\n\n      // Record these so we can add them up\n      // and get a total amount of packet drops\n      // in the region across all AZs\n      this._packetDropsPerZone[azLetter] = packetDropsInThisAZ;\n    });\n\n    keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n\n    let tmp: { [key: string]: IMetric } = {};\n    Object.keys(this._packetDropsPerZone).forEach((azLetter, index) => {\n      tmp[`${keyPrefix}${index}`] = this._packetDropsPerZone[azLetter];\n    });\n\n    // Calculate total packet drops for the region\n    let totalPacketDrops: IMetric = new MathExpression({\n      expression: Object.keys(tmp).join('+'),\n      usingMetrics: tmp,\n      label: Fn.ref('AWS::Region') + ' dropped packets',\n      period: props.period,\n    });\n\n    if (props.outlierDetectionAlgorithm == OutlierDetectionAlgorithm.STATIC) {\n      // Create outlier detection alarms by comparing packet\n      // drops in one AZ versus total packet drops in the region\n      Object.keys(this._packetDropsPerZone).forEach((azLetter, index) => {\n        let azIsOutlierForPacketDrops: IAlarm;\n        keyPrefix = AvailabilityAndLatencyMetrics.nextChar(keyPrefix);\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n        // Determine if AZ is an outlier for faults by exceeding\n        // a static threshold\n        let outlierMetrics: IMetric;\n\n        // These metrics will give the percent of faults for the AZ\n        let usingMetrics: { [key: string]: IMetric } = {};\n        usingMetrics[`${keyPrefix}1`] = this._packetDropsPerZone[azLetter];\n        usingMetrics[`${keyPrefix}2`] = totalPacketDrops;\n\n        outlierMetrics = new MathExpression({\n          expression: `(${keyPrefix}1 / ${keyPrefix}2) * 100`,\n          usingMetrics: usingMetrics,\n          label: availabilityZoneId + ' percentage of dropped packets',\n        });\n\n        azIsOutlierForPacketDrops = new Alarm(\n          this,\n          'AZ' + (index + 1) + 'NATGWDroppedPacketsOutlierAlarm',\n          {\n            metric: outlierMetrics,\n            alarmName: availabilityZoneId + '-dropped-packets-outlier',\n            evaluationPeriods: props.evaluationPeriods,\n            datapointsToAlarm: props.datapointsToAlarm,\n            threshold: outlierThreshold,\n            actionsEnabled: false,\n            treatMissingData: TreatMissingData.IGNORE,\n            comparisonOperator:\n              ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n          },\n        );\n\n        // In addition to being an outlier for packet drops, make sure\n        // the packet loss is substantial enough to trigger the alarm\n        // by making sure at least 1 NAT GW sees packet loss more than 0.01%\n        let azIsOutlierAndSeesImpact: IAlarm = new CompositeAlarm(\n          this,\n          'AZ' + index + 'NATGWIsolatedImpact',\n          {\n            compositeAlarmName: availabilityZoneId + '-isolated-natgw-impact',\n            alarmRule: AlarmRule.allOf(\n              azIsOutlierForPacketDrops,\n              AlarmRule.anyOf(...packetDropPercentageAlarms[azLetter]),\n            ),\n          },\n        );\n\n        // Record these so they can be used in dashboard or for combination\n        // with AZ\n        this._natGWZonalIsolatedImpactAlarms[azLetter] =\n          azIsOutlierAndSeesImpact;\n      });\n    } else {\n      Object.keys(props.natGateways!).forEach((az: string, index: number) => {\n        let azLetter: string = az.substring(az.length - 1);\n        let availabilityZoneId: string =\n          this.azMapper.availabilityZoneIdFromAvailabilityZoneLetter(azLetter);\n\n        // Iterate all NAT GWs in this AZ\n\n        let azIsOutlierForPacketDrops: IAlarm =\n          AvailabilityAndLatencyAlarmsAndRules.createZonalFaultRateOutlierAlarmForNatGW(\n            this,\n            this.natGateways!,\n            availabilityZoneId,\n            outlierThreshold,\n            this.outlierDetectionFunction!,\n            props.outlierDetectionAlgorithm,\n            this.azMapper,\n            index,\n            props.evaluationPeriods,\n            props.datapointsToAlarm,\n            '',\n          );\n\n        // In addition to being an outlier for packet drops, make sure\n        // the packet loss is substantial enough to trigger the alarm\n        // by making sure at least 1 NAT GW sees packet loss more than 0.01%\n        let azIsOutlierAndSeesImpact: IAlarm = new CompositeAlarm(\n          this,\n          'AZ' + index + 'NATGWIsolatedImpact',\n          {\n            compositeAlarmName: availabilityZoneId + '-isolated-natgw-impact',\n            alarmRule: AlarmRule.allOf(\n              azIsOutlierForPacketDrops,\n              AlarmRule.anyOf(...packetDropPercentageAlarms[azLetter]),\n            ),\n          },\n        );\n\n        // Record these so they can be used in dashboard or for combination\n        // with AZ\n        this._natGWZonalIsolatedImpactAlarms[azLetter] =\n          azIsOutlierAndSeesImpact;\n      });\n    }\n  }\n}\n"]}