terraconstructs 0.0.8

package/lib/aws/cloudwatch/alarm.js

@@ -0,0 +1,410 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alarm = exports.TreatMissingData = exports.ComparisonOperator = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/alarm.ts
+// TODO: use https://registry.terraform.io/providers/hashicorp/awscc/latest/docs/resources/cloudwatch_alarm
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_stack_1 = require("../aws-stack");
+const alarm_base_1 = require("./alarm-base");
+const metric_util_1 = require("./private/metric-util");
+const object_1 = require("./private/object");
+const rendering_1 = require("./private/rendering");
+const statistic_1 = require("./private/statistic");
+/**
+ * Comparison operator for evaluating alarms
+ */
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    /**
+     * Specified statistic is greater than or equal to the threshold
+     */
+    ComparisonOperator["GREATER_THAN_OR_EQUAL_TO_THRESHOLD"] = "GreaterThanOrEqualToThreshold";
+    /**
+     * Specified statistic is strictly greater than the threshold
+     */
+    ComparisonOperator["GREATER_THAN_THRESHOLD"] = "GreaterThanThreshold";
+    /**
+     * Specified statistic is strictly less than the threshold
+     */
+    ComparisonOperator["LESS_THAN_THRESHOLD"] = "LessThanThreshold";
+    /**
+     * Specified statistic is less than or equal to the threshold.
+     */
+    ComparisonOperator["LESS_THAN_OR_EQUAL_TO_THRESHOLD"] = "LessThanOrEqualToThreshold";
+    /**
+     * Specified statistic is lower than or greater than the anomaly model band.
+     * Used only for alarms based on anomaly detection models
+     */
+    ComparisonOperator["LESS_THAN_LOWER_OR_GREATER_THAN_UPPER_THRESHOLD"] = "LessThanLowerOrGreaterThanUpperThreshold";
+    /**
+     * Specified statistic is greater than the anomaly model band.
+     * Used only for alarms based on anomaly detection models
+     */
+    ComparisonOperator["GREATER_THAN_UPPER_THRESHOLD"] = "GreaterThanUpperThreshold";
+    /**
+     * Specified statistic is lower than the anomaly model band.
+     * Used only for alarms based on anomaly detection models
+     */
+    ComparisonOperator["LESS_THAN_LOWER_THRESHOLD"] = "LessThanLowerThreshold";
+})(ComparisonOperator || (exports.ComparisonOperator = ComparisonOperator = {}));
+const OPERATOR_SYMBOLS = {
+    GreaterThanOrEqualToThreshold: ">=",
+    GreaterThanThreshold: ">",
+    LessThanThreshold: "<",
+    LessThanOrEqualToThreshold: "<=",
+};
+/**
+ * Specify how missing data points are treated during alarm evaluation
+ */
+var TreatMissingData;
+(function (TreatMissingData) {
+    /**
+     * Missing data points are treated as breaching the threshold
+     */
+    TreatMissingData["BREACHING"] = "breaching";
+    /**
+     * Missing data points are treated as being within the threshold
+     */
+    TreatMissingData["NOT_BREACHING"] = "notBreaching";
+    /**
+     * The current alarm state is maintained
+     */
+    TreatMissingData["IGNORE"] = "ignore";
+    /**
+     * The alarm does not consider missing data points when evaluating whether to change state
+     */
+    TreatMissingData["MISSING"] = "missing";
+})(TreatMissingData || (exports.TreatMissingData = TreatMissingData = {}));
+/**
+ * An alarm on a CloudWatch metric
+ */
+class Alarm extends alarm_base_1.AlarmBase {
+    /**
+     * Import an existing CloudWatch alarm provided an Name.
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param alarmName Alarm Name
+     */
+    static fromAlarmName(scope, id, alarmName) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        return this.fromAlarmArn(scope, id, stack.formatArn({
+            service: "cloudwatch",
+            resource: "alarm",
+            resourceName: alarmName,
+            arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+        }));
+    }
+    /**
+     * Import an existing CloudWatch alarm provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name
+     * @param alarmArn Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:Foo)
+     */
+    static fromAlarmArn(scope, id, alarmArn) {
+        class Import extends alarm_base_1.AlarmBase {
+            constructor() {
+                super(...arguments);
+                this.alarmArn = alarmArn;
+                this.alarmName = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(alarmArn, arn_1.ArnFormat.COLON_RESOURCE_NAME).resourceName;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const alarmName = props.alarmName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                maxLength: 255,
+            });
+        const comparisonOperator = props.comparisonOperator ||
+            ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD;
+        // Render metric, process potential overrides from the alarm
+        // (It would be preferable if the statistic etc. was worked into the metric,
+        // but hey we're allowing overrides...)
+        const metricProps = this.renderMetric(props.metric);
+        if (props.period) {
+            metricProps.period = props.period.toSeconds();
+        }
+        if (props.statistic) {
+            // Will overwrite both fields if present
+            Object.assign(metricProps, {
+                statistic: renderIfSimpleStatistic(props.statistic),
+                extendedStatistic: renderIfExtendedStatistic(props.statistic),
+            });
+        }
+        this.resource = new provider_aws_1.cloudwatchMetricAlarm.CloudwatchMetricAlarm(this, "Resource", {
+            alarmName,
+            // Meta
+            alarmDescription: props.alarmDescription,
+            // Evaluation
+            comparisonOperator,
+            threshold: props.threshold,
+            datapointsToAlarm: props.datapointsToAlarm,
+            evaluateLowSampleCountPercentiles: props.evaluateLowSampleCountPercentile,
+            evaluationPeriods: props.evaluationPeriods,
+            treatMissingData: props.treatMissingData,
+            // Actions
+            actionsEnabled: props.actionsEnabled,
+            alarmActions: cdktf_1.Lazy.listValue({ produce: () => this.alarmActionArns }),
+            insufficientDataActions: cdktf_1.Lazy.listValue({
+                produce: () => this.insufficientDataActionArns,
+            }),
+            okActions: cdktf_1.Lazy.listValue({ produce: () => this.okActionArns }),
+            // Metric
+            ...metricProps,
+        });
+        this.alarmArn = this.resource.arn;
+        this.alarmName = this.resource.id;
+        this.metric = props.metric;
+        const datapoints = props.datapointsToAlarm || props.evaluationPeriods;
+        this.annotation = {
+            // eslint-disable-next-line max-len
+            label: `${this.metric} ${OPERATOR_SYMBOLS[comparisonOperator]} ${props.threshold} for ${datapoints} datapoints within ${describePeriod(props.evaluationPeriods * (0, metric_util_1.metricPeriod)(props.metric).toSeconds())}`,
+            value: props.threshold,
+        };
+        for (const [_, message] of Object.entries(this.metric.warningsV2 ?? {})) {
+            cdktf_1.Annotations.of(this).addWarning(message);
+        }
+    }
+    /**
+     * Turn this alarm into a horizontal annotation
+     *
+     * This is useful if you want to represent an Alarm in a non-AlarmWidget.
+     * An `AlarmWidget` can directly show an alarm, but it can only show a
+     * single alarm and no other metrics. Instead, you can convert the alarm to
+     * a HorizontalAnnotation and add it as an annotation to another graph.
+     *
+     * This might be useful if:
+     *
+     * - You want to show multiple alarms inside a single graph, for example if
+     *   you have both a "small margin/long period" alarm as well as a
+     *   "large margin/short period" alarm.
+     *
+     * - You want to show an Alarm line in a graph with multiple metrics in it.
+     */
+    toAnnotation() {
+        return this.annotation;
+    }
+    /**
+     * Trigger this action if the alarm fires
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addAlarmAction(...actions) {
+        if (this.alarmActionArns === undefined) {
+            this.alarmActionArns = [];
+        }
+        this.alarmActionArns.push(...actions.map((a) => this.validateActionArn(a.bind(this, this).alarmActionArn)));
+    }
+    validateActionArn(actionArn) {
+        // ref: https://github.com/aws/aws-cdk/pull/20224/files
+        const ec2ActionsRegexp = /arn:aws[a-z0-9-]*:automate:[a-z|\d|-]+:ec2:[a-z]+/;
+        let requiresPerInstanceMetric = false;
+        if (cdktf_1.Token.isUnresolved(actionArn)) {
+            requiresPerInstanceMetric =
+                actionArn.startsWith("arn:") &&
+                    actionArn.includes(":automate:") &&
+                    actionArn.includes(":ec2:");
+        }
+        else {
+            requiresPerInstanceMetric = ec2ActionsRegexp.test(actionArn);
+        }
+        if (requiresPerInstanceMetric) {
+            const metricConfig = this.metric.toMetricConfig();
+            const dimensions = metricConfig.metricStat?.dimensions;
+            if (!dimensions ||
+                Object.keys(dimensions).length !== 1 ||
+                !("InstanceId" in dimensions)) {
+                throw new Error(`EC2 alarm actions requires an EC2 Per-Instance Metric. (${JSON.stringify(metricConfig)} does not have an 'InstanceId' dimension)`);
+            }
+        }
+        return actionArn;
+    }
+    renderMetric(metric) {
+        const self = this;
+        return (0, metric_util_1.dispatchMetric)(metric, {
+            withStat(stat, conf) {
+                self.validateMetricStat(stat, metric);
+                const canRenderAsLegacyMetric = conf.renderingProperties?.label == undefined &&
+                    !self.requiresAccountId(stat);
+                // Do this to disturb existing templates as little as possible
+                if (canRenderAsLegacyMetric) {
+                    return (0, object_1.dropUndefined)({
+                        dimensions: stat.dimensions,
+                        namespace: stat.namespace,
+                        metricName: stat.metricName,
+                        period: stat.period?.toSeconds(),
+                        statistic: renderIfSimpleStatistic(stat.statistic),
+                        extendedStatistic: renderIfExtendedStatistic(stat.statistic),
+                        unit: stat.unitFilter,
+                    });
+                }
+                return {
+                    metricQuery: [
+                        {
+                            metric: {
+                                metricName: stat.metricName,
+                                namespace: stat.namespace,
+                                dimensions: stat.dimensions,
+                                period: stat.period.toSeconds(),
+                                stat: stat.statistic,
+                            },
+                            unit: stat.unitFilter,
+                            id: "m1",
+                            accountId: self.requiresAccountId(stat)
+                                ? stat.account
+                                : undefined,
+                            label: conf.renderingProperties?.label,
+                            returnData: true,
+                        },
+                    ],
+                };
+            },
+            withExpression() {
+                // Expand the math expression metric into a set
+                const mset = new rendering_1.MetricSet();
+                mset.addTopLevel(true, metric);
+                let eid = 0;
+                function uniqueMetricId() {
+                    return `expr_${++eid}`;
+                }
+                return {
+                    metricQuery: mset.entries.map((entry) => (0, metric_util_1.dispatchMetric)(entry.metric, {
+                        withStat(stat, conf) {
+                            self.validateMetricStat(stat, entry.metric);
+                            return {
+                                metric: {
+                                    metricName: stat.metricName,
+                                    namespace: stat.namespace,
+                                    dimensions: stat.dimensions,
+                                    period: stat.period.toSeconds(),
+                                    stat: stat.statistic,
+                                },
+                                unit: stat.unitFilter,
+                                id: entry.id || uniqueMetricId(),
+                                accountId: self.requiresAccountId(stat)
+                                    ? stat.account
+                                    : undefined,
+                                label: conf.renderingProperties?.label,
+                                returnData: entry.tag ? undefined : false, // entry.tag evaluates to true if the metric is the math expression the alarm is based on.
+                            };
+                        },
+                        withExpression(expr, conf) {
+                            const hasSubmetrics = mathExprHasSubmetrics(expr);
+                            if (hasSubmetrics) {
+                                assertSubmetricsCount(expr);
+                            }
+                            self.validateMetricExpression(expr);
+                            return {
+                                expression: expr.expression,
+                                id: entry.id || uniqueMetricId(),
+                                label: conf.renderingProperties?.label,
+                                period: hasSubmetrics ? undefined : expr.period,
+                                returnData: entry.tag ? undefined : false, // entry.tag evaluates to true if the metric is the math expression the alarm is based on.
+                            };
+                        },
+                    })),
+                };
+            },
+        });
+    }
+    /**
+     * Validate that if a region is in the given stat config, they match the Alarm
+     */
+    validateMetricStat(stat, metric) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        if (definitelyDifferent(stat.region, stack.region)) {
+            throw new Error(`Cannot create an Alarm in region '${stack.region}' based on metric '${metric}' in '${stat.region}'`);
+        }
+    }
+    /**
+     * Validates that the expression config does not specify searchAccount or searchRegion props
+     * as search expressions are not supported by Alarms.
+     */
+    validateMetricExpression(expr) {
+        if (expr.searchAccount !== undefined || expr.searchRegion !== undefined) {
+            throw new Error("Cannot create an Alarm based on a MathExpression which specifies a searchAccount or searchRegion");
+        }
+    }
+    /**
+     * Determine if the accountId property should be included in the metric.
+     */
+    requiresAccountId(stat) {
+        const stackAccount = aws_stack_1.AwsStack.ofAwsConstruct(this).account;
+        // if stat.account is undefined, it's by definition in the same account
+        if (stat.account === undefined) {
+            return false;
+        }
+        // Return true if they're different. The ACCOUNT_ID token is interned
+        // so will always have the same string value (and even if we guess wrong
+        // it will still work).
+        return stackAccount !== stat.account;
+    }
+}
+exports.Alarm = Alarm;
+_a = JSII_RTTI_SYMBOL_1;
+Alarm[_a] = { fqn: "terraconstructs.aws.cloudwatch.Alarm", version: "0.0.8" };
+function definitelyDifferent(x, y) {
+    return x && !cdktf_1.Token.isUnresolved(y) && x !== y;
+}
+/**
+ * Return a human readable string for this period
+ *
+ * We know the seconds are always one of a handful of allowed values.
+ */
+function describePeriod(seconds) {
+    if (seconds === 60) {
+        return "1 minute";
+    }
+    if (seconds === 1) {
+        return "1 second";
+    }
+    if (seconds > 60) {
+        return seconds / 60 + " minutes";
+    }
+    return seconds + " seconds";
+}
+function renderIfSimpleStatistic(statistic) {
+    if (statistic === undefined) {
+        return undefined;
+    }
+    const parsed = (0, statistic_1.parseStatistic)(statistic);
+    if (parsed.type === "simple") {
+        return (0, statistic_1.normalizeStatistic)(parsed);
+    }
+    return undefined;
+}
+function renderIfExtendedStatistic(statistic) {
+    if (statistic === undefined) {
+        return undefined;
+    }
+    const parsed = (0, statistic_1.parseStatistic)(statistic);
+    if (parsed.type === "simple") {
+        // This statistic will have been rendered by renderIfSimpleStatistic
+        return undefined;
+    }
+    if (parsed.type === "single" || parsed.type === "pair") {
+        return (0, statistic_1.normalizeStatistic)(parsed);
+    }
+    // We can't not render anything here. Just put whatever we got as input into
+    // the ExtendedStatistic and hope it's correct. Either that, or we throw
+    // an error.
+    return parsed.statistic;
+}
+function mathExprHasSubmetrics(expr) {
+    return Object.keys(expr.usingMetrics).length > 0;
+}
+function assertSubmetricsCount(expr) {
+    if (Object.keys(expr.usingMetrics).length > 10) {
+        // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-on-metric-math-expressions
+        throw new Error("Alarms on math expressions cannot contain more than 10 individual metrics");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alarm.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/alarm.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/alarm.ts\n\n// TODO: use https://registry.terraform.io/providers/hashicorp/awscc/latest/docs/resources/cloudwatch_alarm\nimport { cloudwatchMetricAlarm } from \"@cdktf/provider-aws\";\nimport { Lazy, Token, Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IAlarmAction } from \"./alarm-action\";\nimport { AlarmBase, IAlarm } from \"./alarm-base\";\nimport { HorizontalAnnotation } from \"./graph\";\nimport { CreateAlarmOptions } from \"./metric\";\nimport {\n  IMetric,\n  MetricExpressionConfig,\n  MetricStatConfig,\n} from \"./metric-types\";\nimport { dispatchMetric, metricPeriod } from \"./private/metric-util\";\nimport { dropUndefined } from \"./private/object\";\nimport { MetricSet } from \"./private/rendering\";\nimport { normalizeStatistic, parseStatistic } from \"./private/statistic\";\n\n/**\n * Properties for Alarms\n */\nexport interface AlarmProps extends CreateAlarmOptions, AwsConstructProps {\n  /**\n   * The metric to add the alarm on\n   *\n   * Metric objects can be obtained from most resources, or you can construct\n   * custom Metric objects by instantiating one.\n   */\n  readonly metric: IMetric;\n}\n\n/**\n * Comparison operator for evaluating alarms\n */\nexport enum ComparisonOperator {\n  /**\n   * Specified statistic is greater than or equal to the threshold\n   */\n  GREATER_THAN_OR_EQUAL_TO_THRESHOLD = \"GreaterThanOrEqualToThreshold\",\n\n  /**\n   * Specified statistic is strictly greater than the threshold\n   */\n  GREATER_THAN_THRESHOLD = \"GreaterThanThreshold\",\n\n  /**\n   * Specified statistic is strictly less than the threshold\n   */\n  LESS_THAN_THRESHOLD = \"LessThanThreshold\",\n\n  /**\n   * Specified statistic is less than or equal to the threshold.\n   */\n  LESS_THAN_OR_EQUAL_TO_THRESHOLD = \"LessThanOrEqualToThreshold\",\n\n  /**\n   * Specified statistic is lower than or greater than the anomaly model band.\n   * Used only for alarms based on anomaly detection models\n   */\n  LESS_THAN_LOWER_OR_GREATER_THAN_UPPER_THRESHOLD = \"LessThanLowerOrGreaterThanUpperThreshold\",\n\n  /**\n   * Specified statistic is greater than the anomaly model band.\n   * Used only for alarms based on anomaly detection models\n   */\n  GREATER_THAN_UPPER_THRESHOLD = \"GreaterThanUpperThreshold\",\n\n  /**\n   * Specified statistic is lower than the anomaly model band.\n   * Used only for alarms based on anomaly detection models\n   */\n  LESS_THAN_LOWER_THRESHOLD = \"LessThanLowerThreshold\",\n}\n\nconst OPERATOR_SYMBOLS: { [key: string]: string } = {\n  GreaterThanOrEqualToThreshold: \">=\",\n  GreaterThanThreshold: \">\",\n  LessThanThreshold: \"<\",\n  LessThanOrEqualToThreshold: \"<=\",\n};\n\n/**\n * Specify how missing data points are treated during alarm evaluation\n */\nexport enum TreatMissingData {\n  /**\n   * Missing data points are treated as breaching the threshold\n   */\n  BREACHING = \"breaching\",\n\n  /**\n   * Missing data points are treated as being within the threshold\n   */\n  NOT_BREACHING = \"notBreaching\",\n\n  /**\n   * The current alarm state is maintained\n   */\n  IGNORE = \"ignore\",\n\n  /**\n   * The alarm does not consider missing data points when evaluating whether to change state\n   */\n  MISSING = \"missing\",\n}\n\n/**\n * An alarm on a CloudWatch metric\n */\nexport class Alarm extends AlarmBase {\n  /**\n   * Import an existing CloudWatch alarm provided an Name.\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param alarmName Alarm Name\n   */\n  public static fromAlarmName(\n    scope: Construct,\n    id: string,\n    alarmName: string,\n  ): IAlarm {\n    const stack = AwsStack.ofAwsConstruct(scope);\n\n    return this.fromAlarmArn(\n      scope,\n      id,\n      stack.formatArn({\n        service: \"cloudwatch\",\n        resource: \"alarm\",\n        resourceName: alarmName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n    );\n  }\n\n  /**\n   * Import an existing CloudWatch alarm provided an ARN\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name\n   * @param alarmArn Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:Foo)\n   */\n  public static fromAlarmArn(\n    scope: Construct,\n    id: string,\n    alarmArn: string,\n  ): IAlarm {\n    class Import extends AlarmBase implements IAlarm {\n      public readonly alarmArn = alarmArn;\n      public readonly alarmName = AwsStack.ofAwsConstruct(scope).splitArn(\n        alarmArn,\n        ArnFormat.COLON_RESOURCE_NAME,\n      ).resourceName!;\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly resource: cloudwatchMetricAlarm.CloudwatchMetricAlarm;\n\n  /**\n   * ARN of this alarm\n   *\n   * @attribute\n   */\n  public readonly alarmArn: string;\n\n  /**\n   * Name of this alarm.\n   *\n   * @attribute\n   */\n  public readonly alarmName: string;\n\n  /**\n   * The metric object this alarm was based on\n   */\n  public readonly metric: IMetric;\n\n  /**\n   * This metric as an annotation\n   */\n  private readonly annotation: HorizontalAnnotation;\n\n  constructor(scope: Construct, id: string, props: AlarmProps) {\n    super(scope, id, props);\n\n    const alarmName =\n      props.alarmName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 255,\n      });\n\n    const comparisonOperator =\n      props.comparisonOperator ||\n      ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD;\n\n    // Render metric, process potential overrides from the alarm\n    // (It would be preferable if the statistic etc. was worked into the metric,\n    // but hey we're allowing overrides...)\n    const metricProps: Writeable<\n      Partial<cloudwatchMetricAlarm.CloudwatchMetricAlarmConfig>\n    > = this.renderMetric(props.metric);\n    if (props.period) {\n      metricProps.period = props.period.toSeconds();\n    }\n    if (props.statistic) {\n      // Will overwrite both fields if present\n      Object.assign(metricProps, {\n        statistic: renderIfSimpleStatistic(props.statistic),\n        extendedStatistic: renderIfExtendedStatistic(props.statistic),\n      });\n    }\n\n    this.resource = new cloudwatchMetricAlarm.CloudwatchMetricAlarm(\n      this,\n      \"Resource\",\n      {\n        alarmName,\n        // Meta\n        alarmDescription: props.alarmDescription,\n\n        // Evaluation\n        comparisonOperator,\n        threshold: props.threshold,\n        datapointsToAlarm: props.datapointsToAlarm,\n        evaluateLowSampleCountPercentiles:\n          props.evaluateLowSampleCountPercentile,\n        evaluationPeriods: props.evaluationPeriods,\n        treatMissingData: props.treatMissingData,\n\n        // Actions\n        actionsEnabled: props.actionsEnabled,\n        alarmActions: Lazy.listValue({ produce: () => this.alarmActionArns }),\n        insufficientDataActions: Lazy.listValue({\n          produce: () => this.insufficientDataActionArns,\n        }),\n        okActions: Lazy.listValue({ produce: () => this.okActionArns }),\n\n        // Metric\n        ...metricProps,\n      },\n    );\n\n    this.alarmArn = this.resource.arn;\n    this.alarmName = this.resource.id;\n\n    this.metric = props.metric;\n    const datapoints = props.datapointsToAlarm || props.evaluationPeriods;\n    this.annotation = {\n      // eslint-disable-next-line max-len\n      label: `${this.metric} ${OPERATOR_SYMBOLS[comparisonOperator]} ${props.threshold} for ${datapoints} datapoints within ${describePeriod(props.evaluationPeriods * metricPeriod(props.metric).toSeconds())}`,\n      value: props.threshold,\n    };\n\n    for (const [_, message] of Object.entries(this.metric.warningsV2 ?? {})) {\n      Annotations.of(this).addWarning(message);\n    }\n  }\n\n  /**\n   * Turn this alarm into a horizontal annotation\n   *\n   * This is useful if you want to represent an Alarm in a non-AlarmWidget.\n   * An `AlarmWidget` can directly show an alarm, but it can only show a\n   * single alarm and no other metrics. Instead, you can convert the alarm to\n   * a HorizontalAnnotation and add it as an annotation to another graph.\n   *\n   * This might be useful if:\n   *\n   * - You want to show multiple alarms inside a single graph, for example if\n   *   you have both a \"small margin/long period\" alarm as well as a\n   *   \"large margin/short period\" alarm.\n   *\n   * - You want to show an Alarm line in a graph with multiple metrics in it.\n   */\n  public toAnnotation(): HorizontalAnnotation {\n    return this.annotation;\n  }\n\n  /**\n   * Trigger this action if the alarm fires\n   *\n   * Typically SnsAction or AutoScalingAction.\n   */\n  public addAlarmAction(...actions: IAlarmAction[]) {\n    if (this.alarmActionArns === undefined) {\n      this.alarmActionArns = [];\n    }\n\n    this.alarmActionArns.push(\n      ...actions.map((a) =>\n        this.validateActionArn(a.bind(this, this).alarmActionArn),\n      ),\n    );\n  }\n\n  private validateActionArn(actionArn: string): string {\n    // ref: https://github.com/aws/aws-cdk/pull/20224/files\n    const ec2ActionsRegexp: RegExp =\n      /arn:aws[a-z0-9-]*:automate:[a-z|\\d|-]+:ec2:[a-z]+/;\n    let requiresPerInstanceMetric: boolean = false;\n    if (Token.isUnresolved(actionArn)) {\n      requiresPerInstanceMetric =\n        actionArn.startsWith(\"arn:\") &&\n        actionArn.includes(\":automate:\") &&\n        actionArn.includes(\":ec2:\");\n    } else {\n      requiresPerInstanceMetric = ec2ActionsRegexp.test(actionArn);\n    }\n    if (requiresPerInstanceMetric) {\n      const metricConfig = this.metric.toMetricConfig();\n      const dimensions = metricConfig.metricStat?.dimensions;\n\n      if (\n        !dimensions ||\n        Object.keys(dimensions).length !== 1 ||\n        !(\"InstanceId\" in dimensions)\n      ) {\n        throw new Error(\n          `EC2 alarm actions requires an EC2 Per-Instance Metric. (${JSON.stringify(metricConfig)} does not have an 'InstanceId' dimension)`,\n        );\n      }\n    }\n    return actionArn;\n  }\n\n  private renderMetric(\n    metric: IMetric,\n  ): Writeable<Partial<cloudwatchMetricAlarm.CloudwatchMetricAlarmConfig>> {\n    const self = this;\n    return dispatchMetric(metric, {\n      withStat(stat, conf) {\n        self.validateMetricStat(stat, metric);\n        const canRenderAsLegacyMetric =\n          conf.renderingProperties?.label == undefined &&\n          !self.requiresAccountId(stat);\n        // Do this to disturb existing templates as little as possible\n        if (canRenderAsLegacyMetric) {\n          return dropUndefined({\n            dimensions: stat.dimensions,\n            namespace: stat.namespace,\n            metricName: stat.metricName,\n            period: stat.period?.toSeconds(),\n            statistic: renderIfSimpleStatistic(stat.statistic),\n            extendedStatistic: renderIfExtendedStatistic(stat.statistic),\n            unit: stat.unitFilter,\n          });\n        }\n\n        return {\n          metricQuery: [\n            {\n              metric: {\n                metricName: stat.metricName,\n                namespace: stat.namespace,\n                dimensions: stat.dimensions,\n                period: stat.period.toSeconds(),\n                stat: stat.statistic,\n              },\n              unit: stat.unitFilter,\n              id: \"m1\",\n              accountId: self.requiresAccountId(stat)\n                ? stat.account\n                : undefined,\n              label: conf.renderingProperties?.label,\n              returnData: true,\n            } as cloudwatchMetricAlarm.CloudwatchMetricAlarmMetricQuery,\n          ],\n        };\n      },\n\n      withExpression() {\n        // Expand the math expression metric into a set\n        const mset = new MetricSet<boolean>();\n        mset.addTopLevel(true, metric);\n\n        let eid = 0;\n        function uniqueMetricId() {\n          return `expr_${++eid}`;\n        }\n\n        return {\n          metricQuery: mset.entries.map(\n            (entry) =>\n              dispatchMetric(entry.metric, {\n                withStat(stat, conf) {\n                  self.validateMetricStat(stat, entry.metric);\n\n                  return {\n                    metric: {\n                      metricName: stat.metricName,\n                      namespace: stat.namespace,\n                      dimensions: stat.dimensions,\n                      period: stat.period.toSeconds(),\n                      stat: stat.statistic,\n                    },\n                    unit: stat.unitFilter,\n                    id: entry.id || uniqueMetricId(),\n                    accountId: self.requiresAccountId(stat)\n                      ? stat.account\n                      : undefined,\n                    label: conf.renderingProperties?.label,\n                    returnData: entry.tag ? undefined : false, // entry.tag evaluates to true if the metric is the math expression the alarm is based on.\n                  };\n                },\n                withExpression(expr, conf) {\n                  const hasSubmetrics = mathExprHasSubmetrics(expr);\n\n                  if (hasSubmetrics) {\n                    assertSubmetricsCount(expr);\n                  }\n\n                  self.validateMetricExpression(expr);\n\n                  return {\n                    expression: expr.expression,\n                    id: entry.id || uniqueMetricId(),\n                    label: conf.renderingProperties?.label,\n                    period: hasSubmetrics ? undefined : expr.period,\n                    returnData: entry.tag ? undefined : false, // entry.tag evaluates to true if the metric is the math expression the alarm is based on.\n                  };\n                },\n              }) as cloudwatchMetricAlarm.CloudwatchMetricAlarmMetricQuery,\n          ),\n        };\n      },\n    });\n  }\n\n  /**\n   * Validate that if a region is in the given stat config, they match the Alarm\n   */\n  private validateMetricStat(stat: MetricStatConfig, metric: IMetric) {\n    const stack = AwsStack.ofAwsConstruct(this);\n\n    if (definitelyDifferent(stat.region, stack.region)) {\n      throw new Error(\n        `Cannot create an Alarm in region '${stack.region}' based on metric '${metric}' in '${stat.region}'`,\n      );\n    }\n  }\n\n  /**\n   * Validates that the expression config does not specify searchAccount or searchRegion props\n   * as search expressions are not supported by Alarms.\n   */\n  private validateMetricExpression(expr: MetricExpressionConfig) {\n    if (expr.searchAccount !== undefined || expr.searchRegion !== undefined) {\n      throw new Error(\n        \"Cannot create an Alarm based on a MathExpression which specifies a searchAccount or searchRegion\",\n      );\n    }\n  }\n\n  /**\n   * Determine if the accountId property should be included in the metric.\n   */\n  private requiresAccountId(stat: MetricStatConfig): boolean {\n    const stackAccount = AwsStack.ofAwsConstruct(this).account;\n\n    // if stat.account is undefined, it's by definition in the same account\n    if (stat.account === undefined) {\n      return false;\n    }\n\n    // Return true if they're different. The ACCOUNT_ID token is interned\n    // so will always have the same string value (and even if we guess wrong\n    // it will still work).\n    return stackAccount !== stat.account;\n  }\n}\n\nfunction definitelyDifferent(x: string | undefined, y: string) {\n  return x && !Token.isUnresolved(y) && x !== y;\n}\n\n/**\n * Return a human readable string for this period\n *\n * We know the seconds are always one of a handful of allowed values.\n */\nfunction describePeriod(seconds: number) {\n  if (seconds === 60) {\n    return \"1 minute\";\n  }\n  if (seconds === 1) {\n    return \"1 second\";\n  }\n  if (seconds > 60) {\n    return seconds / 60 + \" minutes\";\n  }\n  return seconds + \" seconds\";\n}\n\nfunction renderIfSimpleStatistic(statistic?: string): string | undefined {\n  if (statistic === undefined) {\n    return undefined;\n  }\n\n  const parsed = parseStatistic(statistic);\n  if (parsed.type === \"simple\") {\n    return normalizeStatistic(parsed);\n  }\n  return undefined;\n}\n\nfunction renderIfExtendedStatistic(statistic?: string): string | undefined {\n  if (statistic === undefined) {\n    return undefined;\n  }\n\n  const parsed = parseStatistic(statistic);\n  if (parsed.type === \"simple\") {\n    // This statistic will have been rendered by renderIfSimpleStatistic\n    return undefined;\n  }\n\n  if (parsed.type === \"single\" || parsed.type === \"pair\") {\n    return normalizeStatistic(parsed);\n  }\n\n  // We can't not render anything here. Just put whatever we got as input into\n  // the ExtendedStatistic and hope it's correct. Either that, or we throw\n  // an error.\n  return parsed.statistic;\n}\n\nfunction mathExprHasSubmetrics(expr: MetricExpressionConfig) {\n  return Object.keys(expr.usingMetrics).length > 0;\n}\n\nfunction assertSubmetricsCount(expr: MetricExpressionConfig) {\n  if (Object.keys(expr.usingMetrics).length > 10) {\n    // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-on-metric-math-expressions\n    throw new Error(\n      \"Alarms on math expressions cannot contain more than 10 individual metrics\",\n    );\n  }\n}\n\ntype Writeable<T> = { -readonly [P in keyof T]: T[P] };\n"]}

package/lib/aws/cloudwatch/composite-alarm.d.ts

@@ -0,0 +1,88 @@
+import { cloudwatchCompositeAlarm } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructProps } from "../aws-construct";
+import { AlarmBase, IAlarm, IAlarmRule } from "./alarm-base";
+import { Duration } from "../../duration";
+/**
+ * Properties for creating a Composite Alarm
+ */
+export interface CompositeAlarmProps extends AwsConstructProps {
+    /**
+     * Whether the actions for this alarm are enabled
+     *
+     * @default true
+     */
+    readonly actionsEnabled?: boolean;
+    /**
+     * Description for the alarm
+     *
+     * @default - No description.
+     */
+    readonly alarmDescription?: string;
+    /**
+     * Name of the alarm
+     *
+     * @default - Automatically generated name.
+     */
+    readonly compositeAlarmName?: string;
+    /**
+     * Expression that specifies which other alarms are to be evaluated to determine this composite alarm's state.
+     */
+    readonly alarmRule: IAlarmRule;
+    /**
+     * Actions will be suppressed if the suppressor alarm is in the ALARM state.
+     *
+     * @default - alarm will not be suppressed.
+     */
+    readonly actionsSuppressor?: IAlarm;
+    /**
+     * The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state.
+     * After this time, the composite alarm performs its actions.
+     *
+     * @default - 1 minute extension period will be set.
+     */
+    readonly actionsSuppressorExtensionPeriod?: Duration;
+    /**
+     * The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state.
+     * After this time, the composite alarm performs its actions.
+     *
+     * @default - 1 minute wait period will be set.
+     */
+    readonly actionsSuppressorWaitPeriod?: Duration;
+}
+/**
+ * A Composite Alarm based on Alarm Rule.
+ */
+export declare class CompositeAlarm extends AlarmBase {
+    /**
+     * Import an existing CloudWatch composite alarm provided an Name.
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param compositeAlarmName Composite Alarm Name
+     */
+    static fromCompositeAlarmName(scope: Construct, id: string, compositeAlarmName: string): IAlarm;
+    /**
+     * Import an existing CloudWatch composite alarm provided an ARN.
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param compositeAlarmArn Composite Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:CompositeAlarmName)
+     */
+    static fromCompositeAlarmArn(scope: Construct, id: string, compositeAlarmArn: string): IAlarm;
+    readonly resource: cloudwatchCompositeAlarm.CloudwatchCompositeAlarm;
+    /**
+     * ARN of this alarm
+     *
+     * @attribute
+     */
+    readonly alarmArn: string;
+    /**
+     * Name of this alarm.
+     *
+     * @attribute
+     */
+    readonly alarmName: string;
+    private readonly alarmRule;
+    constructor(scope: Construct, id: string, props: CompositeAlarmProps);
+}