terraconstructs 0.0.8

package/lib/aws/cloudwatch/metric.js

@@ -0,0 +1,493 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathExpression = exports.Metric = 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/metric.ts
+const cdktf_1 = require("cdktf");
+const alarm_1 = require("./alarm");
+const aws_stack_1 = require("../aws-stack");
+const metric_util_1 = require("./private/metric-util");
+const statistic_1 = require("./private/statistic");
+const stats_1 = require("./stats");
+const duration_1 = require("../../duration");
+const iam = require("../iam");
+/**
+ * A metric emitted by a service
+ *
+ * The metric is a combination of a metric identifier (namespace, name and dimensions)
+ * and an aggregation function (statistic, period and unit).
+ *
+ * It also contains metadata which is used only in graphs, such as color and label.
+ * It makes sense to embed this in here, so that compound constructs can attach
+ * that metadata to metrics they expose.
+ *
+ * This class does not represent a resource, so hence is not a construct. Instead,
+ * Metric is an abstraction that makes it easy to specify metrics for use in both
+ * alarms and graphs.
+ */
+class Metric {
+    /**
+     * Grant permissions to the given identity to write metrics.
+     *
+     * @param grantee The IAM identity to give permissions to.
+     */
+    static grantPutMetricData(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["cloudwatch:PutMetricData"],
+            resourceArns: ["*"],
+        });
+    }
+    constructor(props) {
+        this.period = props.period || duration_1.Duration.minutes(5);
+        const periodSec = this.period.toSeconds();
+        if (periodSec !== 1 &&
+            periodSec !== 5 &&
+            periodSec !== 10 &&
+            periodSec !== 30 &&
+            periodSec % 60 !== 0) {
+            throw new Error(`'period' must be 1, 5, 10, 30, or a multiple of 60 seconds, received ${periodSec}`);
+        }
+        this.warnings = undefined;
+        this.dimensions = this.validateDimensions(props.dimensionsMap);
+        this.namespace = props.namespace;
+        this.metricName = props.metricName;
+        const parsedStat = (0, statistic_1.parseStatistic)(props.statistic || stats_1.Stats.AVERAGE);
+        if (parsedStat.type === "generic") {
+            // Unrecognized statistic, do not throw, just warn
+            // There may be a new statistic that this lib does not support yet
+            const label = props.label ? `, label "${props.label}"` : "";
+            const warning = `Unrecognized statistic "${props.statistic}" for metric with namespace "${props.namespace}"${label} and metric name "${props.metricName}".` +
+                " Preferably use the `aws_cloudwatch.Stats` helper class to specify a statistic." +
+                " You can ignore this warning if your statistic is valid but not yet supported by the `aws_cloudwatch.Stats` helper class.";
+            this.warningsV2 = {
+                "CloudWatch:Alarm:UnrecognizedStatistic": warning,
+            };
+            this.warnings = [warning];
+        }
+        this.statistic = (0, statistic_1.normalizeStatistic)(parsedStat);
+        this.label = props.label;
+        this.color = props.color;
+        this.unit = props.unit;
+        this.account = props.account;
+        this.region = props.region;
+    }
+    /**
+     * Return a copy of Metric `with` properties changed.
+     *
+     * All properties except namespace and metricName can be changed.
+     *
+     * @param props The set of properties to change.
+     */
+    with(props) {
+        // Short-circuit creating a new object if there would be no effective change
+        if ((props.label === undefined || props.label === this.label) &&
+            (props.color === undefined || props.color === this.color) &&
+            (props.statistic === undefined || props.statistic === this.statistic) &&
+            (props.unit === undefined || props.unit === this.unit) &&
+            (props.account === undefined || props.account === this.account) &&
+            (props.region === undefined || props.region === this.region) &&
+            // For these we're not going to do deep equality, misses some opportunity for optimization
+            // but that's okay.
+            props.dimensionsMap === undefined &&
+            (props.period === undefined ||
+                props.period.toSeconds() === this.period.toSeconds())) {
+            return this;
+        }
+        return new Metric({
+            dimensionsMap: props.dimensionsMap ?? this.dimensions,
+            namespace: this.namespace,
+            metricName: this.metricName,
+            period: ifUndefined(props.period, this.period),
+            statistic: ifUndefined(props.statistic, this.statistic),
+            unit: ifUndefined(props.unit, this.unit),
+            label: ifUndefined(props.label, this.label),
+            color: ifUndefined(props.color, this.color),
+            account: ifUndefined(props.account, this.account),
+            region: ifUndefined(props.region, this.region),
+        });
+    }
+    /**
+     * Attach the metric object to the given construct scope
+     *
+     * Returns a Metric object that uses the account and region from the Stack
+     * the given construct is defined in. If the metric is subsequently used
+     * in a Dashboard or Alarm in a different Stack defined in a different
+     * account or region, the appropriate 'region' and 'account' fields
+     * will be added to it.
+     *
+     * If the scope we attach to is in an environment-agnostic stack,
+     * nothing is done and the same Metric object is returned.
+     */
+    attachTo(scope) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        return this.with({
+            region: cdktf_1.Token.isUnresolved(stack.region) ? undefined : stack.region,
+            account: cdktf_1.Token.isUnresolved(stack.account) ? undefined : stack.account,
+        });
+    }
+    toMetricConfig() {
+        // const dims = this.dimensionsAsList();
+        return {
+            metricStat: {
+                dimensions: this.dimensions && Object.keys(this.dimensions).length > 0
+                    ? this.dimensions
+                    : undefined,
+                namespace: this.namespace,
+                metricName: this.metricName,
+                period: this.period,
+                statistic: this.statistic,
+                unitFilter: this.unit,
+                account: this.account,
+                region: this.region,
+            },
+            renderingProperties: {
+                color: this.color,
+                label: this.label,
+            },
+        };
+    }
+    /** @deprecated use toMetricConfig() */
+    toAlarmConfig() {
+        const metricConfig = this.toMetricConfig();
+        if (metricConfig.metricStat === undefined) {
+            throw new Error("Using a math expression is not supported here. Pass a 'Metric' object instead");
+        }
+        const parsed = (0, statistic_1.parseStatistic)(metricConfig.metricStat.statistic);
+        let extendedStatistic = undefined;
+        if (parsed.type === "single") {
+            extendedStatistic = (0, statistic_1.singleStatisticToString)(parsed);
+        }
+        else if (parsed.type === "pair") {
+            extendedStatistic = (0, statistic_1.pairStatisticToString)(parsed);
+        }
+        return {
+            dimensions: metricConfig.metricStat.dimensions,
+            namespace: metricConfig.metricStat.namespace,
+            metricName: metricConfig.metricStat.metricName,
+            period: metricConfig.metricStat.period.toSeconds(),
+            statistic: parsed.type === "simple" ? parsed.statistic : undefined,
+            extendedStatistic,
+            unit: this.unit,
+        };
+    }
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toGraphConfig() {
+        const metricConfig = this.toMetricConfig();
+        if (metricConfig.metricStat === undefined) {
+            throw new Error("Using a math expression is not supported here. Pass a 'Metric' object instead");
+        }
+        return {
+            dimensions: metricConfig.metricStat.dimensions,
+            namespace: metricConfig.metricStat.namespace,
+            metricName: metricConfig.metricStat.metricName,
+            renderingProperties: {
+                period: metricConfig.metricStat.period.toSeconds(),
+                stat: metricConfig.metricStat.statistic,
+                color: asString(metricConfig.renderingProperties?.color),
+                label: asString(metricConfig.renderingProperties?.label),
+            },
+            // deprecated properties for backwards compatibility
+            period: metricConfig.metricStat.period.toSeconds(),
+            statistic: metricConfig.metricStat.statistic,
+            color: asString(metricConfig.renderingProperties?.color),
+            label: asString(metricConfig.renderingProperties?.label),
+            unit: this.unit,
+        };
+    }
+    /**
+     * Make a new Alarm for this metric
+     *
+     * Combines both properties that may adjust the metric (aggregation) as well
+     * as alarm properties.
+     */
+    createAlarm(scope, id, props) {
+        return new alarm_1.Alarm(scope, id, {
+            metric: this.with({
+                statistic: props.statistic,
+                period: props.period,
+            }),
+            alarmName: props.alarmName,
+            alarmDescription: props.alarmDescription,
+            comparisonOperator: props.comparisonOperator,
+            datapointsToAlarm: props.datapointsToAlarm,
+            threshold: props.threshold,
+            evaluationPeriods: props.evaluationPeriods,
+            evaluateLowSampleCountPercentile: props.evaluateLowSampleCountPercentile,
+            treatMissingData: props.treatMissingData,
+            actionsEnabled: props.actionsEnabled,
+        });
+    }
+    toString() {
+        return this.label || this.metricName;
+    }
+    validateDimensions(dims) {
+        if (!dims) {
+            return dims;
+        }
+        var dimsArray = Object.keys(dims);
+        if (dimsArray?.length > 30) {
+            throw new Error(`The maximum number of dimensions is 30, received ${dimsArray.length}`);
+        }
+        dimsArray.map((key) => {
+            if (dims[key] === undefined || dims[key] === null) {
+                throw new Error(`Dimension value of '${dims[key]}' is invalid`);
+            }
+            if (key.length < 1 || key.length > 255) {
+                throw new Error(`Dimension name must be at least 1 and no more than 255 characters; received ${key}`);
+            }
+            if (dims[key].length < 1 || dims[key].length > 255) {
+                throw new Error(`Dimension value must be at least 1 and no more than 255 characters; received ${dims[key]}`);
+            }
+        });
+        return dims;
+    }
+}
+exports.Metric = Metric;
+_a = JSII_RTTI_SYMBOL_1;
+Metric[_a] = { fqn: "terraconstructs.aws.cloudwatch.Metric", version: "0.0.8" };
+function asString(x) {
+    if (x === undefined) {
+        return undefined;
+    }
+    if (typeof x !== "string") {
+        throw new Error(`Expected string, got ${x}`);
+    }
+    return x;
+}
+/**
+ * A math expression built with metric(s) emitted by a service
+ *
+ * The math expression is a combination of an expression (x+y) and metrics to apply expression on.
+ * It also contains metadata which is used only in graphs, such as color and label.
+ * It makes sense to embed this in here, so that compound constructs can attach
+ * that metadata to metrics they expose.
+ *
+ * MathExpression can also be used for search expressions. In this case,
+ * it also optionally accepts a searchRegion and searchAccount property for cross-environment
+ * search expressions.
+ *
+ * This class does not represent a resource, so hence is not a construct. Instead,
+ * MathExpression is an abstraction that makes it easy to specify metrics for use in both
+ * alarms and graphs.
+ */
+class MathExpression {
+    constructor(props) {
+        this.period = props.period || duration_1.Duration.minutes(5);
+        this.expression = props.expression;
+        this.label = props.label;
+        this.color = props.color;
+        this.searchAccount = props.searchAccount;
+        this.searchRegion = props.searchRegion;
+        const { record, overridden } = changeAllPeriods(props.usingMetrics ?? {}, this.period);
+        this.usingMetrics = record;
+        const warnings = {};
+        if (overridden) {
+            warnings["CloudWatch:Math:MetricsPeriodsOverridden"] =
+                `Periods of metrics in 'usingMetrics' for Math expression '${this.expression}' have been overridden to ${this.period.toSeconds()} seconds.`;
+        }
+        const invalidVariableNames = Object.keys(this.usingMetrics).filter((x) => !validVariableName(x));
+        if (invalidVariableNames.length > 0) {
+            throw new Error(`Invalid variable names in expression: ${invalidVariableNames}. Must start with lowercase letter and only contain alphanumerics.`);
+        }
+        this.validateNoIdConflicts();
+        // Check that all IDs used in the expression are also in the `usingMetrics` map. We
+        // can't throw on this anymore since we didn't use to do this validation from the start
+        // and now there will be loads of people who are violating the expected contract, but
+        // we can add warnings.
+        const missingIdentifiers = allIdentifiersInExpression(this.expression).filter((i) => !this.usingMetrics[i]);
+        if (!this.expression
+            .toUpperCase()
+            .match("\\s*INSIGHT_RULE_METRIC|SELECT|SEARCH|METRICS\\s.*") &&
+            missingIdentifiers.length > 0) {
+            warnings["CloudWatch:Math:UnknownIdentifier"] =
+                `Math expression '${this.expression}' references unknown identifiers: ${missingIdentifiers.join(", ")}. Please add them to the 'usingMetrics' map.`;
+        }
+        // Also copy warnings from deeper levels so graphs, alarms only have to inspect the top-level objects
+        for (const m of Object.values(this.usingMetrics)) {
+            for (const [id, message] of Object.entries(m.warningsV2 ?? {})) {
+                warnings[id] = message;
+            }
+        }
+        if (Object.keys(warnings).length > 0) {
+            this.warnings = Array.from(Object.values(warnings));
+            this.warningsV2 = warnings;
+        }
+    }
+    /**
+     * Return a copy of Metric with properties changed.
+     *
+     * All properties except namespace and metricName can be changed.
+     *
+     * @param props The set of properties to change.
+     */
+    with(props) {
+        // Short-circuit creating a new object if there would be no effective change
+        if ((props.label === undefined || props.label === this.label) &&
+            (props.color === undefined || props.color === this.color) &&
+            (props.period === undefined ||
+                props.period.toSeconds() === this.period.toSeconds()) &&
+            (props.searchAccount === undefined ||
+                props.searchAccount === this.searchAccount) &&
+            (props.searchRegion === undefined ||
+                props.searchRegion === this.searchRegion)) {
+            return this;
+        }
+        return new MathExpression({
+            expression: this.expression,
+            usingMetrics: this.usingMetrics,
+            label: ifUndefined(props.label, this.label),
+            color: ifUndefined(props.color, this.color),
+            period: ifUndefined(props.period, this.period),
+            searchAccount: ifUndefined(props.searchAccount, this.searchAccount),
+            searchRegion: ifUndefined(props.searchRegion, this.searchRegion),
+        });
+    }
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toAlarmConfig() {
+        throw new Error("Using a math expression is not supported here. Pass a 'Metric' object instead");
+    }
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toGraphConfig() {
+        throw new Error("Using a math expression is not supported here. Pass a 'Metric' object instead");
+    }
+    toMetricConfig() {
+        return {
+            mathExpression: {
+                period: this.period.toSeconds(),
+                expression: this.expression,
+                usingMetrics: this.usingMetrics,
+                searchAccount: this.searchAccount,
+                searchRegion: this.searchRegion,
+            },
+            renderingProperties: {
+                label: this.label,
+                color: this.color,
+            },
+        };
+    }
+    /**
+     * Make a new Alarm for this metric
+     *
+     * Combines both properties that may adjust the metric (aggregation) as well
+     * as alarm properties.
+     */
+    createAlarm(scope, id, props) {
+        return new alarm_1.Alarm(scope, id, {
+            metric: this.with({
+                period: props.period,
+            }),
+            alarmName: props.alarmName,
+            alarmDescription: props.alarmDescription,
+            comparisonOperator: props.comparisonOperator,
+            datapointsToAlarm: props.datapointsToAlarm,
+            threshold: props.threshold,
+            evaluationPeriods: props.evaluationPeriods,
+            evaluateLowSampleCountPercentile: props.evaluateLowSampleCountPercentile,
+            treatMissingData: props.treatMissingData,
+            actionsEnabled: props.actionsEnabled,
+        });
+    }
+    toString() {
+        return this.label || this.expression;
+    }
+    validateNoIdConflicts() {
+        const seen = new Map();
+        visit(this);
+        function visit(metric) {
+            (0, metric_util_1.dispatchMetric)(metric, {
+                withStat() {
+                    // Nothing
+                },
+                withExpression(expr) {
+                    for (const [id, subMetric] of Object.entries(expr.usingMetrics)) {
+                        const existing = seen.get(id);
+                        if (existing && (0, metric_util_1.metricKey)(existing) !== (0, metric_util_1.metricKey)(subMetric)) {
+                            throw new Error(`The ID '${id}' used for two metrics in the expression: '${subMetric}' and '${existing}'. Rename one.`);
+                        }
+                        seen.set(id, subMetric);
+                        visit(subMetric);
+                    }
+                },
+            });
+        }
+    }
+}
+exports.MathExpression = MathExpression;
+_b = JSII_RTTI_SYMBOL_1;
+MathExpression[_b] = { fqn: "terraconstructs.aws.cloudwatch.MathExpression", version: "0.0.8" };
+/**
+ * Pattern for a variable name. Alphanum starting with lowercase.
+ */
+const VARIABLE_PAT = "[a-z][a-zA-Z0-9_]*";
+const VALID_VARIABLE = new RegExp(`^${VARIABLE_PAT}$`);
+const FIND_VARIABLE = new RegExp(VARIABLE_PAT, "g");
+function validVariableName(x) {
+    return VALID_VARIABLE.test(x);
+}
+/**
+ * Return all variable names used in an expression
+ */
+function allIdentifiersInExpression(x) {
+    return Array.from(matchAll(x, FIND_VARIABLE)).map((m) => m[0]);
+}
+function ifUndefined(x, def) {
+    if (x !== undefined) {
+        return x;
+    }
+    return def;
+}
+/**
+ * Change periods of all metrics in the map
+ */
+function changeAllPeriods(metrics, period) {
+    const retRecord = {};
+    let retOverridden = false;
+    for (const [id, m] of Object.entries(metrics)) {
+        const { metric, overridden } = changePeriod(m, period);
+        retRecord[id] = metric;
+        if (overridden) {
+            retOverridden = true;
+        }
+    }
+    return { record: retRecord, overridden: retOverridden };
+}
+/**
+ * Return a new metric object which is the same type as the input object but with the period changed,
+ * and a flag to indicate whether the period has been overwritten.
+ *
+ * Relies on the fact that implementations of `IMetric` are also supposed to have
+ * an implementation of `with` that accepts an argument called `period`. See `IModifiableMetric`.
+ */
+function changePeriod(metric, period) {
+    if (isModifiableMetric(metric)) {
+        const overridden = isMetricWithPeriod(metric) && // always true, as the period property is set with a default value even if it is not specified
+            metric.period.toSeconds() !== duration_1.Duration.minutes(5).toSeconds() && // exclude the default value of a metric, assuming the user has not specified it
+            metric.period.toSeconds() !== period.toSeconds();
+        return { metric: metric.with({ period }), overridden };
+    }
+    throw new Error(`Metric object should also implement 'with': ${metric}`);
+}
+function isModifiableMetric(m) {
+    return typeof m === "object" && m !== null && !!m.with;
+}
+function isMetricWithPeriod(m) {
+    return typeof m === "object" && m !== null && !!m.period;
+}
+// Polyfill for string.matchAll(regexp)
+function matchAll(x, re) {
+    const ret = new Array();
+    let m;
+    while ((m = re.exec(x))) {
+        ret.push(m);
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/metric.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/metric.ts\n\nimport { Token } from \"cdktf\";\nimport { Construct, IConstruct } from \"constructs\";\nimport { Alarm, ComparisonOperator, TreatMissingData } from \"./alarm\";\nimport {\n  IMetric,\n  MetricAlarmConfig,\n  MetricConfig,\n  MetricGraphConfig,\n  Statistic,\n  Unit,\n} from \"./metric-types\";\nimport { AwsStack } from \"../aws-stack\";\nimport { dispatchMetric, metricKey } from \"./private/metric-util\";\nimport {\n  normalizeStatistic,\n  pairStatisticToString,\n  parseStatistic,\n  singleStatisticToString,\n} from \"./private/statistic\";\nimport { Stats } from \"./stats\";\nimport { Duration } from \"../../duration\";\nimport * as iam from \"../iam\";\n\nexport type DimensionsMap = { [dim: string]: string };\n\n/**\n * Options shared by most methods accepting metric options\n */\nexport interface CommonMetricOptions {\n  /**\n   * The period over which the specified statistic is applied.\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly period?: Duration;\n\n  /**\n   * What function to use for aggregating.\n   *\n   * Use the `aws_cloudwatch.Stats` helper class to construct valid input strings.\n   *\n   * Can be one of the following:\n   *\n   * - \"Minimum\" | \"min\"\n   * - \"Maximum\" | \"max\"\n   * - \"Average\" | \"avg\"\n   * - \"Sum\" | \"sum\"\n   * - \"SampleCount | \"n\"\n   * - \"pNN.NN\"\n   * - \"tmNN.NN\" | \"tm(NN.NN%:NN.NN%)\"\n   * - \"iqm\"\n   * - \"wmNN.NN\" | \"wm(NN.NN%:NN.NN%)\"\n   * - \"tcNN.NN\" | \"tc(NN.NN%:NN.NN%)\"\n   * - \"tsNN.NN\" | \"ts(NN.NN%:NN.NN%)\"\n   *\n   * @default Average\n   */\n  readonly statistic?: string;\n\n  /**\n   * Dimensions of the metric\n   *\n   * @default - No dimensions.\n   */\n  readonly dimensionsMap?: DimensionsMap;\n\n  /**\n   * Unit used to filter the metric stream\n   *\n   * Only refer to datums emitted to the metric stream with the given unit and\n   * ignore all others. Only useful when datums are being emitted to the same\n   * metric stream under different units.\n   *\n   * The default is to use all matric datums in the stream, regardless of unit,\n   * which is recommended in nearly all cases.\n   *\n   * CloudWatch does not honor this property for graphs.\n   *\n   * @default - All metric datums in the given metric stream\n   */\n  readonly unit?: Unit;\n\n  /**\n   * Label for this metric when added to a Graph in a Dashboard\n   *\n   * You can use [dynamic labels](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html)\n   * to show summary information about the entire displayed time series\n   * in the legend. For example, if you use:\n   *\n   * ```\n   * [max: ${MAX}] MyMetric\n   * ```\n   *\n   * As the metric label, the maximum value in the visible range will\n   * be shown next to the time series name in the graph's legend.\n   *\n   * @default - No label\n   */\n  readonly label?: string;\n\n  /**\n   * The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph.\n   * The `Color` class has a set of standard colors that can be used here.\n   * @default - Automatic color\n   */\n  readonly color?: string;\n\n  /**\n   * Account which this metric comes from.\n   *\n   * @default - Deployment account.\n   */\n  readonly account?: string;\n\n  /**\n   * Region which this metric comes from.\n   *\n   * @default - Deployment region.\n   */\n  readonly region?: string;\n}\n\n/**\n * Properties for a metric\n */\nexport interface MetricProps extends CommonMetricOptions {\n  /**\n   * Namespace of the metric.\n   */\n  readonly namespace: string;\n\n  /**\n   * Name of the metric.\n   */\n  readonly metricName: string;\n}\n\n/**\n * Properties of a metric that can be changed\n */\nexport interface MetricOptions extends CommonMetricOptions {}\n\n/**\n * Configurable options for MathExpressions\n */\nexport interface MathExpressionOptions {\n  /**\n   * Label for this expression when added to a Graph in a Dashboard\n   *\n   * If this expression evaluates to more than one time series (for\n   * example, through the use of `METRICS()` or `SEARCH()` expressions),\n   * each time series will appear in the graph using a combination of the\n   * expression label and the individual metric label. Specify the empty\n   * string (`''`) to suppress the expression label and only keep the\n   * metric label.\n   *\n   * You can use [dynamic labels](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html)\n   * to show summary information about the displayed time series\n   * in the legend. For example, if you use:\n   *\n   * ```\n   * [max: ${MAX}] MyMetric\n   * ```\n   *\n   * As the metric label, the maximum value in the visible range will\n   * be shown next to the time series name in the graph's legend. If the\n   * math expression produces more than one time series, the maximum\n   * will be shown for each individual time series produce by this\n   * math expression.\n   *\n   * @default - Expression value is used as label\n   */\n  readonly label?: string;\n\n  /**\n   * Color for this metric when added to a Graph in a Dashboard\n   *\n   * @default - Automatic color\n   */\n  readonly color?: string;\n\n  /**\n   * The period over which the expression's statistics are applied.\n   *\n   * This period overrides all periods in the metrics used in this\n   * math expression.\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly period?: Duration;\n\n  /**\n   * Account to evaluate search expressions within.\n   *\n   * Specifying a searchAccount has no effect to the account used\n   * for metrics within the expression (passed via usingMetrics).\n   *\n   * @default - Deployment account.\n   */\n  readonly searchAccount?: string;\n\n  /**\n   * Region to evaluate search expressions within.\n   *\n   * Specifying a searchRegion has no effect to the region used\n   * for metrics within the expression (passed via usingMetrics).\n   *\n   * @default - Deployment region.\n   */\n  readonly searchRegion?: string;\n}\n\n/**\n * Properties for a MathExpression\n */\nexport interface MathExpressionProps extends MathExpressionOptions {\n  /**\n   * The expression defining the metric.\n   *\n   * When an expression contains a SEARCH function, it cannot be used\n   * within an Alarm.\n   */\n  readonly expression: string;\n\n  /**\n   * The metrics used in the expression, in a map.\n   *\n   * The key is the identifier that represents the given metric in the\n   * expression, and the value is the actual Metric object.\n   *\n   * The `period` of each metric in `usingMetrics` is ignored and instead overridden\n   * by the `period` specified for the `MathExpression` construct. Even if no `period`\n   * is specified for the `MathExpression`, it will be overridden by the default\n   * value (`Duration.minutes(5)`).\n   *\n   * Example:\n   *\n   * ```ts\n   * declare const metrics: elbv2.IApplicationLoadBalancerMetrics;\n   * new cloudwatch.MathExpression({\n   *   expression:  'm1+m2',\n   *   label: 'AlbErrors',\n   *   usingMetrics: {\n   *     m1: metrics.custom('HTTPCode_ELB_500_Count', {\n   *       period: Duration.minutes(1), // <- This period will be ignored\n   *       statistic: 'Sum',\n   *       label: 'HTTPCode_ELB_500_Count',\n   *     }),\n   *     m2: metrics.custom('HTTPCode_ELB_502_Count', {\n   *       period: Duration.minutes(1), // <- This period will be ignored\n   *       statistic: 'Sum',\n   *       label: 'HTTPCode_ELB_502_Count',\n   *     }),\n   *   },\n   *   period: Duration.minutes(3), // <- This overrides the period of each metric in `usingMetrics`\n   *                                //    (Even if not specified, it is overridden by the default value)\n   * });\n   * ```\n   *\n   * @default - Empty map.\n   */\n  readonly usingMetrics?: Record<string, IMetric>;\n}\n\n/**\n * A metric emitted by a service\n *\n * The metric is a combination of a metric identifier (namespace, name and dimensions)\n * and an aggregation function (statistic, period and unit).\n *\n * It also contains metadata which is used only in graphs, such as color and label.\n * It makes sense to embed this in here, so that compound constructs can attach\n * that metadata to metrics they expose.\n *\n * This class does not represent a resource, so hence is not a construct. Instead,\n * Metric is an abstraction that makes it easy to specify metrics for use in both\n * alarms and graphs.\n */\nexport class Metric implements IMetric {\n  /**\n   * Grant permissions to the given identity to write metrics.\n   *\n   * @param grantee The IAM identity to give permissions to.\n   */\n  public static grantPutMetricData(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"cloudwatch:PutMetricData\"],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  /** Dimensions of this metric */\n  public readonly dimensions?: DimensionsMap;\n  /** Namespace of this metric */\n  public readonly namespace: string;\n  /** Name of this metric */\n  public readonly metricName: string;\n  /** Period of this metric */\n  public readonly period: Duration;\n  /** Statistic of this metric */\n  public readonly statistic: string;\n  /** Label for this metric when added to a Graph in a Dashboard */\n  public readonly label?: string;\n  /** The hex color code used when this metric is rendered on a graph. */\n  public readonly color?: string;\n\n  /** Unit of the metric. */\n  public readonly unit?: Unit;\n\n  /** Account which this metric comes from */\n  public readonly account?: string;\n\n  /** Region which this metric comes from. */\n  public readonly region?: string;\n\n  /**\n   * Warnings attached to this metric.\n   * @deprecated - use warningsV2\n   **/\n  public readonly warnings?: string[];\n\n  /** Warnings attached to this metric. */\n  public readonly warningsV2?: { [id: string]: string };\n\n  constructor(props: MetricProps) {\n    this.period = props.period || Duration.minutes(5);\n    const periodSec = this.period.toSeconds();\n    if (\n      periodSec !== 1 &&\n      periodSec !== 5 &&\n      periodSec !== 10 &&\n      periodSec !== 30 &&\n      periodSec % 60 !== 0\n    ) {\n      throw new Error(\n        `'period' must be 1, 5, 10, 30, or a multiple of 60 seconds, received ${periodSec}`,\n      );\n    }\n\n    this.warnings = undefined;\n    this.dimensions = this.validateDimensions(props.dimensionsMap);\n    this.namespace = props.namespace;\n    this.metricName = props.metricName;\n\n    const parsedStat = parseStatistic(props.statistic || Stats.AVERAGE);\n    if (parsedStat.type === \"generic\") {\n      // Unrecognized statistic, do not throw, just warn\n      // There may be a new statistic that this lib does not support yet\n      const label = props.label ? `, label \"${props.label}\"` : \"\";\n\n      const warning =\n        `Unrecognized statistic \"${props.statistic}\" for metric with namespace \"${props.namespace}\"${label} and metric name \"${props.metricName}\".` +\n        \" Preferably use the `aws_cloudwatch.Stats` helper class to specify a statistic.\" +\n        \" You can ignore this warning if your statistic is valid but not yet supported by the `aws_cloudwatch.Stats` helper class.\";\n      this.warningsV2 = {\n        \"CloudWatch:Alarm:UnrecognizedStatistic\": warning,\n      };\n      this.warnings = [warning];\n    }\n    this.statistic = normalizeStatistic(parsedStat);\n\n    this.label = props.label;\n    this.color = props.color;\n    this.unit = props.unit;\n    this.account = props.account;\n    this.region = props.region;\n  }\n\n  /**\n   * Return a copy of Metric `with` properties changed.\n   *\n   * All properties except namespace and metricName can be changed.\n   *\n   * @param props The set of properties to change.\n   */\n  public with(props: MetricOptions): Metric {\n    // Short-circuit creating a new object if there would be no effective change\n    if (\n      (props.label === undefined || props.label === this.label) &&\n      (props.color === undefined || props.color === this.color) &&\n      (props.statistic === undefined || props.statistic === this.statistic) &&\n      (props.unit === undefined || props.unit === this.unit) &&\n      (props.account === undefined || props.account === this.account) &&\n      (props.region === undefined || props.region === this.region) &&\n      // For these we're not going to do deep equality, misses some opportunity for optimization\n      // but that's okay.\n      props.dimensionsMap === undefined &&\n      (props.period === undefined ||\n        props.period.toSeconds() === this.period.toSeconds())\n    ) {\n      return this;\n    }\n\n    return new Metric({\n      dimensionsMap: props.dimensionsMap ?? this.dimensions,\n      namespace: this.namespace,\n      metricName: this.metricName,\n      period: ifUndefined(props.period, this.period),\n      statistic: ifUndefined(props.statistic, this.statistic),\n      unit: ifUndefined(props.unit, this.unit),\n      label: ifUndefined(props.label, this.label),\n      color: ifUndefined(props.color, this.color),\n      account: ifUndefined(props.account, this.account),\n      region: ifUndefined(props.region, this.region),\n    });\n  }\n\n  /**\n   * Attach the metric object to the given construct scope\n   *\n   * Returns a Metric object that uses the account and region from the Stack\n   * the given construct is defined in. If the metric is subsequently used\n   * in a Dashboard or Alarm in a different Stack defined in a different\n   * account or region, the appropriate 'region' and 'account' fields\n   * will be added to it.\n   *\n   * If the scope we attach to is in an environment-agnostic stack,\n   * nothing is done and the same Metric object is returned.\n   */\n  public attachTo(scope: IConstruct): Metric {\n    const stack = AwsStack.ofAwsConstruct(scope);\n\n    return this.with({\n      region: Token.isUnresolved(stack.region) ? undefined : stack.region,\n      account: Token.isUnresolved(stack.account) ? undefined : stack.account,\n    });\n  }\n\n  public toMetricConfig(): MetricConfig {\n    // const dims = this.dimensionsAsList();\n    return {\n      metricStat: {\n        dimensions:\n          this.dimensions && Object.keys(this.dimensions).length > 0\n            ? this.dimensions\n            : undefined,\n        namespace: this.namespace,\n        metricName: this.metricName,\n        period: this.period,\n        statistic: this.statistic,\n        unitFilter: this.unit,\n        account: this.account,\n        region: this.region,\n      },\n      renderingProperties: {\n        color: this.color,\n        label: this.label,\n      },\n    };\n  }\n\n  /** @deprecated use toMetricConfig() */\n  public toAlarmConfig(): MetricAlarmConfig {\n    const metricConfig = this.toMetricConfig();\n    if (metricConfig.metricStat === undefined) {\n      throw new Error(\n        \"Using a math expression is not supported here. Pass a 'Metric' object instead\",\n      );\n    }\n\n    const parsed = parseStatistic(metricConfig.metricStat.statistic);\n\n    let extendedStatistic: string | undefined = undefined;\n    if (parsed.type === \"single\") {\n      extendedStatistic = singleStatisticToString(parsed);\n    } else if (parsed.type === \"pair\") {\n      extendedStatistic = pairStatisticToString(parsed);\n    }\n\n    return {\n      dimensions: metricConfig.metricStat.dimensions,\n      namespace: metricConfig.metricStat.namespace,\n      metricName: metricConfig.metricStat.metricName,\n      period: metricConfig.metricStat.period.toSeconds(),\n      statistic:\n        parsed.type === \"simple\" ? (parsed.statistic as Statistic) : undefined,\n      extendedStatistic,\n      unit: this.unit,\n    };\n  }\n\n  /**\n   * @deprecated use toMetricConfig()\n   */\n  public toGraphConfig(): MetricGraphConfig {\n    const metricConfig = this.toMetricConfig();\n    if (metricConfig.metricStat === undefined) {\n      throw new Error(\n        \"Using a math expression is not supported here. Pass a 'Metric' object instead\",\n      );\n    }\n\n    return {\n      dimensions: metricConfig.metricStat.dimensions,\n      namespace: metricConfig.metricStat.namespace,\n      metricName: metricConfig.metricStat.metricName,\n      renderingProperties: {\n        period: metricConfig.metricStat.period.toSeconds(),\n        stat: metricConfig.metricStat.statistic,\n        color: asString(metricConfig.renderingProperties?.color),\n        label: asString(metricConfig.renderingProperties?.label),\n      },\n      // deprecated properties for backwards compatibility\n      period: metricConfig.metricStat.period.toSeconds(),\n      statistic: metricConfig.metricStat.statistic,\n      color: asString(metricConfig.renderingProperties?.color),\n      label: asString(metricConfig.renderingProperties?.label),\n      unit: this.unit,\n    };\n  }\n\n  /**\n   * Make a new Alarm for this metric\n   *\n   * Combines both properties that may adjust the metric (aggregation) as well\n   * as alarm properties.\n   */\n  public createAlarm(\n    scope: Construct,\n    id: string,\n    props: CreateAlarmOptions,\n  ): Alarm {\n    return new Alarm(scope, id, {\n      metric: this.with({\n        statistic: props.statistic,\n        period: props.period,\n      }),\n      alarmName: props.alarmName,\n      alarmDescription: props.alarmDescription,\n      comparisonOperator: props.comparisonOperator,\n      datapointsToAlarm: props.datapointsToAlarm,\n      threshold: props.threshold,\n      evaluationPeriods: props.evaluationPeriods,\n      evaluateLowSampleCountPercentile: props.evaluateLowSampleCountPercentile,\n      treatMissingData: props.treatMissingData,\n      actionsEnabled: props.actionsEnabled,\n    });\n  }\n\n  public toString() {\n    return this.label || this.metricName;\n  }\n\n  private validateDimensions(dims?: DimensionsMap): DimensionsMap | undefined {\n    if (!dims) {\n      return dims;\n    }\n\n    var dimsArray = Object.keys(dims);\n    if (dimsArray?.length > 30) {\n      throw new Error(\n        `The maximum number of dimensions is 30, received ${dimsArray.length}`,\n      );\n    }\n\n    dimsArray.map((key) => {\n      if (dims[key] === undefined || dims[key] === null) {\n        throw new Error(`Dimension value of '${dims[key]}' is invalid`);\n      }\n      if (key.length < 1 || key.length > 255) {\n        throw new Error(\n          `Dimension name must be at least 1 and no more than 255 characters; received ${key}`,\n        );\n      }\n\n      if (dims[key].length < 1 || dims[key].length > 255) {\n        throw new Error(\n          `Dimension value must be at least 1 and no more than 255 characters; received ${dims[key]}`,\n        );\n      }\n    });\n\n    return dims;\n  }\n}\n\nfunction asString(x?: unknown): string | undefined {\n  if (x === undefined) {\n    return undefined;\n  }\n  if (typeof x !== \"string\") {\n    throw new Error(`Expected string, got ${x}`);\n  }\n  return x;\n}\n\n/**\n * A math expression built with metric(s) emitted by a service\n *\n * The math expression is a combination of an expression (x+y) and metrics to apply expression on.\n * It also contains metadata which is used only in graphs, such as color and label.\n * It makes sense to embed this in here, so that compound constructs can attach\n * that metadata to metrics they expose.\n *\n * MathExpression can also be used for search expressions. In this case,\n * it also optionally accepts a searchRegion and searchAccount property for cross-environment\n * search expressions.\n *\n * This class does not represent a resource, so hence is not a construct. Instead,\n * MathExpression is an abstraction that makes it easy to specify metrics for use in both\n * alarms and graphs.\n */\nexport class MathExpression implements IMetric {\n  /**\n   * The expression defining the metric.\n   */\n  public readonly expression: string;\n\n  /**\n   * The metrics used in the expression as KeyValuePair <id, metric>.\n   */\n  public readonly usingMetrics: Record<string, IMetric>;\n\n  /**\n   * Label for this metric when added to a Graph.\n   */\n  public readonly label?: string;\n\n  /**\n   * The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph.\n   * The `Color` class has a set of standard colors that can be used here.\n   */\n  public readonly color?: string;\n\n  /**\n   * Aggregation period of this metric\n   */\n  public readonly period: Duration;\n\n  /**\n   * Account to evaluate search expressions within.\n   */\n  public readonly searchAccount?: string;\n\n  /**\n   * Region to evaluate search expressions within.\n   */\n  public readonly searchRegion?: string;\n\n  /**\n   * Warnings generated by this math expression\n   * @deprecated - use warningsV2\n   */\n  public readonly warnings?: string[];\n\n  /**\n   * Warnings generated by this math expression\n   */\n  public readonly warningsV2?: { [id: string]: string };\n\n  constructor(props: MathExpressionProps) {\n    this.period = props.period || Duration.minutes(5);\n    this.expression = props.expression;\n    this.label = props.label;\n    this.color = props.color;\n    this.searchAccount = props.searchAccount;\n    this.searchRegion = props.searchRegion;\n\n    const { record, overridden } = changeAllPeriods(\n      props.usingMetrics ?? {},\n      this.period,\n    );\n    this.usingMetrics = record;\n\n    const warnings: { [id: string]: string } = {};\n    if (overridden) {\n      warnings[\"CloudWatch:Math:MetricsPeriodsOverridden\"] =\n        `Periods of metrics in 'usingMetrics' for Math expression '${this.expression}' have been overridden to ${this.period.toSeconds()} seconds.`;\n    }\n\n    const invalidVariableNames = Object.keys(this.usingMetrics).filter(\n      (x) => !validVariableName(x),\n    );\n    if (invalidVariableNames.length > 0) {\n      throw new Error(\n        `Invalid variable names in expression: ${invalidVariableNames}. Must start with lowercase letter and only contain alphanumerics.`,\n      );\n    }\n\n    this.validateNoIdConflicts();\n\n    // Check that all IDs used in the expression are also in the `usingMetrics` map. We\n    // can't throw on this anymore since we didn't use to do this validation from the start\n    // and now there will be loads of people who are violating the expected contract, but\n    // we can add warnings.\n    const missingIdentifiers = allIdentifiersInExpression(\n      this.expression,\n    ).filter((i) => !this.usingMetrics[i]);\n\n    if (\n      !this.expression\n        .toUpperCase()\n        .match(\"\\\\s*INSIGHT_RULE_METRIC|SELECT|SEARCH|METRICS\\\\s.*\") &&\n      missingIdentifiers.length > 0\n    ) {\n      warnings[\"CloudWatch:Math:UnknownIdentifier\"] =\n        `Math expression '${this.expression}' references unknown identifiers: ${missingIdentifiers.join(\", \")}. Please add them to the 'usingMetrics' map.`;\n    }\n\n    // Also copy warnings from deeper levels so graphs, alarms only have to inspect the top-level objects\n    for (const m of Object.values(this.usingMetrics)) {\n      for (const [id, message] of Object.entries(m.warningsV2 ?? {})) {\n        warnings[id] = message;\n      }\n    }\n\n    if (Object.keys(warnings).length > 0) {\n      this.warnings = Array.from(Object.values(warnings));\n      this.warningsV2 = warnings;\n    }\n  }\n\n  /**\n   * Return a copy of Metric with properties changed.\n   *\n   * All properties except namespace and metricName can be changed.\n   *\n   * @param props The set of properties to change.\n   */\n  public with(props: MathExpressionOptions): MathExpression {\n    // Short-circuit creating a new object if there would be no effective change\n    if (\n      (props.label === undefined || props.label === this.label) &&\n      (props.color === undefined || props.color === this.color) &&\n      (props.period === undefined ||\n        props.period.toSeconds() === this.period.toSeconds()) &&\n      (props.searchAccount === undefined ||\n        props.searchAccount === this.searchAccount) &&\n      (props.searchRegion === undefined ||\n        props.searchRegion === this.searchRegion)\n    ) {\n      return this;\n    }\n\n    return new MathExpression({\n      expression: this.expression,\n      usingMetrics: this.usingMetrics,\n      label: ifUndefined(props.label, this.label),\n      color: ifUndefined(props.color, this.color),\n      period: ifUndefined(props.period, this.period),\n      searchAccount: ifUndefined(props.searchAccount, this.searchAccount),\n      searchRegion: ifUndefined(props.searchRegion, this.searchRegion),\n    });\n  }\n\n  /**\n   * @deprecated use toMetricConfig()\n   */\n  public toAlarmConfig(): MetricAlarmConfig {\n    throw new Error(\n      \"Using a math expression is not supported here. Pass a 'Metric' object instead\",\n    );\n  }\n\n  /**\n   * @deprecated use toMetricConfig()\n   */\n  public toGraphConfig(): MetricGraphConfig {\n    throw new Error(\n      \"Using a math expression is not supported here. Pass a 'Metric' object instead\",\n    );\n  }\n\n  public toMetricConfig(): MetricConfig {\n    return {\n      mathExpression: {\n        period: this.period.toSeconds(),\n        expression: this.expression,\n        usingMetrics: this.usingMetrics,\n        searchAccount: this.searchAccount,\n        searchRegion: this.searchRegion,\n      },\n      renderingProperties: {\n        label: this.label,\n        color: this.color,\n      },\n    };\n  }\n\n  /**\n   * Make a new Alarm for this metric\n   *\n   * Combines both properties that may adjust the metric (aggregation) as well\n   * as alarm properties.\n   */\n  public createAlarm(\n    scope: Construct,\n    id: string,\n    props: CreateAlarmOptions,\n  ): Alarm {\n    return new Alarm(scope, id, {\n      metric: this.with({\n        period: props.period,\n      }),\n      alarmName: props.alarmName,\n      alarmDescription: props.alarmDescription,\n      comparisonOperator: props.comparisonOperator,\n      datapointsToAlarm: props.datapointsToAlarm,\n      threshold: props.threshold,\n      evaluationPeriods: props.evaluationPeriods,\n      evaluateLowSampleCountPercentile: props.evaluateLowSampleCountPercentile,\n      treatMissingData: props.treatMissingData,\n      actionsEnabled: props.actionsEnabled,\n    });\n  }\n\n  public toString() {\n    return this.label || this.expression;\n  }\n\n  private validateNoIdConflicts() {\n    const seen = new Map<string, IMetric>();\n    visit(this);\n\n    function visit(metric: IMetric) {\n      dispatchMetric(metric, {\n        withStat() {\n          // Nothing\n        },\n        withExpression(expr) {\n          for (const [id, subMetric] of Object.entries(expr.usingMetrics)) {\n            const existing = seen.get(id);\n            if (existing && metricKey(existing) !== metricKey(subMetric)) {\n              throw new Error(\n                `The ID '${id}' used for two metrics in the expression: '${subMetric}' and '${existing}'. Rename one.`,\n              );\n            }\n            seen.set(id, subMetric);\n            visit(subMetric);\n          }\n        },\n      });\n    }\n  }\n}\n\n/**\n * Pattern for a variable name. Alphanum starting with lowercase.\n */\nconst VARIABLE_PAT = \"[a-z][a-zA-Z0-9_]*\";\n\nconst VALID_VARIABLE = new RegExp(`^${VARIABLE_PAT}$`);\nconst FIND_VARIABLE = new RegExp(VARIABLE_PAT, \"g\");\n\nfunction validVariableName(x: string) {\n  return VALID_VARIABLE.test(x);\n}\n\n/**\n * Return all variable names used in an expression\n */\nfunction allIdentifiersInExpression(x: string) {\n  return Array.from(matchAll(x, FIND_VARIABLE)).map((m) => m[0]);\n}\n\n/**\n * Properties needed to make an alarm from a metric\n */\nexport interface CreateAlarmOptions {\n  /**\n   * The period over which the specified statistic is applied.\n   *\n   * Cannot be used with `MathExpression` objects.\n   *\n   * @default - The period from the metric\n   * @deprecated Use `metric.with({ period: ... })` to encode the period into the Metric object\n   */\n  readonly period?: Duration;\n\n  /**\n   * What function to use for aggregating.\n   *\n   * Can be one of the following:\n   *\n   * - \"Minimum\" | \"min\"\n   * - \"Maximum\" | \"max\"\n   * - \"Average\" | \"avg\"\n   * - \"Sum\" | \"sum\"\n   * - \"SampleCount | \"n\"\n   * - \"pNN.NN\"\n   *\n   * Cannot be used with `MathExpression` objects.\n   *\n   * @default - The statistic from the metric\n   * @deprecated Use `metric.with({ statistic: ... })` to encode the period into the Metric object\n   */\n  readonly statistic?: string;\n\n  /**\n   * Name of the alarm\n   *\n   * @default Automatically generated name\n   */\n  readonly alarmName?: string;\n\n  /**\n   * Description for the alarm\n   *\n   * @default No description\n   */\n  readonly alarmDescription?: string;\n\n  /**\n   * Comparison to use to check if metric is breaching\n   *\n   * @default GreaterThanOrEqualToThreshold\n   */\n  readonly comparisonOperator?: ComparisonOperator;\n\n  /**\n   * The value against which the specified statistic is compared.\n   */\n  readonly threshold: number;\n\n  /**\n   * The number of periods over which data is compared to the specified threshold.\n   */\n  readonly evaluationPeriods: number;\n\n  /**\n   * Specifies whether to evaluate the data and potentially change the alarm state if there are too few data points to be statistically significant.\n   *\n   * Used only for alarms that are based on percentiles.\n   *\n   * @default - Not configured.\n   */\n  readonly evaluateLowSampleCountPercentile?: string;\n\n  /**\n   * Sets how this alarm is to handle missing data points.\n   *\n   * @default TreatMissingData.Missing\n   */\n  readonly treatMissingData?: TreatMissingData;\n\n  /**\n   * Whether the actions for this alarm are enabled\n   *\n   * @default true\n   */\n  readonly actionsEnabled?: boolean;\n\n  /**\n   * The number of datapoints that must be breaching to trigger the alarm. This is used only if you are setting an \"M\n   * out of N\" alarm. In that case, this value is the M. For more information, see Evaluating an Alarm in the Amazon\n   * CloudWatch User Guide.\n   *\n   * @default ``evaluationPeriods``\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarm-evaluation\n   */\n  readonly datapointsToAlarm?: number;\n}\n\nfunction ifUndefined<T>(x: T | undefined, def: T | undefined): T | undefined {\n  if (x !== undefined) {\n    return x;\n  }\n  return def;\n}\n\n/**\n * Change periods of all metrics in the map\n */\nfunction changeAllPeriods(\n  metrics: Record<string, IMetric>,\n  period: Duration,\n): { record: Record<string, IMetric>; overridden: boolean } {\n  const retRecord: Record<string, IMetric> = {};\n  let retOverridden = false;\n  for (const [id, m] of Object.entries(metrics)) {\n    const { metric, overridden } = changePeriod(m, period);\n    retRecord[id] = metric;\n    if (overridden) {\n      retOverridden = true;\n    }\n  }\n  return { record: retRecord, overridden: retOverridden };\n}\n\n/**\n * Return a new metric object which is the same type as the input object but with the period changed,\n * and a flag to indicate whether the period has been overwritten.\n *\n * Relies on the fact that implementations of `IMetric` are also supposed to have\n * an implementation of `with` that accepts an argument called `period`. See `IModifiableMetric`.\n */\nfunction changePeriod(\n  metric: IMetric,\n  period: Duration,\n): { metric: IMetric; overridden: boolean } {\n  if (isModifiableMetric(metric)) {\n    const overridden =\n      isMetricWithPeriod(metric) && // always true, as the period property is set with a default value even if it is not specified\n      metric.period.toSeconds() !== Duration.minutes(5).toSeconds() && // exclude the default value of a metric, assuming the user has not specified it\n      metric.period.toSeconds() !== period.toSeconds();\n    return { metric: metric.with({ period }), overridden };\n  }\n\n  throw new Error(`Metric object should also implement 'with': ${metric}`);\n}\n\n/**\n * Private protocol for metrics\n *\n * Metric types used in a MathExpression need to implement at least this:\n * a `with` method that takes at least a `period` and returns a modified copy\n * of the metric object.\n *\n * We put it here instead of on `IMetric` because there is no way to type\n * it in jsii in a way that concrete implementations `Metric` and `MathExpression`\n * can be statically typable about the fields that are changeable: all\n * `with` methods would need to take the same argument type, but not all\n * classes have the same `with`-able properties.\n *\n * This class exists to prevent having to use `instanceof` in the `changePeriod`\n * function, so that we have a system where in principle new implementations\n * of `IMetric` can be added. Because it will be rare, the mechanism doesn't have\n * to be exposed very well, just has to be possible.\n */\ninterface IModifiableMetric {\n  with(options: { period?: Duration }): IMetric;\n}\n\nfunction isModifiableMetric(m: any): m is IModifiableMetric {\n  return typeof m === \"object\" && m !== null && !!m.with;\n}\n\ninterface IMetricWithPeriod {\n  period: Duration;\n}\n\nfunction isMetricWithPeriod(m: any): m is IMetricWithPeriod {\n  return typeof m === \"object\" && m !== null && !!m.period;\n}\n\n// Polyfill for string.matchAll(regexp)\nfunction matchAll(x: string, re: RegExp): RegExpMatchArray[] {\n  const ret = new Array<RegExpMatchArray>();\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(x))) {\n    ret.push(m);\n  }\n  return ret;\n}\n"]}