terraconstructs 0.0.8

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

@@ -0,0 +1,84 @@
+import { IAwsConstruct, AwsConstructBase } from "../aws-construct";
+import { IAlarmAction } from "./alarm-action";
+/**
+ * Interface for Alarm Rule.
+ */
+export interface IAlarmRule {
+    /**
+     * serialized representation of Alarm Rule to be used when building the Composite Alarm resource.
+     */
+    renderAlarmRule(): string;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface AlarmOutputs {
+    /**
+     * Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:Foo)
+     *
+     * @attribute
+     */
+    readonly alarmArn: string;
+    /**
+     * Name of the alarm
+     *
+     * @attribute
+     */
+    readonly alarmName: string;
+}
+/**
+ * Represents a CloudWatch Alarm
+ */
+export interface IAlarm extends IAlarmRule, IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly alarmOutputs: AlarmOutputs;
+    /**
+     * Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:Foo)
+     *
+     * @attribute
+     */
+    readonly alarmArn: string;
+    /**
+     * Name of the alarm
+     *
+     * @attribute
+     */
+    readonly alarmName: string;
+}
+/**
+ * The base class for Alarm and CompositeAlarm resources.
+ */
+export declare abstract class AlarmBase extends AwsConstructBase implements IAlarm {
+    /**
+     * @attribute
+     */
+    abstract readonly alarmArn: string;
+    abstract readonly alarmName: string;
+    get alarmOutputs(): AlarmOutputs;
+    get outputs(): Record<string, any>;
+    protected alarmActionArns?: string[];
+    protected insufficientDataActionArns?: string[];
+    protected okActionArns?: string[];
+    /**
+     * AlarmRule indicating ALARM state for Alarm.
+     */
+    renderAlarmRule(): string;
+    /**
+     * Trigger this action if the alarm fires
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addAlarmAction(...actions: IAlarmAction[]): void;
+    /**
+     * Trigger this action if there is insufficient data to evaluate the alarm
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addInsufficientDataAction(...actions: IAlarmAction[]): void;
+    /**
+     * Trigger this action if the alarm returns from breaching state into ok state
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addOkAction(...actions: IAlarmAction[]): void;
+}

package/lib/aws/cloudwatch/alarm-base.js

@@ -0,0 +1,64 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlarmBase = 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-base.ts
+const aws_construct_1 = require("../aws-construct");
+/**
+ * The base class for Alarm and CompositeAlarm resources.
+ */
+class AlarmBase extends aws_construct_1.AwsConstructBase {
+    get alarmOutputs() {
+        return {
+            alarmArn: this.alarmArn,
+            alarmName: this.alarmName,
+        };
+    }
+    get outputs() {
+        return this.alarmOutputs;
+    }
+    /**
+     * AlarmRule indicating ALARM state for Alarm.
+     */
+    renderAlarmRule() {
+        return `ALARM("${this.alarmArn}")`;
+    }
+    /**
+     * 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) => a.bind(this, this).alarmActionArn));
+    }
+    /**
+     * Trigger this action if there is insufficient data to evaluate the alarm
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addInsufficientDataAction(...actions) {
+        if (this.insufficientDataActionArns === undefined) {
+            this.insufficientDataActionArns = [];
+        }
+        this.insufficientDataActionArns.push(...actions.map((a) => a.bind(this, this).alarmActionArn));
+    }
+    /**
+     * Trigger this action if the alarm returns from breaching state into ok state
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addOkAction(...actions) {
+        if (this.okActionArns === undefined) {
+            this.okActionArns = [];
+        }
+        this.okActionArns.push(...actions.map((a) => a.bind(this, this).alarmActionArn));
+    }
+}
+exports.AlarmBase = AlarmBase;
+_a = JSII_RTTI_SYMBOL_1;
+AlarmBase[_a] = { fqn: "terraconstructs.aws.cloudwatch.AlarmBase", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+import { IAlarm, IAlarmRule } from "./alarm-base";
+/**
+ * Enumeration indicates state of Alarm used in building Alarm Rule.
+ */
+export declare enum AlarmState {
+    /**
+     * State indicates resource is in ALARM
+     */
+    ALARM = "ALARM",
+    /**
+     * State indicates resource is not in ALARM
+     */
+    OK = "OK",
+    /**
+     * State indicates there is not enough data to determine is resource is in ALARM
+     */
+    INSUFFICIENT_DATA = "INSUFFICIENT_DATA"
+}
+/**
+ * Class with static functions to build AlarmRule for Composite Alarms.
+ */
+export declare class AlarmRule {
+    /**
+     * function to join all provided AlarmRules with AND operator.
+     *
+     * @param operands IAlarmRules to be joined with AND operator.
+     */
+    static allOf(...operands: IAlarmRule[]): IAlarmRule;
+    /**
+     * function to join all provided AlarmRules with OR operator.
+     *
+     * @param operands IAlarmRules to be joined with OR operator.
+     */
+    static anyOf(...operands: IAlarmRule[]): IAlarmRule;
+    /**
+     * function to wrap provided AlarmRule in NOT operator.
+     *
+     * @param operand IAlarmRule to be wrapped in NOT operator.
+     */
+    static not(operand: IAlarmRule): IAlarmRule;
+    /**
+     * function to build TRUE/FALSE intent for Rule Expression.
+     *
+     * @param value boolean value to be used in rule expression.
+     */
+    static fromBoolean(value: boolean): IAlarmRule;
+    /**
+     * function to build Rule Expression for given IAlarm and AlarmState.
+     *
+     * @param alarm IAlarm to be used in Rule Expression.
+     * @param alarmState AlarmState to be used in Rule Expression.
+     */
+    static fromAlarm(alarm: IAlarm, alarmState: AlarmState): IAlarmRule;
+    /**
+     * function to build Rule Expression for given Alarm Rule string.
+     *
+     * @param alarmRule string to be used in Rule Expression.
+     */
+    static fromString(alarmRule: string): IAlarmRule;
+    private static concat;
+}

package/lib/aws/cloudwatch/alarm-rule.js

@@ -0,0 +1,116 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlarmRule = exports.AlarmState = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Enumeration indicates state of Alarm used in building Alarm Rule.
+ */
+var AlarmState;
+(function (AlarmState) {
+    /**
+     * State indicates resource is in ALARM
+     */
+    AlarmState["ALARM"] = "ALARM";
+    /**
+     * State indicates resource is not in ALARM
+     */
+    AlarmState["OK"] = "OK";
+    /**
+     * State indicates there is not enough data to determine is resource is in ALARM
+     */
+    AlarmState["INSUFFICIENT_DATA"] = "INSUFFICIENT_DATA";
+})(AlarmState || (exports.AlarmState = AlarmState = {}));
+/**
+ * Enumeration of supported Composite Alarms operators.
+ */
+var Operator;
+(function (Operator) {
+    Operator["AND"] = "AND";
+    Operator["OR"] = "OR";
+    Operator["NOT"] = "NOT";
+})(Operator || (Operator = {}));
+/**
+ * Class with static functions to build AlarmRule for Composite Alarms.
+ */
+class AlarmRule {
+    /**
+     * function to join all provided AlarmRules with AND operator.
+     *
+     * @param operands IAlarmRules to be joined with AND operator.
+     */
+    static allOf(...operands) {
+        return this.concat(Operator.AND, ...operands);
+    }
+    /**
+     * function to join all provided AlarmRules with OR operator.
+     *
+     * @param operands IAlarmRules to be joined with OR operator.
+     */
+    static anyOf(...operands) {
+        return this.concat(Operator.OR, ...operands);
+    }
+    /**
+     * function to wrap provided AlarmRule in NOT operator.
+     *
+     * @param operand IAlarmRule to be wrapped in NOT operator.
+     */
+    static not(operand) {
+        return new (class {
+            renderAlarmRule() {
+                return `(NOT (${operand.renderAlarmRule()}))`;
+            }
+        })();
+    }
+    /**
+     * function to build TRUE/FALSE intent for Rule Expression.
+     *
+     * @param value boolean value to be used in rule expression.
+     */
+    static fromBoolean(value) {
+        return new (class {
+            renderAlarmRule() {
+                return `${String(value).toUpperCase()}`;
+            }
+        })();
+    }
+    /**
+     * function to build Rule Expression for given IAlarm and AlarmState.
+     *
+     * @param alarm IAlarm to be used in Rule Expression.
+     * @param alarmState AlarmState to be used in Rule Expression.
+     */
+    static fromAlarm(alarm, alarmState) {
+        return new (class {
+            renderAlarmRule() {
+                return `${alarmState}("${alarm.alarmArn}")`;
+            }
+        })();
+    }
+    /**
+     * function to build Rule Expression for given Alarm Rule string.
+     *
+     * @param alarmRule string to be used in Rule Expression.
+     */
+    static fromString(alarmRule) {
+        return new (class {
+            renderAlarmRule() {
+                return alarmRule;
+            }
+        })();
+    }
+    static concat(operator, ...operands) {
+        return new (class {
+            renderAlarmRule() {
+                const expression = operands
+                    .map((operand) => `${operand.renderAlarmRule()}`)
+                    .join(` ${operator} `);
+                return `(${expression})`;
+            }
+        })();
+    }
+}
+exports.AlarmRule = AlarmRule;
+_a = JSII_RTTI_SYMBOL_1;
+AlarmRule[_a] = { fqn: "terraconstructs.aws.cloudwatch.AlarmRule", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/alarm-status-widget.d.ts

@@ -0,0 +1,77 @@
+import { Construct } from "constructs";
+import { IAlarm } from "./alarm-base";
+import { AlarmState } from "./alarm-rule";
+import { ConcreteWidget } from "./widget";
+/**
+ * The sort possibilities for AlarmStatusWidgets
+ */
+export declare enum AlarmStatusWidgetSortBy {
+    /**
+     * Choose DEFAULT to sort them in alphabetical order by alarm name.
+     */
+    DEFAULT = "default",
+    /**
+     * Choose STATE_UPDATED_TIMESTAMP to sort them first by alarm state, with alarms in ALARM state first,
+     * INSUFFICIENT_DATA alarms next, and OK alarms last.
+     * Within each group, the alarms are sorted by when they last changed state, with more recent state changes listed first.
+     */
+    STATE_UPDATED_TIMESTAMP = "stateUpdatedTimestamp",
+    /**
+     * Choose TIMESTAMP to sort them by the time when the alarms most recently changed state,
+     * no matter the current alarm state.
+     * The alarm that changed state most recently is listed first.
+     */
+    TIMESTAMP = "timestamp"
+}
+/**
+ * Properties for an Alarm Status Widget
+ */
+export interface AlarmStatusWidgetProps {
+    /**
+     * CloudWatch Alarms to show in widget
+     */
+    readonly alarms: IAlarm[];
+    /**
+     * The title of the widget
+     *
+     * @default 'Alarm Status'
+     */
+    readonly title?: string;
+    /**
+     * Width of the widget, in a grid of 24 units wide
+     *
+     * @default 6
+     */
+    readonly width?: number;
+    /**
+     * Height of the widget
+     *
+     * @default 3
+     */
+    readonly height?: number;
+    /**
+     * Specifies how to sort the alarms in the widget.
+     *
+     * @default - alphabetical order
+     */
+    readonly sortBy?: AlarmStatusWidgetSortBy;
+    /**
+     * Use this field to filter the list of alarms displayed in the widget to only those alarms currently in the specified states.
+     * You can specify one or more alarm states in the value for this field.
+     * The alarm states that you can specify are ALARM, INSUFFICIENT_DATA, and OK.
+     *
+     * If you omit this field or specify an empty array, all the alarms specifed in alarms are displayed.
+     *
+     * @default -  all the alarms specified in alarms are displayed.
+     */
+    readonly states?: AlarmState[];
+}
+/**
+ * A dashboard widget that displays alarms in a grid view
+ */
+export declare class AlarmStatusWidget extends ConcreteWidget {
+    private readonly props;
+    constructor(scope: Construct, props: AlarmStatusWidgetProps);
+    position(x: number, y: number): void;
+    toJson(): any[];
+}

package/lib/aws/cloudwatch/alarm-status-widget.js

@@ -0,0 +1,62 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlarmStatusWidget = exports.AlarmStatusWidgetSortBy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const widget_1 = require("./widget");
+/**
+ * The sort possibilities for AlarmStatusWidgets
+ */
+var AlarmStatusWidgetSortBy;
+(function (AlarmStatusWidgetSortBy) {
+    /**
+     * Choose DEFAULT to sort them in alphabetical order by alarm name.
+     */
+    AlarmStatusWidgetSortBy["DEFAULT"] = "default";
+    /**
+     * Choose STATE_UPDATED_TIMESTAMP to sort them first by alarm state, with alarms in ALARM state first,
+     * INSUFFICIENT_DATA alarms next, and OK alarms last.
+     * Within each group, the alarms are sorted by when they last changed state, with more recent state changes listed first.
+     */
+    AlarmStatusWidgetSortBy["STATE_UPDATED_TIMESTAMP"] = "stateUpdatedTimestamp";
+    /**
+     * Choose TIMESTAMP to sort them by the time when the alarms most recently changed state,
+     * no matter the current alarm state.
+     * The alarm that changed state most recently is listed first.
+     */
+    AlarmStatusWidgetSortBy["TIMESTAMP"] = "timestamp";
+})(AlarmStatusWidgetSortBy || (exports.AlarmStatusWidgetSortBy = AlarmStatusWidgetSortBy = {}));
+/**
+ * A dashboard widget that displays alarms in a grid view
+ */
+class AlarmStatusWidget extends widget_1.ConcreteWidget {
+    constructor(scope, props) {
+        super(scope, props.width || 6, props.height || 3);
+        this.props = props;
+    }
+    position(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    toJson() {
+        return [
+            {
+                type: "alarm",
+                width: this.width,
+                height: this.height,
+                x: this.x,
+                y: this.y,
+                properties: {
+                    title: this.props.title ? this.props.title : "Alarm Status",
+                    alarms: this.props.alarms.map((alarm) => alarm.alarmArn),
+                    states: this.props.states,
+                    sortBy: this.props.sortBy,
+                },
+            },
+        ];
+    }
+}
+exports.AlarmStatusWidget = AlarmStatusWidget;
+_a = JSII_RTTI_SYMBOL_1;
+AlarmStatusWidget[_a] = { fqn: "terraconstructs.aws.cloudwatch.AlarmStatusWidget", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,158 @@
+import { cloudwatchMetricAlarm } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructProps } from "../aws-construct";
+import { IAlarmAction } from "./alarm-action";
+import { AlarmBase, IAlarm } from "./alarm-base";
+import { HorizontalAnnotation } from "./graph";
+import { CreateAlarmOptions } from "./metric";
+import { IMetric } from "./metric-types";
+/**
+ * Properties for Alarms
+ */
+export interface AlarmProps extends CreateAlarmOptions, AwsConstructProps {
+    /**
+     * The metric to add the alarm on
+     *
+     * Metric objects can be obtained from most resources, or you can construct
+     * custom Metric objects by instantiating one.
+     */
+    readonly metric: IMetric;
+}
+/**
+ * Comparison operator for evaluating alarms
+ */
+export declare enum ComparisonOperator {
+    /**
+     * Specified statistic is greater than or equal to the threshold
+     */
+    GREATER_THAN_OR_EQUAL_TO_THRESHOLD = "GreaterThanOrEqualToThreshold",
+    /**
+     * Specified statistic is strictly greater than the threshold
+     */
+    GREATER_THAN_THRESHOLD = "GreaterThanThreshold",
+    /**
+     * Specified statistic is strictly less than the threshold
+     */
+    LESS_THAN_THRESHOLD = "LessThanThreshold",
+    /**
+     * Specified statistic is less than or equal to the threshold.
+     */
+    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
+     */
+    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
+     */
+    GREATER_THAN_UPPER_THRESHOLD = "GreaterThanUpperThreshold",
+    /**
+     * Specified statistic is lower than the anomaly model band.
+     * Used only for alarms based on anomaly detection models
+     */
+    LESS_THAN_LOWER_THRESHOLD = "LessThanLowerThreshold"
+}
+/**
+ * Specify how missing data points are treated during alarm evaluation
+ */
+export declare enum TreatMissingData {
+    /**
+     * Missing data points are treated as breaching the threshold
+     */
+    BREACHING = "breaching",
+    /**
+     * Missing data points are treated as being within the threshold
+     */
+    NOT_BREACHING = "notBreaching",
+    /**
+     * The current alarm state is maintained
+     */
+    IGNORE = "ignore",
+    /**
+     * The alarm does not consider missing data points when evaluating whether to change state
+     */
+    MISSING = "missing"
+}
+/**
+ * An alarm on a CloudWatch metric
+ */
+export declare class Alarm extends 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: Construct, id: string, alarmName: string): IAlarm;
+    /**
+     * 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: Construct, id: string, alarmArn: string): IAlarm;
+    readonly resource: cloudwatchMetricAlarm.CloudwatchMetricAlarm;
+    /**
+     * ARN of this alarm
+     *
+     * @attribute
+     */
+    readonly alarmArn: string;
+    /**
+     * Name of this alarm.
+     *
+     * @attribute
+     */
+    readonly alarmName: string;
+    /**
+     * The metric object this alarm was based on
+     */
+    readonly metric: IMetric;
+    /**
+     * This metric as an annotation
+     */
+    private readonly annotation;
+    constructor(scope: Construct, id: string, props: AlarmProps);
+    /**
+     * 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(): HorizontalAnnotation;
+    /**
+     * Trigger this action if the alarm fires
+     *
+     * Typically SnsAction or AutoScalingAction.
+     */
+    addAlarmAction(...actions: IAlarmAction[]): void;
+    private validateActionArn;
+    private renderMetric;
+    /**
+     * Validate that if a region is in the given stat config, they match the Alarm
+     */
+    private validateMetricStat;
+    /**
+     * Validates that the expression config does not specify searchAccount or searchRegion props
+     * as search expressions are not supported by Alarms.
+     */
+    private validateMetricExpression;
+    /**
+     * Determine if the accountId property should be included in the metric.
+     */
+    private requiresAccountId;
+}