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

package/lib/metrics/AvailabilityAndLatencyMetrics.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityAndLatencyMetrics = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const AvailabilityMetricType_1 = require("../utilities/AvailabilityMetricType");
+const LatencyMetricType_1 = require("../utilities/LatencyMetricType");
+/**
+ * Class for creating availability and latency metrics that can be used in alarms and graphs
+ */
+class AvailabilityAndLatencyMetrics {
+    /**
+     * Increments a str by one char, for example
+     * a -> b
+     * z -> aa
+     * ad -> ae
+     *
+     * This wraps at z and adds a new 'a'
+     * @param str
+     * @returns
+     */
+    static nextChar(str) {
+        if (str.length == 0) {
+            return 'a';
+        }
+        let charA = str.split('');
+        if (charA[charA.length - 1] === 'z') {
+            return (AvailabilityAndLatencyMetrics.nextChar(str.substring(0, charA.length - 1)) + 'a');
+        }
+        else {
+            return (str.substring(0, charA.length - 1) +
+                String.fromCharCode(charA[charA.length - 1].charCodeAt(0) + 1));
+        }
+    }
+    /**
+     * General purpose method to create availability metrics
+     * @param props
+     * @param dimensions
+     * @returns
+     */
+    static createAvailabilityMetric(props, dimensions) {
+        let counter = 0;
+        let key = '';
+        let usingMetrics = {};
+        let successKeys = [];
+        let faultKeys = [];
+        if (props.metricDetails.successMetricNames !== undefined &&
+            props.metricType != AvailabilityMetricType_1.AvailabilityMetricType.FAULT_COUNT) {
+            props.metricDetails.successMetricNames.forEach((successMetric) => {
+                let keyPrefix = (props.keyPrefix === undefined || props.keyPrefix == ''
+                    ? ''
+                    : props.keyPrefix.toLowerCase() + '_') +
+                    props.metricDetails.operationName.toLowerCase() +
+                    '_' +
+                    successMetric.toLowerCase();
+                key = keyPrefix + '_' + counter++;
+                successKeys.push(key);
+                usingMetrics[key] = new aws_cloudwatch_1.Metric({
+                    namespace: props.metricDetails.metricNamespace,
+                    metricName: successMetric,
+                    unit: props.metricDetails.unit,
+                    period: props.metricDetails.period,
+                    statistic: props.metricDetails.alarmStatistic,
+                    dimensionsMap: dimensions,
+                    label: successMetric,
+                });
+            });
+        }
+        if (props.metricDetails.faultMetricNames !== undefined &&
+            props.metricType != AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_COUNT) {
+            props.metricDetails.faultMetricNames.forEach((faultMetric) => {
+                let keyPrefix = (props.keyPrefix === undefined || props.keyPrefix == ''
+                    ? ''
+                    : props.keyPrefix.toLowerCase() + '_') +
+                    props.metricDetails.operationName.toLowerCase() +
+                    '_' +
+                    faultMetric.toLowerCase();
+                key = keyPrefix + '_' + counter++;
+                faultKeys.push(key);
+                usingMetrics[key] = new aws_cloudwatch_1.Metric({
+                    namespace: props.metricDetails.metricNamespace,
+                    metricName: faultMetric,
+                    unit: props.metricDetails.unit,
+                    period: props.metricDetails.period,
+                    statistic: props.metricDetails.alarmStatistic,
+                    dimensionsMap: dimensions,
+                    label: faultMetric,
+                });
+            });
+        }
+        let expression = '';
+        switch (props.metricType) {
+            case AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_RATE:
+                expression = `((${successKeys.join('+')}) / (${successKeys.join('+')}+${faultKeys.join('+')})) * 100`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.REQUEST_COUNT:
+                expression = `${successKeys.join('+')}+${faultKeys.join('+')}`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.FAULT_COUNT:
+                expression = `(${faultKeys.join('+')})`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.FAULT_RATE:
+                expression = `((${faultKeys.join('+')}) / (${successKeys.join('+')}+${faultKeys.join('+')})) * 100`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_COUNT:
+                expression = `(${successKeys.join('+')})`;
+                break;
+        }
+        return new aws_cloudwatch_1.MathExpression({
+            expression: expression,
+            label: props.label,
+            period: props.metricDetails.period,
+            usingMetrics: usingMetrics,
+        });
+    }
+    /**
+     * General purpose method to create latency metrics, the reason this creates an array of metrics while the
+     * equivalent availability metric method doesn't is because in availability, we can just sum the count of different
+     * metric names while for latency we can't sum the count because that's not what's being measured. It allows the
+     * caller to decide if they only want to take the first name, or average all of the names
+     * (like SuccessLatency and BigItemSuccessLatency).
+     *
+     * @param props
+     * @param dimensions
+     * @returns
+     */
+    static createLatencyMetrics(props, dimensions) {
+        let names;
+        switch (props.metricType) {
+            default:
+            case LatencyMetricType_1.LatencyMetricType.SUCCESS_LATENCY:
+                names = props.metricDetails.successMetricNames;
+                break;
+            case LatencyMetricType_1.LatencyMetricType.FAULT_LATENCY:
+                names = props.metricDetails.faultMetricNames;
+                break;
+        }
+        return names.map((x) => new aws_cloudwatch_1.Metric({
+            metricName: x,
+            namespace: props.metricDetails.metricNamespace,
+            unit: props.metricDetails.unit,
+            period: props.metricDetails.period,
+            statistic: props.statistic,
+            dimensionsMap: dimensions,
+            label: props.label,
+        }));
+    }
+    /**
+     * Takes all of the success or failure latency metric names and creates an average of those
+     * names, if there's only 1 name, it just returns that metric
+     * @param props
+     * @param dimensions
+     */
+    static createAverageLatencyMetric(props, dimensions) {
+        let latencyMetrics = AvailabilityAndLatencyMetrics.createLatencyMetrics(props, dimensions);
+        if (latencyMetrics.length == 1) {
+            return latencyMetrics[0];
+        }
+        else {
+            let usingMetrics = {};
+            latencyMetrics.forEach((metric, index) => {
+                let keyPrefix = (props.keyPrefix === undefined || props.keyPrefix == ''
+                    ? ''
+                    : props.keyPrefix.toLowerCase() + '_') +
+                    props.metricDetails.operationName.toLowerCase() +
+                    '_' +
+                    props.metricType.toString().toLowerCase();
+                usingMetrics[keyPrefix + index] = metric;
+            });
+            return new aws_cloudwatch_1.MathExpression({
+                expression: `(${Object.keys(usingMetrics).join('+')})/${Object.keys(usingMetrics).length}`,
+                label: props.label,
+                period: props.metricDetails.period,
+                usingMetrics: usingMetrics,
+            });
+        }
+    }
+    /**
+     * Creates a count of high latency metrics for either SuccessLatency or FaultLatency, will total
+     * the count of requests that exceed a threshold you define in your statistic, like TC(200:) across
+     * all metric names that are part of either Success or Fault latency.
+     * @param props
+     * @returns
+     */
+    static createLatencyCountMetric(props, dimensions) {
+        let latencyMetrics = AvailabilityAndLatencyMetrics.createLatencyMetrics(props, dimensions);
+        if (latencyMetrics.length == 1) {
+            return latencyMetrics[0];
+        }
+        else {
+            let usingMetrics = {};
+            latencyMetrics.forEach((metric, index) => {
+                let keyPrefix = (props.keyPrefix === undefined || props.keyPrefix == ''
+                    ? ''
+                    : props.keyPrefix.toLowerCase() + '_') +
+                    props.metricDetails.operationName.toLowerCase() +
+                    '_' +
+                    props.metricType.toString().toLowerCase();
+                usingMetrics[keyPrefix + index] = metric;
+            });
+            return new aws_cloudwatch_1.MathExpression({
+                expression: Object.keys(usingMetrics).join('+'),
+                label: props.label,
+                period: props.metricDetails.period,
+                usingMetrics: usingMetrics,
+            });
+        }
+    }
+}
+exports.AvailabilityAndLatencyMetrics = AvailabilityAndLatencyMetrics;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AvailabilityAndLatencyMetrics.js","sourceRoot":"","sources":["../../src/metrics/AvailabilityAndLatencyMetrics.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 { IMetric, Metric, MathExpression } from 'aws-cdk-lib/aws-cloudwatch';\nimport { AvailabilityMetricProps } from './props/AvailabilityMetricProps';\nimport { LatencyMetricProps } from './props/LatencyMetricProps';\nimport { AvailabilityMetricType } from '../utilities/AvailabilityMetricType';\nimport { LatencyMetricType } from '../utilities/LatencyMetricType';\n\n/**\n * Class for creating availability and latency metrics that can be used in alarms and graphs\n */\nexport class AvailabilityAndLatencyMetrics {\n  /**\n   * Increments a str by one char, for example\n   * a -> b\n   * z -> aa\n   * ad -> ae\n   *\n   * This wraps at z and adds a new 'a'\n   * @param str\n   * @returns\n   */\n  static nextChar(str: string): string {\n    if (str.length == 0) {\n      return 'a';\n    }\n    let charA: string[] = str.split('');\n\n    if (charA[charA.length - 1] === 'z') {\n      return (\n        AvailabilityAndLatencyMetrics.nextChar(\n          str.substring(0, charA.length - 1),\n        ) + 'a'\n      );\n    } else {\n      return (\n        str.substring(0, charA.length - 1) +\n        String.fromCharCode(charA[charA.length - 1].charCodeAt(0) + 1)\n      );\n    }\n  }\n\n  /**\n   * General purpose method to create availability metrics\n   * @param props\n   * @param dimensions\n   * @returns\n   */\n  static createAvailabilityMetric(\n    props: AvailabilityMetricProps,\n    dimensions: { [key: string]: string },\n  ): IMetric {\n    let counter: number = 0;\n    let key: string = '';\n\n    let usingMetrics: { [key: string]: IMetric } = {};\n\n    let successKeys: string[] = [];\n    let faultKeys: string[] = [];\n\n    if (\n      props.metricDetails.successMetricNames !== undefined &&\n      props.metricType != AvailabilityMetricType.FAULT_COUNT\n    ) {\n      props.metricDetails.successMetricNames.forEach(\n        (successMetric: string) => {\n          let keyPrefix =\n            (props.keyPrefix === undefined || props.keyPrefix == ''\n              ? ''\n              : props.keyPrefix.toLowerCase() + '_') +\n            props.metricDetails.operationName.toLowerCase() +\n            '_' +\n            successMetric.toLowerCase();\n\n          key = keyPrefix + '_' + counter++;\n          successKeys.push(key);\n\n          usingMetrics[key] = new Metric({\n            namespace: props.metricDetails.metricNamespace,\n            metricName: successMetric,\n            unit: props.metricDetails.unit,\n            period: props.metricDetails.period,\n            statistic: props.metricDetails.alarmStatistic,\n            dimensionsMap: dimensions,\n            label: successMetric,\n          });\n        },\n      );\n    }\n\n    if (\n      props.metricDetails.faultMetricNames !== undefined &&\n      props.metricType != AvailabilityMetricType.SUCCESS_COUNT\n    ) {\n      props.metricDetails.faultMetricNames.forEach((faultMetric) => {\n        let keyPrefix =\n          (props.keyPrefix === undefined || props.keyPrefix == ''\n            ? ''\n            : props.keyPrefix.toLowerCase() + '_') +\n          props.metricDetails.operationName.toLowerCase() +\n          '_' +\n          faultMetric.toLowerCase();\n\n        key = keyPrefix + '_' + counter++;\n        faultKeys.push(key);\n\n        usingMetrics[key] = new Metric({\n          namespace: props.metricDetails.metricNamespace,\n          metricName: faultMetric,\n          unit: props.metricDetails.unit,\n          period: props.metricDetails.period,\n          statistic: props.metricDetails.alarmStatistic,\n          dimensionsMap: dimensions,\n          label: faultMetric,\n        });\n      });\n    }\n\n    let expression: string = '';\n\n    switch (props.metricType) {\n      case AvailabilityMetricType.SUCCESS_RATE:\n        expression = `((${successKeys.join('+')}) / (${successKeys.join('+')}+${faultKeys.join('+')})) * 100`;\n        break;\n      case AvailabilityMetricType.REQUEST_COUNT:\n        expression = `${successKeys.join('+')}+${faultKeys.join('+')}`;\n        break;\n      case AvailabilityMetricType.FAULT_COUNT:\n        expression = `(${faultKeys.join('+')})`;\n        break;\n      case AvailabilityMetricType.FAULT_RATE:\n        expression = `((${faultKeys.join('+')}) / (${successKeys.join('+')}+${faultKeys.join('+')})) * 100`;\n        break;\n      case AvailabilityMetricType.SUCCESS_COUNT:\n        expression = `(${successKeys.join('+')})`;\n        break;\n    }\n\n    return new MathExpression({\n      expression: expression,\n      label: props.label,\n      period: props.metricDetails.period,\n      usingMetrics: usingMetrics,\n    });\n  }\n\n  /**\n   * General purpose method to create latency metrics, the reason this creates an array of metrics while the\n   * equivalent availability metric method doesn't is because in availability, we can just sum the count of different\n   * metric names while for latency we can't sum the count because that's not what's being measured. It allows the\n   * caller to decide if they only want to take the first name, or average all of the names\n   * (like SuccessLatency and BigItemSuccessLatency).\n   *\n   * @param props\n   * @param dimensions\n   * @returns\n   */\n  static createLatencyMetrics(\n    props: LatencyMetricProps,\n    dimensions: { [key: string]: string },\n  ): IMetric[] {\n    let names: string[];\n\n    switch (props.metricType) {\n      default:\n      case LatencyMetricType.SUCCESS_LATENCY:\n        names = props.metricDetails.successMetricNames;\n        break;\n      case LatencyMetricType.FAULT_LATENCY:\n        names = props.metricDetails.faultMetricNames;\n        break;\n    }\n\n    return names.map(\n      (x) =>\n        new Metric({\n          metricName: x,\n          namespace: props.metricDetails.metricNamespace,\n          unit: props.metricDetails.unit,\n          period: props.metricDetails.period,\n          statistic: props.statistic,\n          dimensionsMap: dimensions,\n          label: props.label,\n        }),\n    );\n  }\n\n  /**\n   * Takes all of the success or failure latency metric names and creates an average of those\n   * names, if there's only 1 name, it just returns that metric\n   * @param props\n   * @param dimensions\n   */\n  static createAverageLatencyMetric(\n    props: LatencyMetricProps,\n    dimensions: { [key: string]: string },\n  ): IMetric {\n    let latencyMetrics: IMetric[] =\n      AvailabilityAndLatencyMetrics.createLatencyMetrics(props, dimensions);\n\n    if (latencyMetrics.length == 1) {\n      return latencyMetrics[0];\n    } else {\n      let usingMetrics: { [key: string]: IMetric } = {};\n\n      latencyMetrics.forEach((metric: IMetric, index: number) => {\n        let keyPrefix: string =\n          (props.keyPrefix === undefined || props.keyPrefix == ''\n            ? ''\n            : props.keyPrefix.toLowerCase() + '_') +\n          props.metricDetails.operationName.toLowerCase() +\n          '_' +\n          props.metricType.toString().toLowerCase();\n\n        usingMetrics[keyPrefix + index] = metric;\n      });\n\n      return new MathExpression({\n        expression: `(${Object.keys(usingMetrics).join('+')})/${Object.keys(usingMetrics).length}`,\n        label: props.label,\n        period: props.metricDetails.period,\n        usingMetrics: usingMetrics,\n      });\n    }\n  }\n\n  /**\n   * Creates a count of high latency metrics for either SuccessLatency or FaultLatency, will total\n   * the count of requests that exceed a threshold you define in your statistic, like TC(200:) across\n   * all metric names that are part of either Success or Fault latency.\n   * @param props\n   * @returns\n   */\n  static createLatencyCountMetric(\n    props: LatencyMetricProps,\n    dimensions: { [key: string]: string },\n  ): IMetric {\n    let latencyMetrics: IMetric[] =\n      AvailabilityAndLatencyMetrics.createLatencyMetrics(props, dimensions);\n\n    if (latencyMetrics.length == 1) {\n      return latencyMetrics[0];\n    } else {\n      let usingMetrics: { [key: string]: IMetric } = {};\n\n      latencyMetrics.forEach((metric: IMetric, index: number) => {\n        let keyPrefix: string =\n          (props.keyPrefix === undefined || props.keyPrefix == ''\n            ? ''\n            : props.keyPrefix.toLowerCase() + '_') +\n          props.metricDetails.operationName.toLowerCase() +\n          '_' +\n          props.metricType.toString().toLowerCase();\n\n        usingMetrics[keyPrefix + index] = metric;\n      });\n\n      return new MathExpression({\n        expression: Object.keys(usingMetrics).join('+'),\n        label: props.label,\n        period: props.metricDetails.period,\n        usingMetrics: usingMetrics,\n      });\n    }\n  }\n}\n"]}

