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

package/lib/alarmsandrules/AvailabilityAndLatencyAlarmsAndRules.js

@@ -0,0 +1,763 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityAndLatencyAlarmsAndRules = void 0;
+// 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 InsightRuleBody_1 = require("./InsightRuleBody");
+const RegionalAvailabilityMetrics_1 = require("../metrics/RegionalAvailabilityMetrics");
+const RegionalLatencyMetrics_1 = require("../metrics/RegionalLatencyMetrics");
+const ZonalAvailabilityMetrics_1 = require("../metrics/ZonalAvailabilityMetrics");
+const ZonalLatencyMetrics_1 = require("../metrics/ZonalLatencyMetrics");
+const AvailabilityMetricType_1 = require("../utilities/AvailabilityMetricType");
+const LatencyMetricType_1 = require("../utilities/LatencyMetricType");
+/**
+ * Class used to create availability and latency alarms and Contributor Insight rules
+ */
+class AvailabilityAndLatencyAlarmsAndRules {
+    /**
+     * Creates a zonal availability alarm
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @returns
+     */
+    static createZonalAvailabilityAlarm(scope, metricDetails, availabilityZoneId, counter, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName + 'AZ' + counter + 'AvailabilityAlarm', {
+            alarmName: availabilityZoneId +
+                '-' +
+                metricDetails.operationName.toLowerCase() +
+                '-success-rate' +
+                nameSuffix,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.LESS_THAN_THRESHOLD,
+            threshold: metricDetails.successAlarmThreshold,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+            metric: ZonalAvailabilityMetrics_1.ZonalAvailabilityMetrics.createZonalAvailabilityMetric({
+                availabilityZoneId: availabilityZoneId,
+                label: availabilityZoneId + ' availability',
+                metricDetails: metricDetails,
+                metricType: AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_RATE,
+            }),
+        });
+    }
+    /**
+     * Creates a zonal latency alarm
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @returns
+     */
+    static createZonalLatencyAlarm(scope, metricDetails, availabilityZoneId, counter, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName + 'AZ' + counter + 'LatencyAlarm', {
+            alarmName: availabilityZoneId +
+                '-' +
+                metricDetails.operationName.toLowerCase() +
+                '-success-latency' +
+                nameSuffix,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: metricDetails.successAlarmThreshold,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+            metric: ZonalLatencyMetrics_1.ZonalLatencyMetrics.createZonalAverageLatencyMetric({
+                availabilityZoneId: availabilityZoneId,
+                label: availabilityZoneId +
+                    ' ' +
+                    metricDetails.alarmStatistic +
+                    ' latency',
+                metricDetails: metricDetails,
+                metricType: LatencyMetricType_1.LatencyMetricType.SUCCESS_LATENCY,
+                statistic: metricDetails.alarmStatistic,
+            }),
+        });
+    }
+    /**
+     * Creates a composite alarm when either latency or availability is breached in the Availabiltiy Zone
+     * @param scope
+     * @param operation
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @param zonalAvailabilityAlarm
+     * @param zonalLatencyAlarm
+     * @returns
+     */
+    static createZonalAvailabilityOrLatencyCompositeAlarm(scope, operationName, availabilityZoneId, counter, zonalAvailabilityAlarm, zonalLatencyAlarm, nameSuffix) {
+        return new aws_cloudwatch_1.CompositeAlarm(scope, 'AZ' + counter + 'ZonalImpactAlarm', {
+            actionsEnabled: false,
+            alarmDescription: availabilityZoneId +
+                ' has latency or availability impact. This does not indicate it is an outlier and shows isolated impact.',
+            compositeAlarmName: availabilityZoneId +
+                `-${operationName.toLowerCase()}-impact-aggregate-alarm` +
+                nameSuffix,
+            alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(zonalAvailabilityAlarm, zonalLatencyAlarm),
+        });
+    }
+    /**
+     * An alarm that compares error rate in this AZ to the overall region error based only on metric data
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @param outlierThreshold
+     * @returns
+     */
+    static createZonalFaultRateStaticOutlierAlarm(scope, metricDetails, availabilityZoneId, counter, outlierThreshold, nameSuffix) {
+        let zonalFaults = ZonalAvailabilityMetrics_1.ZonalAvailabilityMetrics.createZonalAvailabilityMetric({
+            availabilityZoneId: availabilityZoneId,
+            metricDetails: metricDetails,
+            metricType: AvailabilityMetricType_1.AvailabilityMetricType.FAULT_COUNT,
+            keyPrefix: 'a',
+        });
+        let regionalFaults = RegionalAvailabilityMetrics_1.RegionalAvailabilityMetrics.createRegionalAvailabilityMetric({
+            metricDetails: metricDetails,
+            metricType: AvailabilityMetricType_1.AvailabilityMetricType.FAULT_COUNT,
+            keyPrefix: 'b',
+        });
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'IsolatedImpactAlarmStatic', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-static-majority-errors-impact` +
+                nameSuffix,
+            metric: new aws_cloudwatch_1.MathExpression({
+                expression: 'IF(m2 > 0, (m1 / m2), 0)',
+                usingMetrics: {
+                    m1: zonalFaults,
+                    m2: regionalFaults,
+                },
+                period: metricDetails.period,
+                label: availabilityZoneId + ' percent faults',
+            }),
+            threshold: outlierThreshold,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+        });
+    }
+    static createZonalFaultRateOutlierAlarm(scope, metricDetails, availabilityZoneId, allAvailabilityZoneIds, outlierThreshold, outlierDetectionFunction, outlierDetectionAlgorithm, counter, nameSuffix) {
+        let metricDimensions = {};
+        allAvailabilityZoneIds.forEach((azId) => {
+            metricDimensions[azId] = [
+                metricDetails.metricDimensions.zonalDimensions(azId, aws_cdk_lib_1.Fn.ref('AWS::Region')),
+            ];
+        });
+        let str = JSON.stringify(metricDimensions)
+            .replace(/[\\]/g, '\\\\')
+            .replace(/[\"]/g, '\\"')
+            .replace(/[\/]/g, '\\/')
+            .replace(/[\b]/g, '\\b')
+            .replace(/[\f]/g, '\\f')
+            .replace(/[\n]/g, '\\n')
+            .replace(/[\r]/g, '\\r')
+            .replace(/[\t]/g, '\\t');
+        let outlierMetrics = new aws_cloudwatch_1.MathExpression({
+            expression: `MAX(LAMBDA("${outlierDetectionFunction.functionName}",` +
+                `"${outlierDetectionAlgorithm.toString()}",` +
+                `"${outlierThreshold}",` +
+                `"${availabilityZoneId}",` +
+                `"${str}",` +
+                `"${metricDetails.metricNamespace}",` +
+                `"${metricDetails.faultMetricNames.join(':')}",` +
+                '"Sum",' +
+                '"Count"' +
+                '))',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+        });
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'FaultIsolatedImpactAlarmOutlier', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-majority-errors-impact` +
+                nameSuffix,
+            metric: outlierMetrics,
+            threshold: 1,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+        });
+    }
+    static createZonalFaultRateOutlierAlarmForAlb(scope, loadBalancers, availabilityZoneId, outlierThreshold, outlierDetectionFunction, outlierDetectionAlgorithm, azMapper, counter, evaluationPeriods, datapointsToAlarm, nameSuffix) {
+        let metricDimensions = {};
+        loadBalancers.forEach((x) => {
+            x.vpc?.availabilityZones.forEach((az) => {
+                let azId = azMapper.availabilityZoneIdFromAvailabilityZoneLetter(az.substring(az.length - 1));
+                if (!(azId in metricDimensions)) {
+                    metricDimensions[azId] = [];
+                }
+                metricDimensions[azId].push({
+                    AvailabilityZone: az,
+                    LoadBalancer: x
+                        .loadBalancerFullName,
+                });
+            });
+        });
+        let str = JSON.stringify(metricDimensions)
+            .replace(/[\\]/g, '\\\\')
+            .replace(/[\"]/g, '\\"')
+            .replace(/[\/]/g, '\\/')
+            .replace(/[\b]/g, '\\b')
+            .replace(/[\f]/g, '\\f')
+            .replace(/[\n]/g, '\\n')
+            .replace(/[\r]/g, '\\r')
+            .replace(/[\t]/g, '\\t');
+        let outlierMetrics = new aws_cloudwatch_1.MathExpression({
+            expression: `MAX(LAMBDA("${outlierDetectionFunction.functionName}",` +
+                `"${outlierDetectionAlgorithm.toString()}",` +
+                `"${outlierThreshold}",` +
+                `"${availabilityZoneId}",` +
+                `"${str}",` +
+                '"AWS/ApplicationELB",' +
+                '"HTTPCode_ELB_5XX_Count:HTTPCode_Target_5XX_Count",' +
+                '"Sum",' +
+                '"Count"' +
+                '))',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+        });
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'AlbIsolatedImpactAlarmOutlier', {
+            alarmName: availabilityZoneId + '-alb-majority-errors-impact' + nameSuffix,
+            metric: outlierMetrics,
+            threshold: 1,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: evaluationPeriods,
+            datapointsToAlarm: datapointsToAlarm,
+        });
+    }
+    static createZonalFaultRateOutlierAlarmForNatGW(scope, natGateways, availabilityZoneId, outlierThreshold, outlierDetectionFunction, outlierDetectionAlgorithm, azMapper, counter, evaluationPeriods, datapointsToAlarm, nameSuffix) {
+        let metricDimensions = {};
+        Object.keys(natGateways).forEach((az) => {
+            let azId = azMapper.availabilityZoneIdFromAvailabilityZoneLetter(az.substring(az.length - 1));
+            if (!(azId in metricDimensions)) {
+                metricDimensions[azId] = [];
+            }
+            natGateways[az].forEach((natgw) => {
+                metricDimensions[azId].push({
+                    NatGatewayId: natgw.attrNatGatewayId,
+                });
+            });
+        });
+        let str = JSON.stringify(metricDimensions)
+            .replace(/[\\]/g, '\\\\')
+            .replace(/[\"]/g, '\\"')
+            .replace(/[\/]/g, '\\/')
+            .replace(/[\b]/g, '\\b')
+            .replace(/[\f]/g, '\\f')
+            .replace(/[\n]/g, '\\n')
+            .replace(/[\r]/g, '\\r')
+            .replace(/[\t]/g, '\\t');
+        let outlierMetrics = new aws_cloudwatch_1.MathExpression({
+            expression: `MAX(LAMBDA("${outlierDetectionFunction.functionName}",` +
+                `"${outlierDetectionAlgorithm.toString()}",` +
+                `"${outlierThreshold}",` +
+                `"${availabilityZoneId}",` +
+                `"${str}",` +
+                '"AWS/NATGateway",' +
+                '"PacketsDropCount",' +
+                '"Sum",' +
+                '"Count"' +
+                '))',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+        });
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'NatGWIsolatedImpactAlarmOutlier', {
+            alarmName: availabilityZoneId + '-nat-gw-majority-errors-impact' + nameSuffix,
+            metric: outlierMetrics,
+            threshold: 1,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: evaluationPeriods,
+            datapointsToAlarm: datapointsToAlarm,
+        });
+    }
+    static createZonalHighLatencyOutlierAlarm(scope, metricDetails, availabilityZoneId, allAvailabilityZoneIds, outlierThreshold, outlierDetectionFunction, outlierDetectionAlgorithm, counter, nameSuffix) {
+        let metricDimensions = {};
+        allAvailabilityZoneIds.forEach((azId) => {
+            metricDimensions[azId] = [
+                metricDetails.metricDimensions.zonalDimensions(azId, aws_cdk_lib_1.Fn.ref('AWS::Region')),
+            ];
+        });
+        let str = JSON.stringify(metricDimensions)
+            .replace(/[\\]/g, '\\\\')
+            .replace(/[\"]/g, '\\"')
+            .replace(/[\/]/g, '\\/')
+            .replace(/[\b]/g, '\\b')
+            .replace(/[\f]/g, '\\f')
+            .replace(/[\n]/g, '\\n')
+            .replace(/[\r]/g, '\\r')
+            .replace(/[\t]/g, '\\t');
+        let outlierMetrics = new aws_cloudwatch_1.MathExpression({
+            expression: `MAX(LAMBDA("${outlierDetectionFunction.functionName}",` +
+                `"${outlierDetectionAlgorithm.toString()}",` +
+                `"${outlierThreshold}",` +
+                `"${availabilityZoneId}",` +
+                `"${str}",` +
+                `"${metricDetails.metricNamespace}",` +
+                `"${metricDetails.successMetricNames.join(':')}",` +
+                `"TC(${metricDetails.successAlarmThreshold}:)",` +
+                '"Milliseconds"' +
+                '))',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+        });
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName +
+            'AZ' +
+            counter +
+            'LatencyIsolatedImpactAlarmOutlier', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-majority-high-latency-impact` +
+                nameSuffix,
+            metric: outlierMetrics,
+            threshold: 1,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+        });
+    }
+    static createZonalHighLatencyStaticOutlierAlarm(scope, metricDetails, availabilityZoneId, counter, outlierThreshold, nameSuffix) {
+        let zonalLatency = ZonalLatencyMetrics_1.ZonalLatencyMetrics.createZonalCountLatencyMetric({
+            availabilityZoneId: availabilityZoneId,
+            label: availabilityZoneId +
+                '-' +
+                metricDetails.operationName +
+                '-high-latency-requests',
+            metricDetails: metricDetails,
+            metricType: LatencyMetricType_1.LatencyMetricType.SUCCESS_LATENCY,
+            statistic: `TC(${metricDetails.successAlarmThreshold}:)`,
+            keyPrefix: 'a',
+        });
+        let regionalLatency = RegionalLatencyMetrics_1.RegionalLatencyMetrics.createRegionalLatencyCountMetric({
+            label: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                '-' +
+                metricDetails.operationName +
+                '-high-latency-requests',
+            metricDetails: metricDetails,
+            metricType: LatencyMetricType_1.LatencyMetricType.SUCCESS_LATENCY,
+            statistic: `TC(${metricDetails.successAlarmThreshold}:)`,
+            keyPrefix: 'b',
+        });
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName +
+            'AZ' +
+            counter +
+            'IsolatedImpactAlarmStatic', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-static-majority-high-latency-impact` +
+                nameSuffix,
+            metric: new aws_cloudwatch_1.MathExpression({
+                expression: 'IF(m2 > 0, (m1 / m2), 0)',
+                usingMetrics: {
+                    m1: zonalLatency,
+                    m2: regionalLatency,
+                },
+                period: metricDetails.period,
+                label: availabilityZoneId + ' percent high latency requests',
+            }),
+            threshold: outlierThreshold,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+        });
+    }
+    /**
+     * An insight rule that calculates how many instances are responding to requests in
+     * the specified AZ. Only useful for server-side metrics since the canary doesn't record instance id metrics.
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param logGroups
+     * @param nameSuffix
+     * @param counter
+     * @param instanceIdPath
+     * @param operationNamePath
+     * @param availabilityZoneIdPath
+     * @returns
+     */
+    static createServerSideInstancesHandlingRequestsInThisAZRule(scope, operationName, availabilityZoneId, ruleDetails, counter, nameSuffix) {
+        let ruleBody = new InsightRuleBody_1.InsightRuleBody();
+        ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);
+        ruleBody.aggregateOn = 'Count';
+        ruleBody.logFormat = 'JSON';
+        ruleBody.contribution = {
+            keys: [ruleDetails.instanceIdJsonPath],
+            filters: [
+                {
+                    Match: ruleDetails.availabilityZoneIdJsonPath,
+                    In: [availabilityZoneId],
+                },
+                {
+                    Match: ruleDetails.operationNameJsonPath,
+                    In: [operationName],
+                },
+            ],
+        };
+        return new aws_cloudwatch_1.CfnInsightRule(scope, 'AZ' + counter + 'InstancesInTheAZRule', {
+            ruleName: availabilityZoneId +
+                `-${operationName.toLowerCase()}-instances-in-the-az` +
+                nameSuffix,
+            ruleState: 'ENABLED',
+            ruleBody: ruleBody.toJson(),
+        });
+    }
+    /**
+     * An insight rule that calculates the instances contributing to errors
+     * in this AZ. Only useful for server-side metrics since the canary doesn't record instance id metrics.
+     * @param scope
+     * @param operation
+     * @param availabilityZoneId
+     * @param logGroups
+     * @param nameSuffix
+     * @param counter
+     * @param instanceIdPath
+     * @param operationNamePath
+     * @param availabilityZoneIdPath
+     * @param errorMetricPath
+     * @returns
+     */
+    static createServerSideInstanceFaultContributorsInThisAZRule(scope, operationName, availabilityZoneId, ruleDetails, counter, nameSuffix) {
+        let ruleBody = new InsightRuleBody_1.InsightRuleBody();
+        ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);
+        ruleBody.aggregateOn = 'Count';
+        ruleBody.logFormat = 'JSON';
+        ruleBody.contribution = {
+            keys: [ruleDetails.instanceIdJsonPath],
+            filters: [
+                {
+                    Match: ruleDetails.availabilityZoneIdJsonPath,
+                    In: [availabilityZoneId],
+                },
+                {
+                    Match: ruleDetails.operationNameJsonPath,
+                    In: [operationName],
+                },
+                {
+                    Match: ruleDetails.faultMetricJsonPath,
+                    GreaterThan: 0,
+                },
+            ],
+        };
+        return new aws_cloudwatch_1.CfnInsightRule(scope, 'AZ' + counter + 'InstanceErrorContributionRule', {
+            ruleName: availabilityZoneId +
+                `-${operationName.toLowerCase()}-per-instance-faults` +
+                nameSuffix,
+            ruleState: 'ENABLED',
+            ruleBody: ruleBody.toJson(),
+        });
+    }
+    /**
+     * An insight rule that calculates instances contributing to high latency in this AZ. Only
+     * useful for server-side metrics since the canary doesn't record instance id metrics.
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param logGroups
+     * @param nameSuffix
+     * @param counter
+     * @returns
+     */
+    static createServerSideInstanceHighLatencyContributorsInThisAZRule(scope, metricDetails, availabilityZoneId, ruleDetails, counter, nameSuffix) {
+        let ruleBody = new InsightRuleBody_1.InsightRuleBody();
+        ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);
+        ruleBody.aggregateOn = 'Count';
+        ruleBody.logFormat = 'JSON';
+        ruleBody.contribution = {
+            keys: [ruleDetails.instanceIdJsonPath],
+            filters: [
+                {
+                    Match: ruleDetails.availabilityZoneIdJsonPath,
+                    In: [availabilityZoneId],
+                },
+                {
+                    Match: ruleDetails.operationNameJsonPath,
+                    In: [metricDetails.operationName],
+                },
+                {
+                    Match: ruleDetails.successLatencyMetricJsonPath,
+                    GreaterThan: metricDetails.successAlarmThreshold,
+                },
+            ],
+        };
+        return new aws_cloudwatch_1.CfnInsightRule(scope, 'AZ' + counter + 'LatencyContributorsRule', {
+            ruleName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-per-instance-high-latency` +
+                nameSuffix,
+            ruleState: 'ENABLED',
+            ruleBody: ruleBody.toJson(),
+        });
+    }
+    /**
+     * An alarm that indicates some percentage of the instances in this AZ are producing errors. Only
+     * useful for server-side metrics since the canary doesn't record instance id metrics.
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @param outlierThreshold
+     * @param instanceFaultRateContributorsInThisAZ
+     * @param instancesHandlingRequestsInThisAZ
+     * @returns
+     */
+    static createServerSideZonalMoreThanOneInstanceProducingFaultsAlarm(scope, metricDetails, availabilityZoneId, counter, outlierThreshold, instanceFaultRateContributorsInThisAZ, instancesHandlingRequestsInThisAZ, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'MoreThanOneAlarmForErrors', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-multiple-instances-faults` +
+                nameSuffix,
+            metric: new aws_cloudwatch_1.MathExpression({
+                expression: `INSIGHT_RULE_METRIC(\"${instanceFaultRateContributorsInThisAZ.attrRuleName}\", \"UniqueContributors\") / INSIGHT_RULE_METRIC(\"${instancesHandlingRequestsInThisAZ.attrRuleName}\", \"UniqueContributors\")`,
+                period: metricDetails.period,
+            }),
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            threshold: outlierThreshold,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+        });
+    }
+    /**
+     * An alarm indicating more than some percentage of instances in this AZ
+     * are contributing to high latency. Only useful for server-side metrics since
+     * the canary doesn't record instance id metrics.
+     * @param scope
+     * @param metricDetails
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @param outlierThreshold
+     * @param instanceHighLatencyContributorsInThisAZ
+     * @param instancesHandlingRequestsInThisAZ
+     * @returns
+     */
+    static createServerSideZonalMoreThanOneInstanceProducingHighLatencyAlarm(scope, metricDetails, availabilityZoneId, counter, outlierThreshold, instanceHighLatencyContributorsInThisAZ, instancesHandlingRequestsInThisAZ, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, 'AZ' + counter + 'MoreThanOneAlarmForHighLatency', {
+            alarmName: availabilityZoneId +
+                `-${metricDetails.operationName.toLowerCase()}-multiple-instances-high-latency` +
+                nameSuffix,
+            metric: new aws_cloudwatch_1.MathExpression({
+                expression: `INSIGHT_RULE_METRIC(\"${instanceHighLatencyContributorsInThisAZ.attrRuleName}\", \"UniqueContributors\") / INSIGHT_RULE_METRIC(\"${instancesHandlingRequestsInThisAZ.attrRuleName}\", \"UniqueContributors\")`,
+                period: metricDetails.period,
+            }),
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            threshold: outlierThreshold,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+        });
+    }
+    /**
+     * An alarm that indicates this AZ as an outlier
+     * for availability or latency. This does not ensure that the errors
+     * or latency originate from more than one instance.
+     * @param scope
+     * @param operation
+     * @param availabilityZoneId
+     * @param logGroups
+     * @param nameSuffix
+     * @param counter
+     * @param azIsOutlierForFaultsAlarm
+     * @param availabilityImpactAlarm
+     * @param azIsOutlierForLatencyAlarm
+     * @param latencyImpactAlarm
+     * @returns
+     */
+    static createCanaryIsolatedAZImpactAlarm(scope, operationName, availabilityZoneId, counter, azIsOutlierForFaultsAlarm, availabilityImpactAlarm, azIsOutlierForLatencyAlarm, latencyImpactAlarm, nameSuffix) {
+        return new aws_cloudwatch_1.CompositeAlarm(scope, operationName + 'AZ' + counter + 'IsolatedImpactAlarm' + nameSuffix, {
+            compositeAlarmName: availabilityZoneId +
+                `-${operationName.toLowerCase()}-isolated-impact-alarm` +
+                nameSuffix,
+            alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForFaultsAlarm, availabilityImpactAlarm), aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForLatencyAlarm, latencyImpactAlarm)),
+            actionsEnabled: false,
+        });
+    }
+    /**
+     * Creates the server side alarm to identify isolated single AZ
+     * impact meaning that this one AZ is affected and the others aren't
+     * @param scope
+     * @param operation
+     * @param availabilityZoneId
+     * @param nameSuffix
+     * @param counter
+     * @param azIsOutlierForFaultsAlarm
+     * @param availabilityImpactAlarm
+     * @param moreThanOneInstanceContributingToFaults
+     * @param azIsOutlierForLatencyAlarm
+     * @param latencyImpactAlarm
+     * @param moreThanOneInstanceContributingToLatency
+     * @returns
+     */
+    static createServerSideIsolatedAZImpactAlarm(scope, operationName, availabilityZoneId, counter, azIsOutlierForFaultsAlarm, availabilityImpactAlarm, moreThanOneInstanceContributingToFaults, azIsOutlierForLatencyAlarm, latencyImpactAlarm, moreThanOneInstanceContributingToLatency, nameSuffix) {
+        return new aws_cloudwatch_1.CompositeAlarm(scope, operationName + 'AZ' + counter + 'IsolatedImpactAlarm' + nameSuffix, {
+            compositeAlarmName: availabilityZoneId +
+                `-${operationName.toLowerCase()}-isolated-impact-alarm` +
+                nameSuffix,
+            alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(moreThanOneInstanceContributingToFaults === undefined ||
+                moreThanOneInstanceContributingToFaults == null
+                ? aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForFaultsAlarm, availabilityImpactAlarm)
+                : aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForFaultsAlarm, availabilityImpactAlarm, moreThanOneInstanceContributingToFaults), moreThanOneInstanceContributingToLatency === undefined ||
+                moreThanOneInstanceContributingToLatency == null
+                ? aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForLatencyAlarm, latencyImpactAlarm)
+                : aws_cloudwatch_1.AlarmRule.allOf(azIsOutlierForLatencyAlarm, latencyImpactAlarm, moreThanOneInstanceContributingToLatency)),
+            actionsEnabled: false,
+        });
+    }
+    /**
+     * Creates an alarm that fires if either the canary or the
+     * server side detect single AZ isolated impact
+     * @param scope
+     * @param operation
+     * @param availabilityZoneId
+     * @param counter
+     * @param serverSideAlarm
+     * @param canaryAlarm
+     * @returns
+     */
+    static createAggregateIsolatedAZImpactAlarm(scope, operation, availabilityZoneId, counter, serverSideAlarm, canaryAlarm) {
+        return new aws_cloudwatch_1.CompositeAlarm(scope, operation.operationName + 'AZ' + counter + 'AggregateIsolatedImpactAlarm', {
+            compositeAlarmName: availabilityZoneId +
+                `-${operation.operationName.toLowerCase()}-aggregate-isolated-impact-alarm`,
+            alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(serverSideAlarm, canaryAlarm),
+            actionsEnabled: false,
+        });
+    }
+    /**
+     * Creates a regional availability alarm for the operation
+     * @param scope
+     * @param metricDetails
+     * @param nameSuffix
+     * @param counter
+     * @returns
+     */
+    static createRegionalAvailabilityAlarm(scope, metricDetails, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName + 'RegionalAvailabilityAlarm', {
+            alarmName: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                '-' +
+                metricDetails.operationName.toLowerCase() +
+                '-success-rate' +
+                nameSuffix,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.LESS_THAN_THRESHOLD,
+            threshold: metricDetails.successAlarmThreshold,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+            metric: RegionalAvailabilityMetrics_1.RegionalAvailabilityMetrics.createRegionalAvailabilityMetric({
+                label: aws_cdk_lib_1.Fn.ref('AWS::Region') + ' availability',
+                metricDetails: metricDetails,
+                metricType: AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_RATE,
+            }),
+        });
+    }
+    /**
+     * Creates a regional latency alarm for the operation
+     * @param scope
+     * @param metricDetails
+     * @param nameSuffix
+     * @param counter
+     * @returns
+     */
+    static createRegionalLatencyAlarm(scope, metricDetails, nameSuffix) {
+        return new aws_cloudwatch_1.Alarm(scope, metricDetails.operationName + 'RegionalLatencyAlarm', {
+            alarmName: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                '-' +
+                metricDetails.operationName.toLowerCase() +
+                '-success-latency' +
+                nameSuffix,
+            evaluationPeriods: metricDetails.evaluationPeriods,
+            datapointsToAlarm: metricDetails.datapointsToAlarm,
+            comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: metricDetails.successAlarmThreshold,
+            actionsEnabled: false,
+            treatMissingData: aws_cloudwatch_1.TreatMissingData.IGNORE,
+            metric: RegionalLatencyMetrics_1.RegionalLatencyMetrics.createRegionalAverageLatencyMetric({
+                label: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                    ' ' +
+                    metricDetails.alarmStatistic +
+                    ' latency',
+                metricDetails: metricDetails,
+                metricType: LatencyMetricType_1.LatencyMetricType.SUCCESS_LATENCY,
+                statistic: metricDetails.alarmStatistic,
+            }),
+        });
+    }
+    /**
+     * A composite alarm combining latency and availability alarms for this operation in the region
+     * as measured from either the server side or canary
+     * @param scope
+     * @param operation
+     * @param nameSuffix
+     * @param regionalAvailabilityAlarm
+     * @param regionalLatencyAlarm
+     * @returns
+     */
+    static createRegionalCustomerExperienceAlarm(scope, operationName, nameSuffix, regionalAvailabilityAlarm, regionalLatencyAlarm) {
+        return new aws_cloudwatch_1.CompositeAlarm(scope, operationName + 'RegionalCustomerExperienceAlarm', {
+            compositeAlarmName: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                '-' +
+                operationName.toLowerCase() +
+                '-customer-experience-imact' +
+                nameSuffix,
+            alarmRule: aws_cloudwatch_1.AlarmRule.anyOf(regionalAvailabilityAlarm, regionalLatencyAlarm),
+        });
+    }
+    static createRegionalInstanceContributorsToHighLatency(scope, metricDetails, ruleDetails) {
+        let ruleBody = new InsightRuleBody_1.InsightRuleBody();
+        ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);
+        ruleBody.aggregateOn = 'Count';
+        ruleBody.logFormat = 'JSON';
+        ruleBody.contribution = {
+            keys: [ruleDetails.instanceIdJsonPath],
+            filters: [
+                {
+                    Match: ruleDetails.successLatencyMetricJsonPath,
+                    GreaterThan: metricDetails.successAlarmThreshold,
+                },
+                {
+                    Match: ruleDetails.operationNameJsonPath,
+                    In: [metricDetails.operationName],
+                },
+            ],
+        };
+        return new aws_cloudwatch_1.CfnInsightRule(scope, 'RegionPerInstanceHighLatencyRule', {
+            ruleName: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                `-${metricDetails.operationName.toLowerCase()}-per-instance-high-latency-server`,
+            ruleState: 'ENABLED',
+            ruleBody: ruleBody.toJson(),
+        });
+    }
+    static createRegionalInstanceContributorsToFaults(scope, metricDetails, ruleDetails) {
+        let ruleBody = new InsightRuleBody_1.InsightRuleBody();
+        ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);
+        ruleBody.aggregateOn = 'Count';
+        ruleBody.logFormat = 'JSON';
+        ruleBody.contribution = {
+            keys: [ruleDetails.instanceIdJsonPath],
+            filters: [
+                {
+                    Match: ruleDetails.faultMetricJsonPath,
+                    GreaterThan: 0,
+                },
+                {
+                    Match: ruleDetails.operationNameJsonPath,
+                    In: [metricDetails.operationName],
+                },
+            ],
+        };
+        return new aws_cloudwatch_1.CfnInsightRule(scope, 'RegionPerInstanceErrorRule', {
+            ruleName: aws_cdk_lib_1.Fn.ref('AWS::Region') +
+                `-${metricDetails.operationName.toLowerCase()}-per-instance-faults-server`,
+            ruleState: 'ENABLED',
+            ruleBody: ruleBody.toJson(),
+        });
+    }
+}
+exports.AvailabilityAndLatencyAlarmsAndRules = AvailabilityAndLatencyAlarmsAndRules;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AvailabilityAndLatencyAlarmsAndRules.js","sourceRoot":"","sources":["../../src/alarmsandrules/AvailabilityAndLatencyAlarmsAndRules.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 { Duration, Fn } from 'aws-cdk-lib';\nimport {\n  IAlarm,\n  Alarm,\n  IMetric,\n  CompositeAlarm,\n  AlarmRule,\n  MathExpression,\n  CfnInsightRule,\n  ComparisonOperator,\n  TreatMissingData,\n} from 'aws-cdk-lib/aws-cloudwatch';\nimport { CfnNatGateway } from 'aws-cdk-lib/aws-ec2';\nimport {\n  BaseLoadBalancer,\n  IApplicationLoadBalancer,\n  ILoadBalancerV2,\n} from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport { IFunction } from 'aws-cdk-lib/aws-lambda';\nimport { Construct, IConstruct } from 'constructs';\nimport { IContributionDefinition, InsightRuleBody } from './InsightRuleBody';\nimport { IAvailabilityZoneMapper } from '../azmapper/IAvailabilityZoneMapper';\nimport { RegionalAvailabilityMetrics } from '../metrics/RegionalAvailabilityMetrics';\nimport { RegionalLatencyMetrics } from '../metrics/RegionalLatencyMetrics';\nimport { ZonalAvailabilityMetrics } from '../metrics/ZonalAvailabilityMetrics';\nimport { ZonalLatencyMetrics } from '../metrics/ZonalLatencyMetrics';\nimport { IContributorInsightRuleDetails } from '../services/IContributorInsightRuleDetails';\nimport { IOperation } from '../services/IOperation';\nimport { IOperationMetricDetails } from '../services/IOperationMetricDetails';\nimport { AvailabilityMetricType } from '../utilities/AvailabilityMetricType';\nimport { LatencyMetricType } from '../utilities/LatencyMetricType';\nimport { OutlierDetectionAlgorithm } from '../utilities/OutlierDetectionAlgorithm';\n\n/**\n * Class used to create availability and latency alarms and Contributor Insight rules\n */\nexport class AvailabilityAndLatencyAlarmsAndRules {\n  /**\n   * Creates a zonal availability alarm\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @returns\n   */\n  static createZonalAvailabilityAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new Alarm(\n      scope,\n      metricDetails.operationName + 'AZ' + counter + 'AvailabilityAlarm',\n      {\n        alarmName:\n          availabilityZoneId +\n          '-' +\n          metricDetails.operationName.toLowerCase() +\n          '-success-rate' +\n          nameSuffix,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n        comparisonOperator: ComparisonOperator.LESS_THAN_THRESHOLD,\n        threshold: metricDetails.successAlarmThreshold,\n        actionsEnabled: false,\n        treatMissingData: TreatMissingData.IGNORE,\n        metric: ZonalAvailabilityMetrics.createZonalAvailabilityMetric({\n          availabilityZoneId: availabilityZoneId,\n          label: availabilityZoneId + ' availability',\n          metricDetails: metricDetails,\n          metricType: AvailabilityMetricType.SUCCESS_RATE,\n        }),\n      },\n    );\n  }\n\n  /**\n   * Creates a zonal latency alarm\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @returns\n   */\n  static createZonalLatencyAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new Alarm(\n      scope,\n      metricDetails.operationName + 'AZ' + counter + 'LatencyAlarm',\n      {\n        alarmName:\n          availabilityZoneId +\n          '-' +\n          metricDetails.operationName.toLowerCase() +\n          '-success-latency' +\n          nameSuffix,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,\n        threshold: metricDetails.successAlarmThreshold,\n        actionsEnabled: false,\n        treatMissingData: TreatMissingData.IGNORE,\n        metric: ZonalLatencyMetrics.createZonalAverageLatencyMetric({\n          availabilityZoneId: availabilityZoneId,\n          label:\n            availabilityZoneId +\n            ' ' +\n            metricDetails.alarmStatistic +\n            ' latency',\n          metricDetails: metricDetails,\n          metricType: LatencyMetricType.SUCCESS_LATENCY,\n          statistic: metricDetails.alarmStatistic,\n        }),\n      },\n    );\n  }\n\n  /**\n   * Creates a composite alarm when either latency or availability is breached in the Availabiltiy Zone\n   * @param scope\n   * @param operation\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @param zonalAvailabilityAlarm\n   * @param zonalLatencyAlarm\n   * @returns\n   */\n  static createZonalAvailabilityOrLatencyCompositeAlarm(\n    scope: Construct,\n    operationName: string,\n    availabilityZoneId: string,\n    counter: number,\n    zonalAvailabilityAlarm: IAlarm,\n    zonalLatencyAlarm: IAlarm,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new CompositeAlarm(scope, 'AZ' + counter + 'ZonalImpactAlarm', {\n      actionsEnabled: false,\n      alarmDescription:\n        availabilityZoneId +\n        ' has latency or availability impact. This does not indicate it is an outlier and shows isolated impact.',\n      compositeAlarmName:\n        availabilityZoneId +\n        `-${operationName.toLowerCase()}-impact-aggregate-alarm` +\n        nameSuffix,\n      alarmRule: AlarmRule.anyOf(zonalAvailabilityAlarm, zonalLatencyAlarm),\n    });\n  }\n\n  /**\n   * An alarm that compares error rate in this AZ to the overall region error based only on metric data\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @param outlierThreshold\n   * @returns\n   */\n  static createZonalFaultRateStaticOutlierAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    outlierThreshold: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let zonalFaults: IMetric =\n      ZonalAvailabilityMetrics.createZonalAvailabilityMetric({\n        availabilityZoneId: availabilityZoneId,\n        metricDetails: metricDetails,\n        metricType: AvailabilityMetricType.FAULT_COUNT,\n        keyPrefix: 'a',\n      });\n\n    let regionalFaults: IMetric =\n      RegionalAvailabilityMetrics.createRegionalAvailabilityMetric({\n        metricDetails: metricDetails,\n        metricType: AvailabilityMetricType.FAULT_COUNT,\n        keyPrefix: 'b',\n      });\n\n    return new Alarm(scope, 'AZ' + counter + 'IsolatedImpactAlarmStatic', {\n      alarmName:\n        availabilityZoneId +\n        `-${metricDetails.operationName.toLowerCase()}-static-majority-errors-impact` +\n        nameSuffix,\n      metric: new MathExpression({\n        expression: 'IF(m2 > 0, (m1 / m2), 0)',\n        usingMetrics: {\n          m1: zonalFaults,\n          m2: regionalFaults,\n        },\n        period: metricDetails.period,\n        label: availabilityZoneId + ' percent faults',\n      }),\n      threshold: outlierThreshold,\n      comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      treatMissingData: TreatMissingData.NOT_BREACHING,\n      evaluationPeriods: metricDetails.evaluationPeriods,\n      datapointsToAlarm: metricDetails.datapointsToAlarm,\n    });\n  }\n\n  static createZonalFaultRateOutlierAlarm(\n    scope: IConstruct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    allAvailabilityZoneIds: string[],\n    outlierThreshold: number,\n    outlierDetectionFunction: IFunction,\n    outlierDetectionAlgorithm: OutlierDetectionAlgorithm,\n    counter: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let metricDimensions: { [key: string]: { [key: string]: string }[] } = {};\n\n    allAvailabilityZoneIds.forEach((azId: string) => {\n      metricDimensions[azId] = [\n        metricDetails.metricDimensions.zonalDimensions(\n          azId,\n          Fn.ref('AWS::Region'),\n        ),\n      ];\n    });\n\n    let str: string = JSON.stringify(metricDimensions)\n      .replace(/[\\\\]/g, '\\\\\\\\')\n      .replace(/[\\\"]/g, '\\\\\"')\n      .replace(/[\\/]/g, '\\\\/')\n      .replace(/[\\b]/g, '\\\\b')\n      .replace(/[\\f]/g, '\\\\f')\n      .replace(/[\\n]/g, '\\\\n')\n      .replace(/[\\r]/g, '\\\\r')\n      .replace(/[\\t]/g, '\\\\t');\n\n    let outlierMetrics: IMetric = new MathExpression({\n      expression:\n        `MAX(LAMBDA(\"${outlierDetectionFunction.functionName}\",` +\n        `\"${outlierDetectionAlgorithm.toString()}\",` +\n        `\"${outlierThreshold}\",` +\n        `\"${availabilityZoneId}\",` +\n        `\"${str}\",` +\n        `\"${metricDetails.metricNamespace}\",` +\n        `\"${metricDetails.faultMetricNames.join(':')}\",` +\n        '\"Sum\",' +\n        '\"Count\"' +\n        '))',\n      period: Duration.seconds(60),\n    });\n\n    return new Alarm(\n      scope,\n      'AZ' + counter + 'FaultIsolatedImpactAlarmOutlier',\n      {\n        alarmName:\n          availabilityZoneId +\n          `-${metricDetails.operationName.toLowerCase()}-majority-errors-impact` +\n          nameSuffix,\n        metric: outlierMetrics,\n        threshold: 1,\n        comparisonOperator:\n          ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n      },\n    );\n  }\n\n  static createZonalFaultRateOutlierAlarmForAlb(\n    scope: IConstruct,\n    loadBalancers: IApplicationLoadBalancer[],\n    availabilityZoneId: string,\n    outlierThreshold: number,\n    outlierDetectionFunction: IFunction,\n    outlierDetectionAlgorithm: OutlierDetectionAlgorithm,\n    azMapper: IAvailabilityZoneMapper,\n    counter: number,\n    evaluationPeriods: number,\n    datapointsToAlarm: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let metricDimensions: { [key: string]: { [key: string]: string }[] } = {};\n\n    loadBalancers.forEach((x) => {\n      x.vpc?.availabilityZones.forEach((az) => {\n        let azId = azMapper.availabilityZoneIdFromAvailabilityZoneLetter(\n          az.substring(az.length - 1),\n        );\n        if (!(azId in metricDimensions)) {\n          metricDimensions[azId] = [];\n        }\n\n        metricDimensions[azId].push({\n          AvailabilityZone: az,\n          LoadBalancer: (x as ILoadBalancerV2 as BaseLoadBalancer)\n            .loadBalancerFullName,\n        });\n      });\n    });\n\n    let str: string = JSON.stringify(metricDimensions)\n      .replace(/[\\\\]/g, '\\\\\\\\')\n      .replace(/[\\\"]/g, '\\\\\"')\n      .replace(/[\\/]/g, '\\\\/')\n      .replace(/[\\b]/g, '\\\\b')\n      .replace(/[\\f]/g, '\\\\f')\n      .replace(/[\\n]/g, '\\\\n')\n      .replace(/[\\r]/g, '\\\\r')\n      .replace(/[\\t]/g, '\\\\t');\n\n    let outlierMetrics: IMetric = new MathExpression({\n      expression:\n        `MAX(LAMBDA(\"${outlierDetectionFunction.functionName}\",` +\n        `\"${outlierDetectionAlgorithm.toString()}\",` +\n        `\"${outlierThreshold}\",` +\n        `\"${availabilityZoneId}\",` +\n        `\"${str}\",` +\n        '\"AWS/ApplicationELB\",' +\n        '\"HTTPCode_ELB_5XX_Count:HTTPCode_Target_5XX_Count\",' +\n        '\"Sum\",' +\n        '\"Count\"' +\n        '))',\n      period: Duration.seconds(60),\n    });\n\n    return new Alarm(scope, 'AZ' + counter + 'AlbIsolatedImpactAlarmOutlier', {\n      alarmName:\n        availabilityZoneId + '-alb-majority-errors-impact' + nameSuffix,\n      metric: outlierMetrics,\n      threshold: 1,\n      comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      treatMissingData: TreatMissingData.NOT_BREACHING,\n      evaluationPeriods: evaluationPeriods,\n      datapointsToAlarm: datapointsToAlarm,\n    });\n  }\n\n  static createZonalFaultRateOutlierAlarmForNatGW(\n    scope: IConstruct,\n    natGateways: { [key: string]: CfnNatGateway[] },\n    availabilityZoneId: string,\n    outlierThreshold: number,\n    outlierDetectionFunction: IFunction,\n    outlierDetectionAlgorithm: OutlierDetectionAlgorithm,\n    azMapper: IAvailabilityZoneMapper,\n    counter: number,\n    evaluationPeriods: number,\n    datapointsToAlarm: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let metricDimensions: { [key: string]: { [key: string]: string }[] } = {};\n\n    Object.keys(natGateways).forEach((az) => {\n      let azId = azMapper.availabilityZoneIdFromAvailabilityZoneLetter(\n        az.substring(az.length - 1),\n      );\n\n      if (!(azId in metricDimensions)) {\n        metricDimensions[azId] = [];\n      }\n\n      natGateways[az].forEach((natgw) => {\n        metricDimensions[azId].push({\n          NatGatewayId: natgw.attrNatGatewayId,\n        });\n      });\n    });\n\n    let str: string = JSON.stringify(metricDimensions)\n      .replace(/[\\\\]/g, '\\\\\\\\')\n      .replace(/[\\\"]/g, '\\\\\"')\n      .replace(/[\\/]/g, '\\\\/')\n      .replace(/[\\b]/g, '\\\\b')\n      .replace(/[\\f]/g, '\\\\f')\n      .replace(/[\\n]/g, '\\\\n')\n      .replace(/[\\r]/g, '\\\\r')\n      .replace(/[\\t]/g, '\\\\t');\n\n    let outlierMetrics: IMetric = new MathExpression({\n      expression:\n        `MAX(LAMBDA(\"${outlierDetectionFunction.functionName}\",` +\n        `\"${outlierDetectionAlgorithm.toString()}\",` +\n        `\"${outlierThreshold}\",` +\n        `\"${availabilityZoneId}\",` +\n        `\"${str}\",` +\n        '\"AWS/NATGateway\",' +\n        '\"PacketsDropCount\",' +\n        '\"Sum\",' +\n        '\"Count\"' +\n        '))',\n      period: Duration.seconds(60),\n    });\n\n    return new Alarm(\n      scope,\n      'AZ' + counter + 'NatGWIsolatedImpactAlarmOutlier',\n      {\n        alarmName:\n          availabilityZoneId + '-nat-gw-majority-errors-impact' + nameSuffix,\n        metric: outlierMetrics,\n        threshold: 1,\n        comparisonOperator:\n          ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n        evaluationPeriods: evaluationPeriods,\n        datapointsToAlarm: datapointsToAlarm,\n      },\n    );\n  }\n\n  static createZonalHighLatencyOutlierAlarm(\n    scope: IConstruct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    allAvailabilityZoneIds: string[],\n    outlierThreshold: number,\n    outlierDetectionFunction: IFunction,\n    outlierDetectionAlgorithm: OutlierDetectionAlgorithm,\n    counter: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let metricDimensions: { [key: string]: { [key: string]: string }[] } = {};\n\n    allAvailabilityZoneIds.forEach((azId: string) => {\n      metricDimensions[azId] = [\n        metricDetails.metricDimensions.zonalDimensions(\n          azId,\n          Fn.ref('AWS::Region'),\n        ),\n      ];\n    });\n\n    let str: string = JSON.stringify(metricDimensions)\n      .replace(/[\\\\]/g, '\\\\\\\\')\n      .replace(/[\\\"]/g, '\\\\\"')\n      .replace(/[\\/]/g, '\\\\/')\n      .replace(/[\\b]/g, '\\\\b')\n      .replace(/[\\f]/g, '\\\\f')\n      .replace(/[\\n]/g, '\\\\n')\n      .replace(/[\\r]/g, '\\\\r')\n      .replace(/[\\t]/g, '\\\\t');\n\n    let outlierMetrics: IMetric = new MathExpression({\n      expression:\n        `MAX(LAMBDA(\"${outlierDetectionFunction.functionName}\",` +\n        `\"${outlierDetectionAlgorithm.toString()}\",` +\n        `\"${outlierThreshold}\",` +\n        `\"${availabilityZoneId}\",` +\n        `\"${str}\",` +\n        `\"${metricDetails.metricNamespace}\",` +\n        `\"${metricDetails.successMetricNames.join(':')}\",` +\n        `\"TC(${metricDetails.successAlarmThreshold}:)\",` +\n        '\"Milliseconds\"' +\n        '))',\n      period: Duration.seconds(60),\n    });\n\n    return new Alarm(\n      scope,\n      metricDetails.operationName +\n        'AZ' +\n        counter +\n        'LatencyIsolatedImpactAlarmOutlier',\n      {\n        alarmName:\n          availabilityZoneId +\n          `-${metricDetails.operationName.toLowerCase()}-majority-high-latency-impact` +\n          nameSuffix,\n        metric: outlierMetrics,\n        threshold: 1,\n        comparisonOperator:\n          ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n      },\n    );\n  }\n\n  static createZonalHighLatencyStaticOutlierAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    outlierThreshold: number,\n    nameSuffix?: string,\n  ): IAlarm {\n    let zonalLatency: IMetric =\n      ZonalLatencyMetrics.createZonalCountLatencyMetric({\n        availabilityZoneId: availabilityZoneId,\n        label:\n          availabilityZoneId +\n          '-' +\n          metricDetails.operationName +\n          '-high-latency-requests',\n        metricDetails: metricDetails,\n        metricType: LatencyMetricType.SUCCESS_LATENCY,\n        statistic: `TC(${metricDetails.successAlarmThreshold}:)`,\n        keyPrefix: 'a',\n      });\n\n    let regionalLatency: IMetric =\n      RegionalLatencyMetrics.createRegionalLatencyCountMetric({\n        label:\n          Fn.ref('AWS::Region') +\n          '-' +\n          metricDetails.operationName +\n          '-high-latency-requests',\n        metricDetails: metricDetails,\n        metricType: LatencyMetricType.SUCCESS_LATENCY,\n        statistic: `TC(${metricDetails.successAlarmThreshold}:)`,\n        keyPrefix: 'b',\n      });\n\n    return new Alarm(\n      scope,\n      metricDetails.operationName +\n        'AZ' +\n        counter +\n        'IsolatedImpactAlarmStatic',\n      {\n        alarmName:\n          availabilityZoneId +\n          `-${metricDetails.operationName.toLowerCase()}-static-majority-high-latency-impact` +\n          nameSuffix,\n        metric: new MathExpression({\n          expression: 'IF(m2 > 0, (m1 / m2), 0)',\n          usingMetrics: {\n            m1: zonalLatency,\n            m2: regionalLatency,\n          },\n          period: metricDetails.period,\n          label: availabilityZoneId + ' percent high latency requests',\n        }),\n        threshold: outlierThreshold,\n        comparisonOperator:\n          ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n      },\n    );\n  }\n\n  /**\n   * An insight rule that calculates how many instances are responding to requests in\n   * the specified AZ. Only useful for server-side metrics since the canary doesn't record instance id metrics.\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param logGroups\n   * @param nameSuffix\n   * @param counter\n   * @param instanceIdPath\n   * @param operationNamePath\n   * @param availabilityZoneIdPath\n   * @returns\n   */\n  static createServerSideInstancesHandlingRequestsInThisAZRule(\n    scope: Construct,\n    operationName: string,\n    availabilityZoneId: string,\n    ruleDetails: IContributorInsightRuleDetails,\n    counter: number,\n    nameSuffix?: string,\n  ): CfnInsightRule {\n    let ruleBody = new InsightRuleBody();\n    ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);\n    ruleBody.aggregateOn = 'Count';\n    ruleBody.logFormat = 'JSON';\n\n    ruleBody.contribution = {\n      keys: [ruleDetails.instanceIdJsonPath],\n      filters: [\n        {\n          Match: ruleDetails.availabilityZoneIdJsonPath,\n          In: [availabilityZoneId],\n        },\n        {\n          Match: ruleDetails.operationNameJsonPath,\n          In: [operationName],\n        },\n      ],\n    } as unknown as IContributionDefinition;\n\n    return new CfnInsightRule(scope, 'AZ' + counter + 'InstancesInTheAZRule', {\n      ruleName:\n        availabilityZoneId +\n        `-${operationName.toLowerCase()}-instances-in-the-az` +\n        nameSuffix,\n      ruleState: 'ENABLED',\n      ruleBody: ruleBody.toJson(),\n    });\n  }\n\n  /**\n   * An insight rule that calculates the instances contributing to errors\n   * in this AZ. Only useful for server-side metrics since the canary doesn't record instance id metrics.\n   * @param scope\n   * @param operation\n   * @param availabilityZoneId\n   * @param logGroups\n   * @param nameSuffix\n   * @param counter\n   * @param instanceIdPath\n   * @param operationNamePath\n   * @param availabilityZoneIdPath\n   * @param errorMetricPath\n   * @returns\n   */\n  static createServerSideInstanceFaultContributorsInThisAZRule(\n    scope: Construct,\n    operationName: string,\n    availabilityZoneId: string,\n    ruleDetails: IContributorInsightRuleDetails,\n    counter: number,\n    nameSuffix?: string,\n  ): CfnInsightRule {\n    let ruleBody = new InsightRuleBody();\n    ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);\n    ruleBody.aggregateOn = 'Count';\n    ruleBody.logFormat = 'JSON';\n    ruleBody.contribution = {\n      keys: [ruleDetails.instanceIdJsonPath],\n      filters: [\n        {\n          Match: ruleDetails.availabilityZoneIdJsonPath,\n          In: [availabilityZoneId],\n        },\n        {\n          Match: ruleDetails.operationNameJsonPath,\n          In: [operationName],\n        },\n        {\n          Match: ruleDetails.faultMetricJsonPath,\n          GreaterThan: 0,\n        },\n      ],\n    } as unknown as IContributionDefinition;\n\n    return new CfnInsightRule(\n      scope,\n      'AZ' + counter + 'InstanceErrorContributionRule',\n      {\n        ruleName:\n          availabilityZoneId +\n          `-${operationName.toLowerCase()}-per-instance-faults` +\n          nameSuffix,\n        ruleState: 'ENABLED',\n        ruleBody: ruleBody.toJson(),\n      },\n    );\n  }\n\n  /**\n   * An insight rule that calculates instances contributing to high latency in this AZ. Only\n   * useful for server-side metrics since the canary doesn't record instance id metrics.\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param logGroups\n   * @param nameSuffix\n   * @param counter\n   * @returns\n   */\n  static createServerSideInstanceHighLatencyContributorsInThisAZRule(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    ruleDetails: IContributorInsightRuleDetails,\n    counter: number,\n    nameSuffix?: string,\n  ): CfnInsightRule {\n    let ruleBody = new InsightRuleBody();\n    ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);\n    ruleBody.aggregateOn = 'Count';\n    ruleBody.logFormat = 'JSON';\n    ruleBody.contribution = {\n      keys: [ruleDetails.instanceIdJsonPath],\n      filters: [\n        {\n          Match: ruleDetails.availabilityZoneIdJsonPath,\n          In: [availabilityZoneId],\n        },\n        {\n          Match: ruleDetails.operationNameJsonPath,\n          In: [metricDetails.operationName],\n        },\n        {\n          Match: ruleDetails.successLatencyMetricJsonPath,\n          GreaterThan: metricDetails.successAlarmThreshold,\n        },\n      ],\n    } as unknown as IContributionDefinition;\n\n    return new CfnInsightRule(\n      scope,\n      'AZ' + counter + 'LatencyContributorsRule',\n      {\n        ruleName:\n          availabilityZoneId +\n          `-${metricDetails.operationName.toLowerCase()}-per-instance-high-latency` +\n          nameSuffix,\n        ruleState: 'ENABLED',\n        ruleBody: ruleBody.toJson(),\n      },\n    );\n  }\n\n  /**\n   * An alarm that indicates some percentage of the instances in this AZ are producing errors. Only\n   * useful for server-side metrics since the canary doesn't record instance id metrics.\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @param outlierThreshold\n   * @param instanceFaultRateContributorsInThisAZ\n   * @param instancesHandlingRequestsInThisAZ\n   * @returns\n   */\n  static createServerSideZonalMoreThanOneInstanceProducingFaultsAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    outlierThreshold: number,\n    instanceFaultRateContributorsInThisAZ: CfnInsightRule,\n    instancesHandlingRequestsInThisAZ: CfnInsightRule,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new Alarm(scope, 'AZ' + counter + 'MoreThanOneAlarmForErrors', {\n      alarmName:\n        availabilityZoneId +\n        `-${metricDetails.operationName.toLowerCase()}-multiple-instances-faults` +\n        nameSuffix,\n      metric: new MathExpression({\n        expression: `INSIGHT_RULE_METRIC(\\\"${instanceFaultRateContributorsInThisAZ.attrRuleName}\\\", \\\"UniqueContributors\\\") / INSIGHT_RULE_METRIC(\\\"${instancesHandlingRequestsInThisAZ.attrRuleName}\\\", \\\"UniqueContributors\\\")`,\n        period: metricDetails.period,\n      }),\n      evaluationPeriods: metricDetails.evaluationPeriods,\n      threshold: outlierThreshold,\n      comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      datapointsToAlarm: metricDetails.datapointsToAlarm,\n      actionsEnabled: false,\n      treatMissingData: TreatMissingData.IGNORE,\n    });\n  }\n\n  /**\n   * An alarm indicating more than some percentage of instances in this AZ\n   * are contributing to high latency. Only useful for server-side metrics since\n   * the canary doesn't record instance id metrics.\n   * @param scope\n   * @param metricDetails\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @param outlierThreshold\n   * @param instanceHighLatencyContributorsInThisAZ\n   * @param instancesHandlingRequestsInThisAZ\n   * @returns\n   */\n  static createServerSideZonalMoreThanOneInstanceProducingHighLatencyAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    availabilityZoneId: string,\n    counter: number,\n    outlierThreshold: number,\n    instanceHighLatencyContributorsInThisAZ: CfnInsightRule,\n    instancesHandlingRequestsInThisAZ: CfnInsightRule,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new Alarm(scope, 'AZ' + counter + 'MoreThanOneAlarmForHighLatency', {\n      alarmName:\n        availabilityZoneId +\n        `-${metricDetails.operationName.toLowerCase()}-multiple-instances-high-latency` +\n        nameSuffix,\n      metric: new MathExpression({\n        expression: `INSIGHT_RULE_METRIC(\\\"${instanceHighLatencyContributorsInThisAZ.attrRuleName}\\\", \\\"UniqueContributors\\\") / INSIGHT_RULE_METRIC(\\\"${instancesHandlingRequestsInThisAZ.attrRuleName}\\\", \\\"UniqueContributors\\\")`,\n        period: metricDetails.period,\n      }),\n      evaluationPeriods: metricDetails.evaluationPeriods,\n      threshold: outlierThreshold,\n      comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      datapointsToAlarm: metricDetails.datapointsToAlarm,\n      actionsEnabled: false,\n      treatMissingData: TreatMissingData.IGNORE,\n    });\n  }\n\n  /**\n   * An alarm that indicates this AZ as an outlier\n   * for availability or latency. This does not ensure that the errors\n   * or latency originate from more than one instance.\n   * @param scope\n   * @param operation\n   * @param availabilityZoneId\n   * @param logGroups\n   * @param nameSuffix\n   * @param counter\n   * @param azIsOutlierForFaultsAlarm\n   * @param availabilityImpactAlarm\n   * @param azIsOutlierForLatencyAlarm\n   * @param latencyImpactAlarm\n   * @returns\n   */\n  static createCanaryIsolatedAZImpactAlarm(\n    scope: Construct,\n    operationName: string,\n    availabilityZoneId: string,\n    counter: number,\n    azIsOutlierForFaultsAlarm: IAlarm,\n    availabilityImpactAlarm: IAlarm,\n    azIsOutlierForLatencyAlarm: IAlarm,\n    latencyImpactAlarm: IAlarm,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new CompositeAlarm(\n      scope,\n      operationName + 'AZ' + counter + 'IsolatedImpactAlarm' + nameSuffix,\n      {\n        compositeAlarmName:\n          availabilityZoneId +\n          `-${operationName.toLowerCase()}-isolated-impact-alarm` +\n          nameSuffix,\n        alarmRule: AlarmRule.anyOf(\n          AlarmRule.allOf(azIsOutlierForFaultsAlarm, availabilityImpactAlarm),\n          AlarmRule.allOf(azIsOutlierForLatencyAlarm, latencyImpactAlarm),\n        ),\n        actionsEnabled: false,\n      },\n    );\n  }\n\n  /**\n   * Creates the server side alarm to identify isolated single AZ\n   * impact meaning that this one AZ is affected and the others aren't\n   * @param scope\n   * @param operation\n   * @param availabilityZoneId\n   * @param nameSuffix\n   * @param counter\n   * @param azIsOutlierForFaultsAlarm\n   * @param availabilityImpactAlarm\n   * @param moreThanOneInstanceContributingToFaults\n   * @param azIsOutlierForLatencyAlarm\n   * @param latencyImpactAlarm\n   * @param moreThanOneInstanceContributingToLatency\n   * @returns\n   */\n  static createServerSideIsolatedAZImpactAlarm(\n    scope: Construct,\n    operationName: string,\n    availabilityZoneId: string,\n    counter: number,\n    azIsOutlierForFaultsAlarm: IAlarm,\n    availabilityImpactAlarm: IAlarm,\n    moreThanOneInstanceContributingToFaults: IAlarm,\n    azIsOutlierForLatencyAlarm: IAlarm,\n    latencyImpactAlarm: IAlarm,\n    moreThanOneInstanceContributingToLatency: IAlarm,\n    nameSuffix?: string,\n  ): IAlarm {\n    return new CompositeAlarm(\n      scope,\n      operationName + 'AZ' + counter + 'IsolatedImpactAlarm' + nameSuffix,\n      {\n        compositeAlarmName:\n          availabilityZoneId +\n          `-${operationName.toLowerCase()}-isolated-impact-alarm` +\n          nameSuffix,\n        alarmRule: AlarmRule.anyOf(\n          moreThanOneInstanceContributingToFaults === undefined ||\n            moreThanOneInstanceContributingToFaults == null\n            ? AlarmRule.allOf(\n              azIsOutlierForFaultsAlarm,\n              availabilityImpactAlarm,\n            )\n            : AlarmRule.allOf(\n              azIsOutlierForFaultsAlarm,\n              availabilityImpactAlarm,\n              moreThanOneInstanceContributingToFaults,\n            ),\n          moreThanOneInstanceContributingToLatency === undefined ||\n            moreThanOneInstanceContributingToLatency == null\n            ? AlarmRule.allOf(azIsOutlierForLatencyAlarm, latencyImpactAlarm)\n            : AlarmRule.allOf(\n              azIsOutlierForLatencyAlarm,\n              latencyImpactAlarm,\n              moreThanOneInstanceContributingToLatency,\n            ),\n        ),\n        actionsEnabled: false,\n      },\n    );\n  }\n\n  /**\n   * Creates an alarm that fires if either the canary or the\n   * server side detect single AZ isolated impact\n   * @param scope\n   * @param operation\n   * @param availabilityZoneId\n   * @param counter\n   * @param serverSideAlarm\n   * @param canaryAlarm\n   * @returns\n   */\n  static createAggregateIsolatedAZImpactAlarm(\n    scope: Construct,\n    operation: IOperation,\n    availabilityZoneId: string,\n    counter: number,\n    serverSideAlarm: IAlarm,\n    canaryAlarm: IAlarm,\n  ): IAlarm {\n    return new CompositeAlarm(\n      scope,\n      operation.operationName + 'AZ' + counter + 'AggregateIsolatedImpactAlarm',\n      {\n        compositeAlarmName:\n          availabilityZoneId +\n          `-${operation.operationName.toLowerCase()}-aggregate-isolated-impact-alarm`,\n        alarmRule: AlarmRule.anyOf(serverSideAlarm, canaryAlarm),\n        actionsEnabled: false,\n      },\n    );\n  }\n\n  /**\n   * Creates a regional availability alarm for the operation\n   * @param scope\n   * @param metricDetails\n   * @param nameSuffix\n   * @param counter\n   * @returns\n   */\n  static createRegionalAvailabilityAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    nameSuffix: string,\n  ): IAlarm {\n    return new Alarm(\n      scope,\n      metricDetails.operationName + 'RegionalAvailabilityAlarm',\n      {\n        alarmName:\n          Fn.ref('AWS::Region') +\n          '-' +\n          metricDetails.operationName.toLowerCase() +\n          '-success-rate' +\n          nameSuffix,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n        comparisonOperator: ComparisonOperator.LESS_THAN_THRESHOLD,\n        threshold: metricDetails.successAlarmThreshold,\n        actionsEnabled: false,\n        treatMissingData: TreatMissingData.IGNORE,\n        metric: RegionalAvailabilityMetrics.createRegionalAvailabilityMetric({\n          label: Fn.ref('AWS::Region') + ' availability',\n          metricDetails: metricDetails,\n          metricType: AvailabilityMetricType.SUCCESS_RATE,\n        }),\n      },\n    );\n  }\n\n  /**\n   * Creates a regional latency alarm for the operation\n   * @param scope\n   * @param metricDetails\n   * @param nameSuffix\n   * @param counter\n   * @returns\n   */\n  static createRegionalLatencyAlarm(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    nameSuffix: string,\n  ): IAlarm {\n    return new Alarm(\n      scope,\n      metricDetails.operationName + 'RegionalLatencyAlarm',\n      {\n        alarmName:\n          Fn.ref('AWS::Region') +\n          '-' +\n          metricDetails.operationName.toLowerCase() +\n          '-success-latency' +\n          nameSuffix,\n        evaluationPeriods: metricDetails.evaluationPeriods,\n        datapointsToAlarm: metricDetails.datapointsToAlarm,\n        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,\n        threshold: metricDetails.successAlarmThreshold,\n        actionsEnabled: false,\n        treatMissingData: TreatMissingData.IGNORE,\n        metric: RegionalLatencyMetrics.createRegionalAverageLatencyMetric({\n          label:\n            Fn.ref('AWS::Region') +\n            ' ' +\n            metricDetails.alarmStatistic +\n            ' latency',\n          metricDetails: metricDetails,\n          metricType: LatencyMetricType.SUCCESS_LATENCY,\n          statistic: metricDetails.alarmStatistic,\n        }),\n      },\n    );\n  }\n\n  /**\n   * A composite alarm combining latency and availability alarms for this operation in the region\n   * as measured from either the server side or canary\n   * @param scope\n   * @param operation\n   * @param nameSuffix\n   * @param regionalAvailabilityAlarm\n   * @param regionalLatencyAlarm\n   * @returns\n   */\n  static createRegionalCustomerExperienceAlarm(\n    scope: Construct,\n    operationName: string,\n    nameSuffix: string,\n    regionalAvailabilityAlarm: IAlarm,\n    regionalLatencyAlarm: IAlarm,\n  ): IAlarm {\n    return new CompositeAlarm(\n      scope,\n      operationName + 'RegionalCustomerExperienceAlarm',\n      {\n        compositeAlarmName:\n          Fn.ref('AWS::Region') +\n          '-' +\n          operationName.toLowerCase() +\n          '-customer-experience-imact' +\n          nameSuffix,\n        alarmRule: AlarmRule.anyOf(\n          regionalAvailabilityAlarm,\n          regionalLatencyAlarm,\n        ),\n      },\n    );\n  }\n\n  static createRegionalInstanceContributorsToHighLatency(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    ruleDetails: IContributorInsightRuleDetails,\n  ): CfnInsightRule {\n    let ruleBody = new InsightRuleBody();\n    ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);\n    ruleBody.aggregateOn = 'Count';\n    ruleBody.logFormat = 'JSON';\n    ruleBody.contribution = {\n      keys: [ruleDetails.instanceIdJsonPath],\n      filters: [\n        {\n          Match: ruleDetails.successLatencyMetricJsonPath,\n          GreaterThan: metricDetails.successAlarmThreshold,\n        },\n        {\n          Match: ruleDetails.operationNameJsonPath,\n          In: [metricDetails.operationName],\n        },\n      ],\n    } as unknown as IContributionDefinition;\n\n    return new CfnInsightRule(scope, 'RegionPerInstanceHighLatencyRule', {\n      ruleName:\n        Fn.ref('AWS::Region') +\n        `-${metricDetails.operationName.toLowerCase()}-per-instance-high-latency-server`,\n      ruleState: 'ENABLED',\n      ruleBody: ruleBody.toJson(),\n    });\n  }\n\n  static createRegionalInstanceContributorsToFaults(\n    scope: Construct,\n    metricDetails: IOperationMetricDetails,\n    ruleDetails: IContributorInsightRuleDetails,\n  ): CfnInsightRule {\n    let ruleBody = new InsightRuleBody();\n    ruleBody.logGroupNames = ruleDetails.logGroups.map((x) => x.logGroupName);\n    ruleBody.aggregateOn = 'Count';\n    ruleBody.logFormat = 'JSON';\n    ruleBody.contribution = {\n      keys: [ruleDetails.instanceIdJsonPath],\n      filters: [\n        {\n          Match: ruleDetails.faultMetricJsonPath,\n          GreaterThan: 0,\n        },\n        {\n          Match: ruleDetails.operationNameJsonPath,\n          In: [metricDetails.operationName],\n        },\n      ],\n    } as unknown as IContributionDefinition;\n\n    return new CfnInsightRule(scope, 'RegionPerInstanceErrorRule', {\n      ruleName:\n        Fn.ref('AWS::Region') +\n        `-${metricDetails.operationName.toLowerCase()}-per-instance-faults-server`,\n      ruleState: 'ENABLED',\n      ruleBody: ruleBody.toJson(),\n    });\n  }\n}\n"]}