@liflig/cdk 2.18.5 → 2.18.6

package/assets/prepare-cdk-source-lambda/index.py

@@ -0,0 +1,159 @@
+import datetime
+import json
+import os
+import re
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+
+import boto3
+from boto3.session import Session
+
+s3 = boto3.client("s3")
+codepipeline = boto3.client("codepipeline")
+ssm = boto3.client("ssm")
+
+
+def get_variables_from_parameters(namespace):
+    next_token = None
+    result = {}
+
+    prefix = f'/liflig-cdk/{namespace}/pipeline-variables/'
+    params = {
+        'Path': prefix,
+    }
+
+    while True:
+        if next_token is not None:
+            params['NextToken'] = next_token
+        response = ssm.get_parameters_by_path(**params)
+
+        parameters = response['Parameters']
+        if len(parameters) == 0:
+            break
+
+        for parameter in parameters:
+            result[parameter['Name'][len(prefix) :]] = parameter['Value']
+
+        if 'NextToken' not in response:
+            break
+        next_token = response['NextToken']
+
+    return result
+
+
+def handler(event, context):
+    job = event["CodePipeline.job"]
+    job_id = job["id"]
+
+    try:
+        user_parameters = json.loads(
+            job["data"]["actionConfiguration"]["configuration"]["UserParameters"]
+        )
+
+        files = s3.list_objects_v2(
+            Bucket=user_parameters["bucketName"],
+            Prefix=user_parameters["prefix"],
+        )
+
+        def get_data(key):
+            result = s3.get_object(Bucket=user_parameters["bucketName"], Key=key)
+            return result["Body"].read()
+
+        cdk_source_ref = None
+        now = datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc)
+        variables = {
+            # Special variable that can be used when reading variables
+            # to ensure it is not stale. In the pipeline, variables
+            # will never be stale, but locally it can be.
+            'variablesTimestamp': now.isoformat(),
+        }
+
+        for file in files.get("Contents", []):
+            key = file["Key"]
+            filename = key[len(user_parameters["prefix"]) :]
+
+            print(f"File: {filename}")
+
+            if filename == "cdk-source.json":
+                cdk_source_ref = json.loads(get_data(key))
+            elif re.match(r"^variables.*\.json$", filename):
+                # Legacy variables from S3 scoped only to this pipeline.
+                # Consider removing this later.
+                # See https://jira.capraconsulting.no/browse/CALS-408 for context
+                variables.update(json.loads(get_data(key)))
+            else:
+                print("Ignoring unknown file")
+
+        if cdk_source_ref is None:
+            raise Exception("cdk-source.json not found")
+
+        # Modern variables from Parameter Store.
+        variables.update(
+            get_variables_from_parameters(user_parameters["parametersNamespace"])
+        )
+
+        s3_loc = job["data"]["outputArtifacts"][0]["location"]["s3Location"]
+
+        temp_dir = tempfile.mkdtemp()
+
+        with tempfile.NamedTemporaryFile() as tmp_file:
+            s3.download_file(
+                Bucket=cdk_source_ref["bucketName"],
+                Key=cdk_source_ref["bucketKey"],
+                Filename=tmp_file.name,
+            )
+
+            print(f"Downloaded zip size: {os.path.getsize(tmp_file.name)}")
+
+            with zipfile.ZipFile(tmp_file.name, "r") as zip_file:
+                zip_file.extractall(temp_dir)
+
+        for name, value in variables.items():
+            print(f"Variable: {name}={value}")
+
+        Path(os.path.join(temp_dir, "variables.json")).write_text(json.dumps(variables))
+
+        with tempfile.NamedTemporaryFile() as tmp_file:
+            with zipfile.ZipFile(tmp_file.name, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                for root, dirs, files in os.walk(temp_dir):
+                    for file in files:
+                        fullpath = os.path.join(root, file)
+                        arcname = str(Path(fullpath).relative_to(temp_dir))
+                        print(f"Adding {arcname}")
+                        zip_file.write(filename=fullpath, arcname=arcname)
+
+            credentials = job["data"]["artifactCredentials"]
+            s3_upload_client = Session(
+                aws_access_key_id=credentials["accessKeyId"],
+                aws_secret_access_key=credentials["secretAccessKey"],
+                aws_session_token=credentials["sessionToken"],
+            ).client("s3")
+
+            print(f"Generated zip size: {os.path.getsize(tmp_file.name)}")
+
+            s3_upload_client.upload_file(
+                Filename=tmp_file.name,
+                Bucket=s3_loc["bucketName"],
+                Key=s3_loc["objectKey"],
+            )
+
+        shutil.rmtree(temp_dir)
+
+        codepipeline.put_job_success_result(
+            jobId=job_id,
+        )
+
+        print("Success")
+    except Exception as e:
+        codepipeline.put_job_failure_result(
+            jobId=job_id,
+            failureDetails={
+                "message": str(e),
+                "type": "JobFailed",
+                "externalExecutionId": context.aws_request_id,
+            },
+        )
+
+        print(f"Failed: ${e}")

package/assets/slack-alarm-lambda/index.py

@@ -0,0 +1,103 @@
+import json
+import os
+from urllib.request import Request, urlopen
+from urllib.error import URLError, HTTPError
+
+import boto3
+
+secrets_manager = boto3.client("secretsmanager")
+
+SLACK_URL_SECRET_NAME = os.getenv("SLACK_URL_SECRET_NAME", None)
+PROJECT_NAME = os.getenv("PROJECT_NAME", "undefined")
+ENVIRONMENT_NAME = os.getenv("ENVIRONMENT_NAME", "undefined")
+
+
+def handler(event, context):
+    print("Event: " + json.dumps(event))
+    message = json.loads(event["Records"][0]["Sns"]["Message"])
+    region = event["Records"][0]["Sns"]["TopicArn"].split(":")[3]
+
+    return send_slack_notification(message, region)
+
+
+def get_masked_slack_webhook_url(slack_webhook_url: str):
+    """
+    Return a string that masks the final path segment of a Slack webhook URL.
+    The URL is typically formatted as such: https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
+    """
+    trimmed_url = slack_webhook_url.rstrip("/")
+    [*url, final_path_segment] = trimmed_url.split("/")
+    return "/".join(url + [len(final_path_segment) * "*"])
+
+
+def get_secret(secret):
+    try:
+        return secrets_manager.get_secret_value(SecretId=secret)["SecretString"]
+    except Exception as e:
+        raise Exception(f"Error retrieving secret: {e}")
+
+
+def send_slack_notification(message, region):
+    alarm_emojis = {
+        "ALARM": ":rotating_light:",
+        "INSUFFICIENT_DATA": ":warning:",
+        "OK": ":white_check_mark:",
+    }
+    if message["NewStateValue"] == "ALARM":
+        color = "danger"
+    else:
+        color = "good"
+    alarm_description = message["AlarmDescription"] or "Alarm is missing description"
+    attachments = [
+        {
+            "color": color,
+            "title_link": "https://console.aws.amazon.com/cloudwatch/home?region="
+            + region
+            + "#alarm:alarmFilter=ANY;name="
+            + message["AlarmName"],
+            "fallback": f"{alarm_emojis.get(message['NewStateValue'], '')} {message['AlarmName']}: {alarm_description}",
+            "fields": [
+                {"title": "Alarm Name", "value": message["AlarmName"], "short": False},
+                {
+                    "title": "Alarm Description",
+                    "value": alarm_description,
+                    "short": False,
+                },
+                {"title": "Account", "value": message["AWSAccountId"], "short": True},
+                {"title": "Region", "value": region, "short": True},
+                {"title": "Project", "value": PROJECT_NAME, "short": True},
+                {"title": "Environment", "value": ENVIRONMENT_NAME, "short": True},
+                {
+                    "title": "State Transition",
+                    "value": message.get("OldStateValue", "Unknown")
+                    + " -> "
+                    + message["NewStateValue"],
+                    "short": False,
+                },
+                {
+                    "title": "Link to Alarm",
+                    "value": "https://console.aws.amazon.com/cloudwatch/home?region="
+                    + region
+                    + "#alarm:alarmFilter=ANY;name="
+                    + message["AlarmName"],
+                    "short": False,
+                },
+            ],
+        }
+    ]
+
+    slackMessage = {
+        "attachments": attachments,
+    }
+
+    slack_url = get_secret(SLACK_URL_SECRET_NAME)
+
+    req = Request(slack_url, json.dumps(slackMessage).encode("utf-8"))
+    print(f"Posting message to Slack URL {get_masked_slack_webhook_url(slack_url)}")
+    try:
+        response = urlopen(req)
+        response.read()
+    except HTTPError as e:
+        raise Exception(f"Request to slack failed: {e.code} {e.reason}")
+    except URLError as e:
+        raise Exception(f"Server connection to slack failed: {e.reason}")

package/lib/alarms/database-alarms.d.ts

@@ -0,0 +1,125 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+export interface DatabaseAlarmsProps {
+    /**
+     * The default action to use for CloudWatch alarm state changes
+     */
+    action: cloudwatch.IAlarmAction;
+    instanceIdentifier: string;
+    instanceType: ec2.InstanceType;
+    allocatedStorage: cdk.Size;
+}
+export declare class DatabaseAlarms extends constructs.Construct {
+    private readonly action;
+    private readonly databaseInstanceIdentifier;
+    private readonly instanceType;
+    private readonly allocatedStorage;
+    constructor(scope: constructs.Construct, id: string, props: DatabaseAlarmsProps);
+    /**
+     * Sets up a CloudWatch Alarm that triggers if the CPU credit balance for
+     * a burstable instance breach a certain threshold.
+     *
+     * NOTE: This alarm is only applicable for burstable instances, and a balance of 0 credits will only have performance
+     * implications for T2 instances. T3 and T4g instances will instead cost more for prolonged high CPU utilization after
+     * the balance is depleted.
+     */
+    addCpuCreditsAlarm(
+    /**
+     * Configuration for an alarm.
+     *
+     * @default Configured with sane defaults.
+     */
+    props?: {
+        /**
+         * An action to use for CloudWatch alarm state changes instead of the default action
+         */
+        action?: cloudwatch.IAlarmAction;
+        /**
+         * The CloudWatch Alarm will change its state to ALARM if the number of CPU credits drops below this threshold.
+         *
+         * See https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html#earning-CPU-credits for an overview of maximum CPU credits for various instance types.
+         *
+         * @default 10% of the maximum earned CPU credits for the instance type.
+         */
+        threshold?: number;
+    }): void;
+    /**
+     * Sets up two CloudWatch Alarms for monitoring disk storage space:
+     * 1) one that triggers if the available disk storage space is low.
+     * 2) one that triggers if the available disk storage space is critcally low.
+     *
+     * You may want to use different alarm actions for the two alarms, e.g., one can be
+     * categorized as a "warning", while the other one can be considered an "alarm".
+     */
+    addStorageSpaceAlarms(props?: {
+        /**
+         * Configuration for an alarm.
+         *
+         * @default Configured with sane defaults.
+         */
+        lowStorageSpaceAlarm?: {
+            /**
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * An action to use for CloudWatch alarm state changes instead of the default action
+             */
+            action?: cloudwatch.IAlarmAction;
+            /**
+             * @default 25% of the allocated storage.
+             */
+            threshold?: cdk.Size;
+        };
+        /**
+         * Configuration for an alarm.
+         *
+         * @default Configured with sane defaults.
+         */
+        criticallyLowStorageSpaceAlarm?: {
+            /**
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * An action to use for CloudWatch alarm state changes instead of the default action
+             */
+            action?: cloudwatch.IAlarmAction;
+            /**
+             * @default 5% of the allocated storage.
+             */
+            threshold?: cdk.Size;
+        };
+    }): void;
+    /**
+     * Sets up a CloudWatch Alarm that triggers if the average CPU utilization for
+     * the RDS instance exceeds a given threshold.
+     */
+    addCpuUtilizationAlarm(
+    /**
+     * Configuration for an alarm.
+     *
+     * @default Configured with sane defaults.
+     */
+    props?: {
+        /**
+         * An action to use for CloudWatch alarm state changes instead of the default action
+         */
+        action?: cloudwatch.IAlarmAction;
+        /**
+         * The threshold defined as a percentage that determines if CPU utilization should trigger an alarm or not.
+         * @default 80
+         */
+        threshold?: number;
+        /**
+         * @default 5
+         */
+        evaluationPeriods?: number;
+        /**
+         * @default 2 minutes
+         */
+        period?: cdk.Duration;
+    }): void;
+}

package/lib/alarms/database-alarms.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseAlarms = void 0;
+const constructs = require("constructs");
+const cdk = require("aws-cdk-lib");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+// Based on https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html#earning-CPU-credits
+const cpuCreditBalanceByInstanceType = {
+    "t2.nano": 72,
+    "t2.micro": 144,
+    "t2.small": 288,
+    "t2.medium": 576,
+    "t2.large": 864,
+    "t2.xlarge": 1296,
+    "t2.2xlarge": 1958.4,
+    "t3.nano": 144,
+    "t3.micro": 288,
+    "t3.small": 576,
+    "t3.medium": 576,
+    "t3.large": 864,
+    "t3.xlarge": 2304,
+    "t3.2xlarge": 4608,
+    "t3a.nano": 144,
+    "t3a.micro": 288,
+    "t3a.small": 576,
+    "t3a.medium": 576,
+    "t3a.large": 864,
+    "t3a.xlarge": 2304,
+    "t3a.2xlarge": 4608,
+    "t4g.nano": 144,
+    "t4g.micro": 288,
+    "t4g.small": 576,
+    "t4g.medium": 576,
+    "t4g.large": 864,
+    "t4g.xlarge": 2304,
+    "t4g.2xlarge": 4608,
+};
+class DatabaseAlarms extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.action = props.action;
+        this.databaseInstanceIdentifier = props.instanceIdentifier;
+        this.instanceType = props.instanceType;
+        this.allocatedStorage = props.allocatedStorage;
+    }
+    /**
+     * Sets up a CloudWatch Alarm that triggers if the CPU credit balance for
+     * a burstable instance breach a certain threshold.
+     *
+     * NOTE: This alarm is only applicable for burstable instances, and a balance of 0 credits will only have performance
+     * implications for T2 instances. T3 and T4g instances will instead cost more for prolonged high CPU utilization after
+     * the balance is depleted.
+     */
+    addCpuCreditsAlarm(
+    /**
+     * Configuration for an alarm.
+     *
+     * @default Configured with sane defaults.
+     */
+    props) {
+        var _a;
+        if (!["t2.", "t3.", "t4g."].some((s) => this.instanceType.toString().startsWith(s))) {
+            throw new Error("CPU credits are only relevant for burstable instance types.");
+        }
+        const defaultThreshold = cpuCreditBalanceByInstanceType[this.instanceType.toString()] * 0.1;
+        const threshold = (_a = props === null || props === void 0 ? void 0 : props.threshold) !== null && _a !== void 0 ? _a : defaultThreshold;
+        if (!threshold) {
+            throw new Error(`No threshold supplied, and unable to determine a default value for instance type '${this.instanceType.toString()}'`);
+        }
+        new cloudwatch.Metric({
+            metricName: "CPUCreditBalance",
+            namespace: "AWS/RDS",
+            statistic: "Minimum",
+            period: cdk.Duration.minutes(5),
+            dimensionsMap: {
+                DBInstanceIdentifier: this.databaseInstanceIdentifier,
+            },
+        })
+            .createAlarm(this, "CreditsAlarm", {
+            alarmDescription: `Less than ${threshold} CPU credits remaining for RDS database '${this.databaseInstanceIdentifier}'. ${this.instanceType.toString().startsWith("t2.")
+                ? "If this reaches 0, the instance will be limited to a baseline CPU utilization."
+                : "If the balance is depleted, AWS adds additional charges."}.`,
+            comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,
+            evaluationPeriods: 1,
+            threshold: threshold,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        })
+            .addAlarmAction(this.action);
+    }
+    /**
+     * Sets up two CloudWatch Alarms for monitoring disk storage space:
+     * 1) one that triggers if the available disk storage space is low.
+     * 2) one that triggers if the available disk storage space is critcally low.
+     *
+     * You may want to use different alarm actions for the two alarms, e.g., one can be
+     * categorized as a "warning", while the other one can be considered an "alarm".
+     */
+    addStorageSpaceAlarms(props) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const lowStorageSpaceAlarm = new cloudwatch.Metric({
+            metricName: "FreeStorageSpace",
+            namespace: "AWS/RDS",
+            statistic: "Minimum",
+            period: cdk.Duration.minutes(5),
+            dimensionsMap: {
+                DBInstanceIdentifier: this.databaseInstanceIdentifier,
+            },
+        }).createAlarm(this, "LowStorageSpaceAlarm", {
+            alarmDescription: `Low storage space available on RDS database '${this.databaseInstanceIdentifier}'.`,
+            comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,
+            evaluationPeriods: 1,
+            threshold: (_c = (_b = (_a = props === null || props === void 0 ? void 0 : props.lowStorageSpaceAlarm) === null || _a === void 0 ? void 0 : _a.threshold) === null || _b === void 0 ? void 0 : _b.toBytes()) !== null && _c !== void 0 ? _c : this.allocatedStorage.toBytes() * 0.25,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        if ((_e = (_d = props === null || props === void 0 ? void 0 : props.lowStorageSpaceAlarm) === null || _d === void 0 ? void 0 : _d.enabled) !== null && _e !== void 0 ? _e : true) {
+            lowStorageSpaceAlarm.addAlarmAction(((_f = props === null || props === void 0 ? void 0 : props.lowStorageSpaceAlarm) === null || _f === void 0 ? void 0 : _f.action) || this.action);
+            lowStorageSpaceAlarm.addOkAction(((_g = props === null || props === void 0 ? void 0 : props.lowStorageSpaceAlarm) === null || _g === void 0 ? void 0 : _g.action) || this.action);
+        }
+        const criticallyLowStorageSpaceAlarm = new cloudwatch.Metric({
+            metricName: "FreeStorageSpace",
+            namespace: "AWS/RDS",
+            statistic: "Minimum",
+            period: cdk.Duration.minutes(5),
+            dimensionsMap: {
+                DBInstanceIdentifier: this.databaseInstanceIdentifier,
+            },
+        }).createAlarm(this, "CriticallyLowStorageSpaceAlarm", {
+            alarmDescription: `Critically low storage space available on RDS database '${this.databaseInstanceIdentifier}'.`,
+            comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,
+            evaluationPeriods: 1,
+            threshold: (_k = (_j = (_h = props === null || props === void 0 ? void 0 : props.criticallyLowStorageSpaceAlarm) === null || _h === void 0 ? void 0 : _h.threshold) === null || _j === void 0 ? void 0 : _j.toBytes()) !== null && _k !== void 0 ? _k : this.allocatedStorage.toBytes() * 0.05,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        if ((_m = (_l = props === null || props === void 0 ? void 0 : props.criticallyLowStorageSpaceAlarm) === null || _l === void 0 ? void 0 : _l.enabled) !== null && _m !== void 0 ? _m : true) {
+            criticallyLowStorageSpaceAlarm.addAlarmAction(((_o = props === null || props === void 0 ? void 0 : props.criticallyLowStorageSpaceAlarm) === null || _o === void 0 ? void 0 : _o.action) || this.action);
+            criticallyLowStorageSpaceAlarm.addOkAction(((_p = props === null || props === void 0 ? void 0 : props.criticallyLowStorageSpaceAlarm) === null || _p === void 0 ? void 0 : _p.action) || this.action);
+        }
+    }
+    /**
+     * Sets up a CloudWatch Alarm that triggers if the average CPU utilization for
+     * the RDS instance exceeds a given threshold.
+     */
+    addCpuUtilizationAlarm(
+    /**
+     * Configuration for an alarm.
+     *
+     * @default Configured with sane defaults.
+     */
+    props) {
+        var _a, _b, _c, _d, _e;
+        const alarm = new cloudwatch.Metric({
+            metricName: "CPUUtilization",
+            namespace: "AWS/RDS",
+            statistic: "Average",
+            period: (_a = props === null || props === void 0 ? void 0 : props.period) !== null && _a !== void 0 ? _a : cdk.Duration.minutes(2),
+            dimensionsMap: {
+                DBInstanceIdentifier: this.databaseInstanceIdentifier,
+            },
+        }).createAlarm(this, "CpuUtilizationAlarm", {
+            alarmDescription: `RDS database '${this.databaseInstanceIdentifier}' has a higher than expected CPU utilization.`,
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            evaluationPeriods: (_b = props === null || props === void 0 ? void 0 : props.evaluationPeriods) !== null && _b !== void 0 ? _b : 5,
+            threshold: (_c = props === null || props === void 0 ? void 0 : props.threshold) !== null && _c !== void 0 ? _c : 80,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        alarm.addAlarmAction((_d = props === null || props === void 0 ? void 0 : props.action) !== null && _d !== void 0 ? _d : this.action);
+        alarm.addOkAction((_e = props === null || props === void 0 ? void 0 : props.action) !== null && _e !== void 0 ? _e : this.action);
+    }
+}
+exports.DatabaseAlarms = DatabaseAlarms;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"database-alarms.js","sourceRoot":"","sources":["../../src/alarms/database-alarms.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\n\nexport interface DatabaseAlarmsProps {\n  /**\n   * The default action to use for CloudWatch alarm state changes\n   */\n  action: cloudwatch.IAlarmAction\n  instanceIdentifier: string\n  instanceType: ec2.InstanceType\n  allocatedStorage: cdk.Size\n}\n\n// Based on https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html#earning-CPU-credits\nconst cpuCreditBalanceByInstanceType: {\n  [instanceType: string]: number\n} = {\n  \"t2.nano\": 72,\n  \"t2.micro\": 144,\n  \"t2.small\": 288,\n  \"t2.medium\": 576,\n  \"t2.large\": 864,\n  \"t2.xlarge\": 1296,\n  \"t2.2xlarge\": 1958.4,\n  \"t3.nano\": 144,\n  \"t3.micro\": 288,\n  \"t3.small\": 576,\n  \"t3.medium\": 576,\n  \"t3.large\": 864,\n  \"t3.xlarge\": 2304,\n  \"t3.2xlarge\": 4608,\n  \"t3a.nano\": 144,\n  \"t3a.micro\": 288,\n  \"t3a.small\": 576,\n  \"t3a.medium\": 576,\n  \"t3a.large\": 864,\n  \"t3a.xlarge\": 2304,\n  \"t3a.2xlarge\": 4608,\n  \"t4g.nano\": 144,\n  \"t4g.micro\": 288,\n  \"t4g.small\": 576,\n  \"t4g.medium\": 576,\n  \"t4g.large\": 864,\n  \"t4g.xlarge\": 2304,\n  \"t4g.2xlarge\": 4608,\n}\n\nexport class DatabaseAlarms extends constructs.Construct {\n  private readonly action: cloudwatch.IAlarmAction\n  private readonly databaseInstanceIdentifier: string\n  private readonly instanceType: ec2.InstanceType\n  private readonly allocatedStorage: cdk.Size\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: DatabaseAlarmsProps,\n  ) {\n    super(scope, id)\n\n    this.action = props.action\n    this.databaseInstanceIdentifier = props.instanceIdentifier\n    this.instanceType = props.instanceType\n    this.allocatedStorage = props.allocatedStorage\n  }\n\n  /**\n   * Sets up a CloudWatch Alarm that triggers if the CPU credit balance for\n   * a burstable instance breach a certain threshold.\n   *\n   * NOTE: This alarm is only applicable for burstable instances, and a balance of 0 credits will only have performance\n   * implications for T2 instances. T3 and T4g instances will instead cost more for prolonged high CPU utilization after\n   * the balance is depleted.\n   */\n  addCpuCreditsAlarm(\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    props?: {\n      /**\n       * An action to use for CloudWatch alarm state changes instead of the default action\n       */\n      action?: cloudwatch.IAlarmAction\n      /**\n       * The CloudWatch Alarm will change its state to ALARM if the number of CPU credits drops below this threshold.\n       *\n       * See https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-credits-baseline-concepts.html#earning-CPU-credits for an overview of maximum CPU credits for various instance types.\n       *\n       * @default 10% of the maximum earned CPU credits for the instance type.\n       */\n      threshold?: number\n    },\n  ): void {\n    if (\n      ![\"t2.\", \"t3.\", \"t4g.\"].some((s) =>\n        this.instanceType.toString().startsWith(s),\n      )\n    ) {\n      throw new Error(\n        \"CPU credits are only relevant for burstable instance types.\",\n      )\n    }\n\n    const defaultThreshold =\n      cpuCreditBalanceByInstanceType[this.instanceType.toString()] * 0.1\n    const threshold = props?.threshold ?? defaultThreshold\n    if (!threshold) {\n      throw new Error(\n        `No threshold supplied, and unable to determine a default value for instance type '${this.instanceType.toString()}'`,\n      )\n    }\n    new cloudwatch.Metric({\n      metricName: \"CPUCreditBalance\",\n      namespace: \"AWS/RDS\",\n      statistic: \"Minimum\",\n      period: cdk.Duration.minutes(5),\n      dimensionsMap: {\n        DBInstanceIdentifier: this.databaseInstanceIdentifier,\n      },\n    })\n      .createAlarm(this, \"CreditsAlarm\", {\n        alarmDescription: `Less than ${threshold} CPU credits remaining for RDS database '${\n          this.databaseInstanceIdentifier\n        }'. ${\n          this.instanceType.toString().startsWith(\"t2.\")\n            ? \"If this reaches 0, the instance will be limited to a baseline CPU utilization.\"\n            : \"If the balance is depleted, AWS adds additional charges.\"\n        }.`,\n        comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,\n        evaluationPeriods: 1,\n        threshold: threshold,\n        treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n      })\n      .addAlarmAction(this.action)\n  }\n\n  /**\n   * Sets up two CloudWatch Alarms for monitoring disk storage space:\n   * 1) one that triggers if the available disk storage space is low.\n   * 2) one that triggers if the available disk storage space is critcally low.\n   *\n   * You may want to use different alarm actions for the two alarms, e.g., one can be\n   * categorized as a \"warning\", while the other one can be considered an \"alarm\".\n   */\n  addStorageSpaceAlarms(props?: {\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    lowStorageSpaceAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * An action to use for CloudWatch alarm state changes instead of the default action\n       */\n      action?: cloudwatch.IAlarmAction\n      /**\n       * @default 25% of the allocated storage.\n       */\n      threshold?: cdk.Size\n    }\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    criticallyLowStorageSpaceAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * An action to use for CloudWatch alarm state changes instead of the default action\n       */\n      action?: cloudwatch.IAlarmAction\n      /**\n       * @default 5% of the allocated storage.\n       */\n      threshold?: cdk.Size\n    }\n  }): void {\n    const lowStorageSpaceAlarm = new cloudwatch.Metric({\n      metricName: \"FreeStorageSpace\",\n      namespace: \"AWS/RDS\",\n      statistic: \"Minimum\",\n      period: cdk.Duration.minutes(5),\n      dimensionsMap: {\n        DBInstanceIdentifier: this.databaseInstanceIdentifier,\n      },\n    }).createAlarm(this, \"LowStorageSpaceAlarm\", {\n      alarmDescription: `Low storage space available on RDS database '${this.databaseInstanceIdentifier}'.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,\n      evaluationPeriods: 1,\n      threshold:\n        props?.lowStorageSpaceAlarm?.threshold?.toBytes() ??\n        this.allocatedStorage.toBytes() * 0.25,\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n    if (props?.lowStorageSpaceAlarm?.enabled ?? true) {\n      lowStorageSpaceAlarm.addAlarmAction(\n        props?.lowStorageSpaceAlarm?.action || this.action,\n      )\n      lowStorageSpaceAlarm.addOkAction(\n        props?.lowStorageSpaceAlarm?.action || this.action,\n      )\n    }\n\n    const criticallyLowStorageSpaceAlarm = new cloudwatch.Metric({\n      metricName: \"FreeStorageSpace\",\n      namespace: \"AWS/RDS\",\n      statistic: \"Minimum\",\n      period: cdk.Duration.minutes(5),\n      dimensionsMap: {\n        DBInstanceIdentifier: this.databaseInstanceIdentifier,\n      },\n    }).createAlarm(this, \"CriticallyLowStorageSpaceAlarm\", {\n      alarmDescription: `Critically low storage space available on RDS database '${this.databaseInstanceIdentifier}'.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,\n      evaluationPeriods: 1,\n      threshold:\n        props?.criticallyLowStorageSpaceAlarm?.threshold?.toBytes() ??\n        this.allocatedStorage.toBytes() * 0.05,\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n    if (props?.criticallyLowStorageSpaceAlarm?.enabled ?? true) {\n      criticallyLowStorageSpaceAlarm.addAlarmAction(\n        props?.criticallyLowStorageSpaceAlarm?.action || this.action,\n      )\n      criticallyLowStorageSpaceAlarm.addOkAction(\n        props?.criticallyLowStorageSpaceAlarm?.action || this.action,\n      )\n    }\n  }\n\n  /**\n   * Sets up a CloudWatch Alarm that triggers if the average CPU utilization for\n   * the RDS instance exceeds a given threshold.\n   */\n  addCpuUtilizationAlarm(\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    props?: {\n      /**\n       * An action to use for CloudWatch alarm state changes instead of the default action\n       */\n      action?: cloudwatch.IAlarmAction\n      /**\n       * The threshold defined as a percentage that determines if CPU utilization should trigger an alarm or not.\n       * @default 80\n       */\n      threshold?: number\n      /**\n       * @default 5\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 2 minutes\n       */\n      period?: cdk.Duration\n    },\n  ): void {\n    const alarm = new cloudwatch.Metric({\n      metricName: \"CPUUtilization\",\n      namespace: \"AWS/RDS\",\n      statistic: \"Average\",\n      period: props?.period ?? cdk.Duration.minutes(2),\n      dimensionsMap: {\n        DBInstanceIdentifier: this.databaseInstanceIdentifier,\n      },\n    }).createAlarm(this, \"CpuUtilizationAlarm\", {\n      alarmDescription: `RDS database '${this.databaseInstanceIdentifier}' has a higher than expected CPU utilization.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      evaluationPeriods: props?.evaluationPeriods ?? 5,\n      threshold: props?.threshold ?? 80,\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n    alarm.addAlarmAction(props?.action ?? this.action)\n    alarm.addOkAction(props?.action ?? this.action)\n  }\n}\n"]}

package/lib/alarms/index.d.ts

@@ -0,0 +1,3 @@
+export { DatabaseAlarms, DatabaseAlarmsProps } from "./database-alarms";
+export { ServiceAlarms, ServiceAlarmsProps } from "./service-alarms";
+export { SlackAlarm, SlackAlarmProps } from "./slack-alarm";

package/lib/alarms/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackAlarm = exports.ServiceAlarms = exports.DatabaseAlarms = void 0;
+var database_alarms_1 = require("./database-alarms");
+Object.defineProperty(exports, "DatabaseAlarms", { enumerable: true, get: function () { return database_alarms_1.DatabaseAlarms; } });
+var service_alarms_1 = require("./service-alarms");
+Object.defineProperty(exports, "ServiceAlarms", { enumerable: true, get: function () { return service_alarms_1.ServiceAlarms; } });
+var slack_alarm_1 = require("./slack-alarm");
+Object.defineProperty(exports, "SlackAlarm", { enumerable: true, get: function () { return slack_alarm_1.SlackAlarm; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWxhcm1zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFEQUF1RTtBQUE5RCxpSEFBQSxjQUFjLE9BQUE7QUFDdkIsbURBQW9FO0FBQTNELCtHQUFBLGFBQWEsT0FBQTtBQUN0Qiw2Q0FBMkQ7QUFBbEQseUdBQUEsVUFBVSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRGF0YWJhc2VBbGFybXMsIERhdGFiYXNlQWxhcm1zUHJvcHMgfSBmcm9tIFwiLi9kYXRhYmFzZS1hbGFybXNcIlxuZXhwb3J0IHsgU2VydmljZUFsYXJtcywgU2VydmljZUFsYXJtc1Byb3BzIH0gZnJvbSBcIi4vc2VydmljZS1hbGFybXNcIlxuZXhwb3J0IHsgU2xhY2tBbGFybSwgU2xhY2tBbGFybVByb3BzIH0gZnJvbSBcIi4vc2xhY2stYWxhcm1cIlxuIl19