package/lib/metrics/NetworkLoadBalancerMetrics.d.ts

@@ -0,0 +1,19 @@
+import { Duration } from 'aws-cdk-lib';
+import { IMetric } from 'aws-cdk-lib/aws-cloudwatch';
+export declare class NetworkLoadBalancerMetrics {
+    /**
+     * Creates a regional processed bytes metric for the specified load balancer
+     * @param loadBalancerFullName
+     * @param period
+     * @returns
+     */
+    static createRegionalNetworkLoadBalancerProcessedBytesMetric(loadBalancerFullName: string, period: Duration): IMetric;
+    /**
+     * Creates a zonal processed bytes metric for the specified load balancer
+     * @param loadBalancerFullName
+     * @param availabilityZoneName
+     * @param period
+     * @returns
+     */
+    static createZonalNetworkLoadBalancerProcessedBytesMetric(loadBalancerFullName: string, availabilityZoneName: string, period: Duration): IMetric;
+}

package/lib/metrics/NetworkLoadBalancerMetrics.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkLoadBalancerMetrics = void 0;
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+class NetworkLoadBalancerMetrics {
+    /**
+     * Creates a regional processed bytes metric for the specified load balancer
+     * @param loadBalancerFullName
+     * @param period
+     * @returns
+     */
+    static createRegionalNetworkLoadBalancerProcessedBytesMetric(loadBalancerFullName, period) {
+        return new aws_cloudwatch_1.Metric({
+            metricName: 'ProcessedBytes',
+            namespace: 'AWS/NetworkELB',
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            period: period,
+            statistic: 'Sum',
+            dimensionsMap: {
+                LoadBalancer: loadBalancerFullName,
+            },
+            label: 'ProcessedBytes',
+        });
+    }
+    /**
+     * Creates a zonal processed bytes metric for the specified load balancer
+     * @param loadBalancerFullName
+     * @param availabilityZoneName
+     * @param period
+     * @returns
+     */
+    static createZonalNetworkLoadBalancerProcessedBytesMetric(loadBalancerFullName, availabilityZoneName, period) {
+        return new aws_cloudwatch_1.Metric({
+            metricName: 'ProcessedBytes',
+            namespace: 'AWS/NetworkELB',
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            period: period,
+            statistic: 'Sum',
+            dimensionsMap: {
+                LoadBalancer: loadBalancerFullName,
+                AvailabilityZone: availabilityZoneName,
+            },
+            label: 'ProcessedBytes',
+        });
+    }
+}
+exports.NetworkLoadBalancerMetrics = NetworkLoadBalancerMetrics;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/metrics/RegionalAvailabilityMetrics.d.ts

@@ -0,0 +1,19 @@
+import { IMetric } from 'aws-cdk-lib/aws-cloudwatch';
+import { RegionalAvailabilityMetricProps } from './props/RegionalAvailabilityMetricProps';
+import { ServiceAvailabilityMetricProps } from './props/ServiceAvailabilityMetricProps';
+export declare class RegionalAvailabilityMetrics {
+    /**
+     * Creates a regional availability metric
+     * @param props
+     * @returns
+     */
+    static createRegionalAvailabilityMetric(props: RegionalAvailabilityMetricProps): IMetric;
+    /**
+     * Creates a regional service level availability metrics, one metric for
+     * each operation at the regional level and the service.
+     * @param props
+     * @returns The metric at index 0 is the metric math expression for the whole service. The following metrics
+     * are the metrics for each operation included in the request availability metric props.
+     */
+    static createRegionalServiceAvailabilityMetrics(props: ServiceAvailabilityMetricProps): IMetric[];
+}

package/lib/metrics/RegionalAvailabilityMetrics.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionalAvailabilityMetrics = 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 AvailabilityAndLatencyMetrics_1 = require("./AvailabilityAndLatencyMetrics");
+const AvailabilityMetricType_1 = require("../utilities/AvailabilityMetricType");
+class RegionalAvailabilityMetrics {
+    /**
+     * Creates a regional availability metric
+     * @param props
+     * @returns
+     */
+    static createRegionalAvailabilityMetric(props) {
+        return AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.createAvailabilityMetric(props, props.metricDetails.metricDimensions.regionalDimensions(aws_cdk_lib_1.Fn.ref('AWS::Region')));
+    }
+    /**
+     * Creates a regional service level availability metrics, one metric for
+     * each operation at the regional level and the service.
+     * @param props
+     * @returns The metric at index 0 is the metric math expression for the whole service. The following metrics
+     * are the metrics for each operation included in the request availability metric props.
+     */
+    static createRegionalServiceAvailabilityMetrics(props) {
+        let usingMetrics = {};
+        let operationMetrics = [];
+        let counter = 0;
+        props.availabilityMetricProps.forEach((prop) => {
+            let keyPrefix = (prop.keyPrefix === undefined || prop.keyPrefix == ''
+                ? ''
+                : prop.keyPrefix.toLowerCase() + '_') +
+                prop.metricDetails.operationName.toLowerCase() +
+                '_' +
+                prop.metricType.toString().toLowerCase();
+            let regionalOperationAvailabilityMetric = this.createRegionalAvailabilityMetric(prop);
+            operationMetrics.push(regionalOperationAvailabilityMetric);
+            usingMetrics[`${keyPrefix}${counter++}`] =
+                regionalOperationAvailabilityMetric;
+        });
+        let expression = '';
+        switch (props.availabilityMetricProps[0].metricType) {
+            case AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_RATE:
+                expression = `(${Object.keys(usingMetrics).join('+')}) / ${props.availabilityMetricProps.length}`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.REQUEST_COUNT:
+                expression = `${Object.keys(usingMetrics).join('+')}`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.FAULT_COUNT:
+                expression = `${Object.keys(usingMetrics).join('+')}`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.FAULT_RATE:
+                expression = `(${Object.keys(usingMetrics).join('+')}) / ${props.availabilityMetricProps.length}`;
+                break;
+            case AvailabilityMetricType_1.AvailabilityMetricType.SUCCESS_COUNT:
+                expression = `${Object.keys(usingMetrics).join('+')}`;
+                break;
+        }
+        let math = new aws_cloudwatch_1.MathExpression({
+            usingMetrics: usingMetrics,
+            period: props.period,
+            label: props.label,
+            expression: expression,
+        });
+        operationMetrics.splice(0, 0, math);
+        return operationMetrics;
+    }
+}
+exports.RegionalAvailabilityMetrics = RegionalAvailabilityMetrics;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/metrics/RegionalLatencyMetrics.d.ts

@@ -0,0 +1,33 @@
+import { IMetric } from 'aws-cdk-lib/aws-cloudwatch';
+import { RegionalLatencyMetricProps } from './props/RegionalLatencyMetricProps';
+import { ServiceLatencyMetricProps } from './props/ServiceLatencyMericProps';
+export declare class RegionalLatencyMetrics {
+    /**
+     * Creates a metrics for regional latency, one metric per metric name for the
+     * specified type of latency metric. You will need to perform some aggregation
+     * of these metrics if there is more than 1 metric name that correponds to
+     * SuccessLatency or FaultLatency, like doing an average.
+     * @param props
+     * @returns
+     */
+    static createRegionalLatencyMetrics(props: RegionalLatencyMetricProps): IMetric[];
+    /**
+     * Creates a regional average latency metric, averages the values from all of the
+     * metric names that represent either SuccessLatency or FaultLatency
+     * @param props
+     * @returns
+     */
+    static createRegionalAverageLatencyMetric(props: RegionalLatencyMetricProps): IMetric;
+    /**
+     * Creates a count of high latency metrics for either SuccessLatency or FaultLatency
+     * @param props
+     * @returns
+     */
+    static createRegionalLatencyCountMetric(props: RegionalLatencyMetricProps): IMetric;
+    /**
+     * Creates a count of high latency responses for all critical operations
+     * @param props
+     * @returns
+     */
+    static createRegionalServiceLatencyCountMetrics(props: ServiceLatencyMetricProps): IMetric[];
+}

package/lib/metrics/RegionalLatencyMetrics.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionalLatencyMetrics = 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 AvailabilityAndLatencyMetrics_1 = require("./AvailabilityAndLatencyMetrics");
+class RegionalLatencyMetrics {
+    /**
+     * Creates a metrics for regional latency, one metric per metric name for the
+     * specified type of latency metric. You will need to perform some aggregation
+     * of these metrics if there is more than 1 metric name that correponds to
+     * SuccessLatency or FaultLatency, like doing an average.
+     * @param props
+     * @returns
+     */
+    static createRegionalLatencyMetrics(props) {
+        return AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.createLatencyMetrics(props, props.metricDetails.metricDimensions.regionalDimensions(aws_cdk_lib_1.Fn.ref('AWS::Region')));
+    }
+    /**
+     * Creates a regional average latency metric, averages the values from all of the
+     * metric names that represent either SuccessLatency or FaultLatency
+     * @param props
+     * @returns
+     */
+    static createRegionalAverageLatencyMetric(props) {
+        return AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.createAverageLatencyMetric(props, props.metricDetails.metricDimensions.regionalDimensions(aws_cdk_lib_1.Fn.ref('AWS::Region')));
+    }
+    /**
+     * Creates a count of high latency metrics for either SuccessLatency or FaultLatency
+     * @param props
+     * @returns
+     */
+    static createRegionalLatencyCountMetric(props) {
+        return AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.createLatencyCountMetric(props, props.metricDetails.metricDimensions.regionalDimensions(aws_cdk_lib_1.Fn.ref('AWS::Region')));
+    }
+    /**
+     * Creates a count of high latency responses for all critical operations
+     * @param props
+     * @returns
+     */
+    static createRegionalServiceLatencyCountMetrics(props) {
+        let usingMetrics = {};
+        let operationMetrics = [];
+        let keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar('');
+        props.latencyMetricProps.forEach((prop, index) => {
+            let operationRegionalMetric = this.createRegionalLatencyCountMetric(prop);
+            operationMetrics.push(operationRegionalMetric);
+            usingMetrics[`${keyPrefix}${index}`] = operationRegionalMetric;
+            keyPrefix = AvailabilityAndLatencyMetrics_1.AvailabilityAndLatencyMetrics.nextChar(keyPrefix);
+        });
+        if (Object.keys(usingMetrics).length == 1) {
+            operationMetrics.push(Object.values(usingMetrics)[0]);
+        }
+        else {
+            let math = new aws_cloudwatch_1.MathExpression({
+                usingMetrics: usingMetrics,
+                period: props.period,
+                label: props.label,
+                expression: Object.keys(usingMetrics).join('+'),
+            });
+            operationMetrics.splice(0, 0, math);
+        }
+        return operationMetrics;
+    }
+}
+exports.RegionalLatencyMetrics = RegionalLatencyMetrics;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/metrics/ZonalAvailabilityMetrics.d.ts

@@ -0,0 +1,19 @@
+import { IMetric } from 'aws-cdk-lib/aws-cloudwatch';
+import { ServiceAvailabilityMetricProps } from './props/ServiceAvailabilityMetricProps';
+import { ZonalAvailabilityMetricProps } from './props/ZonalAvailabilityMetricProps';
+export declare class ZonalAvailabilityMetrics {
+    /**
+     * Creates a zonal service level availability metrics, one metric for
+     * each operation at the zonal level and the service.
+     * @param props
+     * @returns The metric at index 0 is the metric math expression for the whole service. The following metrics
+     * are the metrics for each operation included in the request availability metric props.
+     */
+    static createZonalServiceAvailabilityMetrics(props: ServiceAvailabilityMetricProps): IMetric[];
+    /**
+     * Creates a zonal availability metric
+     * @param props
+     * @returns
+     */
+    static createZonalAvailabilityMetric(props: ZonalAvailabilityMetricProps): IMetric;
+}