@rio-cloud/cdk-v2-constructs 1.0.1-alpha.0

package/lib/watchful/datadog-metric-alarm.js

@@ -0,0 +1,158 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDogMetricAlarm = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cw = require("aws-cdk-lib/aws-cloudwatch");
+const constructs_1 = require("constructs");
+const upperToLower_1 = require("./upperToLower");
+/**
+ * A wrapper for a custom resource that creates a DataDog Monitor.
+ *
+ * To use this construct, the DataDog integration needs to be installed.
+ */
+class DataDogMetricAlarm extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        var _b;
+        super(scope, id);
+        this.serviceToken = upperToLower_1.UpperToLower.getOrCreate(this).provider.serviceToken;
+        new aws_cdk_lib_1.CustomResource(this, 'DDMonitor', {
+            serviceToken: props.serviceToken,
+            pascalCaseProperties: true,
+            resourceType: 'Custom::DataDogMonitor',
+            properties: {
+                ServiceName: props.serviceName,
+                version: '1.0.0',
+                monitor: {
+                    type: 'query alert',
+                    query: this.alarmToDataDogQuery(props),
+                    name: `${(_b = this.node.scope) === null || _b === void 0 ? void 0 : _b.node.id} ${id}`,
+                    // TeamName
+                    message: `
+{{#is_alert}}
+${props.alarmDescription}
+{{/is_alert}} 
+
+{{#is_alert_recovery}}
+${props.alarmDescription} is back to normal.
+{{/is_alert_recovery}} 
+
+@opsgenie-${props.dataDogOpsGenieIntegrationName}`,
+                    options: {
+                        notify_audit: false,
+                        locked: false,
+                        timeout_h: 0,
+                        silenced: {},
+                        include_tags: false,
+                        new_host_delay: 300,
+                        require_full_window: false,
+                        notify_no_data: props.treatMissingData === cw.TreatMissingData.BREACHING,
+                        renotify_interval: 0,
+                        escalation_message: '',
+                        evaluation_delay: 900,
+                    },
+                },
+            },
+        });
+    }
+    /**
+       * Helper function to convert a generic alarm into a DataDog query string.
+       */
+    alarmToDataDogQuery(alarm) {
+        let unit = 'not supported';
+        let totalPeriod = 0;
+        if (alarm.metric.period.toSeconds() < 60) {
+            totalPeriod = alarm.metric.period.toSeconds() * alarm.evaluationPeriods;
+            unit = 's';
+        }
+        if (alarm.metric.period.toMinutes() < 1440) {
+            totalPeriod = alarm.metric.period.toMinutes() * alarm.evaluationPeriods;
+            unit = 'm';
+        }
+        else {
+            totalPeriod = alarm.metric.period.toDays() * alarm.evaluationPeriods;
+            unit = 'd';
+        }
+        // avg(last_15m):max:aws.fargate.cpu.percent{ecs_container_name:$ServiceName$} > 95
+        const namespace = alarm.metric.namespace.toLocaleLowerCase().replace('/', '.');
+        let metricName = alarm.metric.metricName;
+        // Special case for ALB / TargetGroup metrics
+        switch (metricName) {
+            case 'HTTPCode_ELB_5XX_Count':
+                metricName = 'HTTPCode_ELB_5XX';
+                break;
+            case 'HTTPCode_Target_5XX_Count':
+                metricName = 'HTTPCode_Target_5XX';
+                break;
+        }
+        if (!metricName.includes('_')) {
+            metricName = metricName.replace(/([a-z])([A-Z])/g, '$1_$2');
+        }
+        metricName = metricName.toLocaleLowerCase();
+        const metric = `${namespace}.${metricName}`;
+        // statistics must be lowerCase and probably also converted (see allowed values in cw.Metric)
+        let comparisonOperator = 'not supported';
+        switch (alarm.comparisonOperator) {
+            case cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD:
+                comparisonOperator = '>=';
+                break;
+            case cw.ComparisonOperator.GREATER_THAN_THRESHOLD:
+                comparisonOperator = '>';
+                break;
+            case cw.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD:
+                comparisonOperator = '<=';
+                break;
+            case cw.ComparisonOperator.LESS_THAN_THRESHOLD:
+                comparisonOperator = '<';
+                break;
+        }
+        //const timeStatistic = 'sum'; // For count it should be `sum`, for gauges maybe `avg`
+        let alarmStatistic = 'not supported';
+        switch (alarm.metric.statistic) {
+            case cw.Statistic.AVERAGE:
+                alarmStatistic = 'avg';
+                break;
+            case cw.Statistic.MAXIMUM:
+                alarmStatistic = 'max';
+                break;
+            case cw.Statistic.MINIMUM:
+                alarmStatistic = 'min';
+                break;
+            case cw.Statistic.SAMPLE_COUNT:
+                break;
+            case cw.Statistic.SUM:
+                alarmStatistic = 'sum';
+                break;
+            default:
+                alarmStatistic = 'avg';
+                break;
+        }
+        let dimensions = `account_id:${aws_cdk_lib_1.Stack.of(this).account}`;
+        if (alarm.metric.dimensions) {
+            for (const key in alarm.metric.dimensions) {
+                const upperToLowerCr = new aws_cdk_lib_1.CustomResource(this, `${key}UpperToLower`, {
+                    resourceType: 'Custom::UpperToLower',
+                    serviceToken: this.serviceToken,
+                    properties: {
+                        Upper: alarm.metric.dimensions[key],
+                    },
+                });
+                const value = upperToLowerCr.getAtt('Lower');
+                dimensions += `,${key.toLocaleLowerCase()}:${value}`;
+            }
+        }
+        switch (alarm.treatMissingData) {
+            case cw.TreatMissingData.NOT_BREACHING:
+                return `${alarmStatistic}(last_${totalPeriod}${unit}):default_zero(${alarmStatistic}:${metric}{${dimensions}}) ${comparisonOperator} ${alarm.threshold}`;
+            case cw.TreatMissingData.BREACHING:
+            case cw.TreatMissingData.IGNORE:
+            default:
+                return `${alarmStatistic}(last_${totalPeriod}${unit}):${alarmStatistic}:${metric}{${dimensions}} ${comparisonOperator} ${alarm.threshold}`;
+        }
+    }
+}
+exports.DataDogMetricAlarm = DataDogMetricAlarm;
+_a = JSII_RTTI_SYMBOL_1;
+DataDogMetricAlarm[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.DataDogMetricAlarm", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-metric-alarm.js","sourceRoot":"","sources":["../../src/watchful/datadog-metric-alarm.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, CustomResource } from 'aws-cdk-lib';\nimport * as cw from 'aws-cdk-lib/aws-cloudwatch';\nimport { Construct } from 'constructs';\nimport { MetricAlarmProps } from './metric-alarm';\nimport { UpperToLower } from './upperToLower';\n\n/**\n * Interface for DataDogMonitor implementation.\n */\nexport interface DataDogMetricAlarmProps extends MetricAlarmProps {\n  /**\n     * Service token which points to the DataDog Monitor custom resource lambda or sns topic.\n     */\n  readonly serviceToken: string;\n\n  /**\n   * The service name used to name the montors (in datadog-integration).\n   */\n  readonly serviceName: string;\n\n  /**\n   * The name of DataDog's OpsGenie integration. Used to automatically create OpsGenie alarms for the created DataDog Monitor.\n   */\n  readonly dataDogOpsGenieIntegrationName: string;\n}\n\n/**\n * A wrapper for a custom resource that creates a DataDog Monitor.\n *\n * To use this construct, the DataDog integration needs to be installed.\n */\nexport class DataDogMetricAlarm extends Construct {\n  private serviceToken: string;\n  constructor(scope: Construct, id: string, props: DataDogMetricAlarmProps) {\n    super(scope, id);\n\n    this.serviceToken = UpperToLower.getOrCreate(this).provider.serviceToken;\n\n    new CustomResource(this, 'DDMonitor', {\n      serviceToken: props.serviceToken,\n      pascalCaseProperties: true,\n      resourceType: 'Custom::DataDogMonitor',\n      properties: {\n        ServiceName: props.serviceName,\n        version: '1.0.0',\n        monitor: {\n          type: 'query alert',\n          query: this.alarmToDataDogQuery(props),\n          name: `${this.node.scope?.node.id} ${id}`, // datadog-integration custom resource prepend it with Team and ServiceName\n          // TeamName\n          message: `\n{{#is_alert}}\n${props.alarmDescription}\n{{/is_alert}} \n\n{{#is_alert_recovery}}\n${props.alarmDescription} is back to normal.\n{{/is_alert_recovery}} \n\n@opsgenie-${props.dataDogOpsGenieIntegrationName}`,\n          options: {\n            notify_audit: false,\n            locked: false, // double-check!\n            timeout_h: 0,\n            silenced: {},\n            include_tags: false,\n            new_host_delay: 300,\n            require_full_window: false,\n            notify_no_data: props.treatMissingData === cw.TreatMissingData.BREACHING,\n            renotify_interval: 0,\n            escalation_message: '',\n            evaluation_delay: 900,\n          },\n        },\n      },\n    });\n  }\n\n  /**\n     * Helper function to convert a generic alarm into a DataDog query string.\n     */\n  alarmToDataDogQuery(alarm: MetricAlarmProps): string {\n    let unit = 'not supported';\n    let totalPeriod = 0;\n    if (alarm.metric.period.toSeconds() < 60) {\n      totalPeriod = alarm.metric.period.toSeconds() * alarm.evaluationPeriods;\n      unit = 's';\n    }\n    if (alarm.metric.period.toMinutes() < 1440) {\n      totalPeriod = alarm.metric.period.toMinutes() * alarm.evaluationPeriods;\n      unit = 'm';\n    } else {\n      totalPeriod = alarm.metric.period.toDays() * alarm.evaluationPeriods;\n      unit = 'd';\n    }\n\n    // avg(last_15m):max:aws.fargate.cpu.percent{ecs_container_name:$ServiceName$} > 95\n    const namespace = alarm.metric.namespace.toLocaleLowerCase().replace('/', '.');\n\n    let metricName = alarm.metric.metricName;\n\n    // Special case for ALB / TargetGroup metrics\n    switch (metricName) {\n      case 'HTTPCode_ELB_5XX_Count':\n        metricName = 'HTTPCode_ELB_5XX';\n        break;\n      case 'HTTPCode_Target_5XX_Count':\n        metricName = 'HTTPCode_Target_5XX';\n        break;\n    }\n    if (!metricName.includes('_')) {\n      metricName = metricName.replace(/([a-z])([A-Z])/g, '$1_$2');\n    }\n    metricName = metricName.toLocaleLowerCase();\n\n    const metric = `${namespace}.${metricName}`;\n\n    // statistics must be lowerCase and probably also converted (see allowed values in cw.Metric)\n    let comparisonOperator = 'not supported';\n    switch (alarm.comparisonOperator) {\n      case cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD:\n        comparisonOperator = '>=';\n        break;\n      case cw.ComparisonOperator.GREATER_THAN_THRESHOLD:\n        comparisonOperator = '>';\n        break;\n      case cw.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD:\n        comparisonOperator = '<=';\n        break;\n      case cw.ComparisonOperator.LESS_THAN_THRESHOLD:\n        comparisonOperator = '<';\n        break;\n    }\n\n    //const timeStatistic = 'sum'; // For count it should be `sum`, for gauges maybe `avg`\n\n    let alarmStatistic = 'not supported';\n    switch (alarm.metric.statistic) {\n      case cw.Statistic.AVERAGE:\n        alarmStatistic = 'avg';\n        break;\n      case cw.Statistic.MAXIMUM:\n        alarmStatistic = 'max';\n        break;\n      case cw.Statistic.MINIMUM:\n        alarmStatistic = 'min';\n        break;\n      case cw.Statistic.SAMPLE_COUNT:\n        break;\n      case cw.Statistic.SUM:\n        alarmStatistic = 'sum';\n        break;\n      default:\n        alarmStatistic = 'avg';\n        break;\n    }\n\n    let dimensions = `account_id:${Stack.of(this).account}`;\n\n    if (alarm.metric.dimensions) {\n      for (const key in alarm.metric.dimensions) {\n        const upperToLowerCr = new CustomResource(this, `${key}UpperToLower`, {\n          resourceType: 'Custom::UpperToLower',\n          serviceToken: this.serviceToken,\n          properties: {\n            Upper: alarm.metric.dimensions[key],\n          },\n        });\n        const value = upperToLowerCr.getAtt('Lower');\n        dimensions += `,${key.toLocaleLowerCase()}:${value}`;\n      }\n    }\n\n    switch (alarm.treatMissingData) {\n      case cw.TreatMissingData.NOT_BREACHING:\n        return `${alarmStatistic}(last_${totalPeriod}${unit}):default_zero(${alarmStatistic}:${metric}{${dimensions}}) ${comparisonOperator} ${alarm.threshold}`;\n      case cw.TreatMissingData.BREACHING:\n      case cw.TreatMissingData.IGNORE:\n      default:\n        return `${alarmStatistic}(last_${totalPeriod}${unit}):${alarmStatistic}:${metric}{${dimensions}} ${comparisonOperator} ${alarm.threshold}`;\n    }\n  }\n}\n"]}

package/lib/watchful/docdb.d.ts

@@ -0,0 +1,62 @@
+import * as docdb from 'aws-cdk-lib/aws-docdb';
+import { Construct } from 'constructs';
+import { IWatchful } from './watchful';
+/**
+ * Options for defining alarms.
+ */
+export interface WatchDocDbClusterOptions {
+    /**
+       * Threshold of database cpu utilization.
+       *
+       * @default 80
+       */
+    readonly cpuUtilizationThreshold?: number;
+    /**
+       * Minimum database freeable memory in bytes.
+       *
+       * @default 64000000 (64 Megabyte)
+       */
+    readonly freeableMemoryThresholdInByte?: number;
+    /**
+       * Threshold of database swap usage
+       *
+       * @default 256000000 (256 Megabyte)
+       */
+    readonly swapUsageThresholdInByte?: number;
+    /**
+       * Minimum database free local storage space
+       *
+       * @default 2000000000 (2 Gigabyte)
+       */
+    readonly freeLocalStorageInByte?: number;
+}
+/**
+ * Properties for defining a WatchDocDbCluster
+ */
+export interface WatchDocDbClusterProps extends WatchDocDbClusterOptions {
+    /**
+       * The reference to IWatchful class. Used internally.
+       */
+    readonly watchful: IWatchful;
+    /**
+       * The DocDB cluster that should be watched.
+       * [disable-awslint:ref-via-interface]
+       */
+    readonly docDb: docdb.DatabaseCluster;
+}
+/**
+ * A Construct which creates the following alarms for DocumentDb clusters:
+ *
+ * - freeable memory
+ * - swap usage
+ * - free local storage
+ */
+export declare class WatchDocDbCluster extends Construct {
+    private readonly watchful;
+    private readonly docDb;
+    constructor(scope: Construct, id: string, props: WatchDocDbClusterProps);
+    private createCpuUtilizationTooHighAlarm;
+    private createFreeableMemoryTooLowAlarm;
+    private createSwapUsageTooHighAlarm;
+    private createFreeLocalStorageTooLowAlarm;
+}

package/lib/watchful/docdb.js

@@ -0,0 +1,102 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchDocDbCluster = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cw = require("aws-cdk-lib/aws-cloudwatch");
+const constructs_1 = require("constructs");
+/**
+ * A Construct which creates the following alarms for DocumentDb clusters:
+ *
+ * - freeable memory
+ * - swap usage
+ * - free local storage
+ */
+class WatchDocDbCluster extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.watchful = props.watchful;
+        this.docDb = props.docDb;
+        this.watchful.createAlarm(this, 'CpuUtilization', this.createCpuUtilizationTooHighAlarm(props.cpuUtilizationThreshold));
+        this.watchful.createAlarm(this, 'FreeableMemoryTooLow', this.createFreeableMemoryTooLowAlarm(props.freeableMemoryThresholdInByte));
+        this.watchful.createAlarm(this, 'SwapUsageTooHigh', this.createSwapUsageTooHighAlarm(props.swapUsageThresholdInByte));
+        this.watchful.createAlarm(this, 'FreeLocalStorageTooLow', this.createFreeLocalStorageTooLowAlarm(props.freeLocalStorageInByte));
+    }
+    createCpuUtilizationTooHighAlarm(cpuUtilizationThreshold = 80) {
+        const docDbMetric = new cw.Metric({
+            metricName: 'CPUUtilization',
+            namespace: 'AWS/DocDB',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                DBClusterIdentifier: this.docDb.clusterIdentifier,
+            },
+        });
+        return {
+            metric: docDbMetric,
+            alarmDescription: 'Average database CPU utilization over last 10 minutes too high.',
+            comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: cpuUtilizationThreshold,
+            evaluationPeriods: 1,
+        };
+    }
+    createFreeableMemoryTooLowAlarm(freeableMemoryThresholdInByte = 64000000) {
+        const docDbMetric = new cw.Metric({
+            metricName: 'FreeableMemory',
+            namespace: 'AWS/DocDB',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                DBClusterIdentifier: this.docDb.clusterIdentifier,
+            },
+        });
+        return {
+            metric: docDbMetric,
+            alarmDescription: 'Average database freeable memory over last 10 minutes too low, performance may suffer.',
+            comparisonOperator: cw.ComparisonOperator.LESS_THAN_THRESHOLD,
+            threshold: freeableMemoryThresholdInByte,
+            evaluationPeriods: 1,
+        };
+    }
+    createSwapUsageTooHighAlarm(swapUsageThresholdInByte = 256000000) {
+        const docDbMetric = new cw.Metric({
+            metricName: 'SwapUsage',
+            namespace: 'AWS/DocDB',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                DBClusterIdentifier: this.docDb.clusterIdentifier,
+            },
+        });
+        return {
+            metric: docDbMetric,
+            alarmDescription: 'Average database swap usage over last 10 minutes too high, performance may suffer.',
+            comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: swapUsageThresholdInByte,
+            evaluationPeriods: 1,
+        };
+    }
+    createFreeLocalStorageTooLowAlarm(freeLocalStorageInByte = 2000000000) {
+        const docDbMetric = new cw.Metric({
+            metricName: 'FreeLocalStorage',
+            namespace: 'AWS/DocDB',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                DBClusterIdentifier: this.docDb.clusterIdentifier,
+            },
+        });
+        return {
+            metric: docDbMetric,
+            alarmDescription: 'Average database free local storage space over last 10 minutes too low.',
+            comparisonOperator: cw.ComparisonOperator.LESS_THAN_THRESHOLD,
+            threshold: freeLocalStorageInByte,
+            evaluationPeriods: 1,
+        };
+    }
+}
+exports.WatchDocDbCluster = WatchDocDbCluster;
+_a = JSII_RTTI_SYMBOL_1;
+WatchDocDbCluster[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.WatchDocDbCluster", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"docdb.js","sourceRoot":"","sources":["../../src/watchful/docdb.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration } from 'aws-cdk-lib';\nimport * as cw from 'aws-cdk-lib/aws-cloudwatch';\nimport * as docdb from 'aws-cdk-lib/aws-docdb';\nimport { Construct } from 'constructs';\nimport { MetricAlarmProps } from './metric-alarm';\nimport { IWatchful } from './watchful';\n\n/**\n * Options for defining alarms.\n */\nexport interface WatchDocDbClusterOptions {\n  /**\n     * Threshold of database cpu utilization.\n     *\n     * @default 80\n     */\n  readonly cpuUtilizationThreshold?: number;\n  /**\n     * Minimum database freeable memory in bytes.\n     *\n     * @default 64000000 (64 Megabyte)\n     */\n  readonly freeableMemoryThresholdInByte?: number;\n  /**\n     * Threshold of database swap usage\n     *\n     * @default 256000000 (256 Megabyte)\n     */\n  readonly swapUsageThresholdInByte?: number;\n  /**\n     * Minimum database free local storage space\n     *\n     * @default 2000000000 (2 Gigabyte)\n     */\n  readonly freeLocalStorageInByte?: number;\n}\n\n/**\n * Properties for defining a WatchDocDbCluster\n */\nexport interface WatchDocDbClusterProps extends WatchDocDbClusterOptions {\n  /**\n     * The reference to IWatchful class. Used internally.\n     */\n  readonly watchful: IWatchful;\n\n  /**\n     * The DocDB cluster that should be watched.\n     * [disable-awslint:ref-via-interface]\n     */\n  readonly docDb: docdb.DatabaseCluster;\n}\n\n/**\n * A Construct which creates the following alarms for DocumentDb clusters:\n *\n * - freeable memory\n * - swap usage\n * - free local storage\n */\nexport class WatchDocDbCluster extends Construct {\n  private readonly watchful: IWatchful;\n  private readonly docDb: docdb.DatabaseCluster;\n\n  constructor(scope: Construct, id: string, props: WatchDocDbClusterProps) {\n    super(scope, id);\n\n    this.watchful = props.watchful;\n    this.docDb = props.docDb;\n\n    this.watchful.createAlarm(this,\n      'CpuUtilization',\n      this.createCpuUtilizationTooHighAlarm(props.cpuUtilizationThreshold),\n    );\n    this.watchful.createAlarm(this,\n      'FreeableMemoryTooLow',\n      this.createFreeableMemoryTooLowAlarm(props.freeableMemoryThresholdInByte),\n    );\n    this.watchful.createAlarm(this,\n      'SwapUsageTooHigh',\n      this.createSwapUsageTooHighAlarm(props.swapUsageThresholdInByte),\n    );\n    this.watchful.createAlarm(this,\n      'FreeLocalStorageTooLow',\n      this.createFreeLocalStorageTooLowAlarm(props.freeLocalStorageInByte),\n    );\n  }\n\n  private createCpuUtilizationTooHighAlarm(cpuUtilizationThreshold = 80): MetricAlarmProps {\n    const docDbMetric = new cw.Metric({\n      metricName: 'CPUUtilization',\n      namespace: 'AWS/DocDB',\n      period: Duration.seconds(600),\n      statistic: cw.Statistic.AVERAGE,\n      dimensionsMap: {\n        DBClusterIdentifier: this.docDb.clusterIdentifier,\n      },\n    });\n    return {\n      metric: docDbMetric,\n      alarmDescription: 'Average database CPU utilization over last 10 minutes too high.',\n      comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: cpuUtilizationThreshold,\n      evaluationPeriods: 1,\n    };\n  }\n\n  private createFreeableMemoryTooLowAlarm(freeableMemoryThresholdInByte = 64000000): MetricAlarmProps {\n    const docDbMetric = new cw.Metric({\n      metricName: 'FreeableMemory',\n      namespace: 'AWS/DocDB',\n      period: Duration.seconds(600),\n      statistic: cw.Statistic.AVERAGE,\n      dimensionsMap: {\n        DBClusterIdentifier: this.docDb.clusterIdentifier,\n      },\n    });\n    return {\n      metric: docDbMetric,\n      alarmDescription: 'Average database freeable memory over last 10 minutes too low, performance may suffer.',\n      comparisonOperator: cw.ComparisonOperator.LESS_THAN_THRESHOLD,\n      threshold: freeableMemoryThresholdInByte,\n      evaluationPeriods: 1,\n    };\n  }\n\n  private createSwapUsageTooHighAlarm(swapUsageThresholdInByte = 256000000): MetricAlarmProps {\n    const docDbMetric = new cw.Metric({\n      metricName: 'SwapUsage',\n      namespace: 'AWS/DocDB',\n      period: Duration.seconds(600),\n      statistic: cw.Statistic.AVERAGE,\n      dimensionsMap: {\n        DBClusterIdentifier: this.docDb.clusterIdentifier,\n      },\n    });\n    return {\n      metric: docDbMetric,\n      alarmDescription: 'Average database swap usage over last 10 minutes too high, performance may suffer.',\n      comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      threshold: swapUsageThresholdInByte,\n      evaluationPeriods: 1,\n    };\n  }\n\n  private createFreeLocalStorageTooLowAlarm(freeLocalStorageInByte = 2000000000): MetricAlarmProps {\n    const docDbMetric = new cw.Metric({\n      metricName: 'FreeLocalStorage',\n      namespace: 'AWS/DocDB',\n      period: Duration.seconds(600),\n      statistic: cw.Statistic.AVERAGE,\n      dimensionsMap: {\n        DBClusterIdentifier: this.docDb.clusterIdentifier,\n      },\n    });\n    return {\n      metric: docDbMetric,\n      alarmDescription: 'Average database free local storage space over last 10 minutes too low.',\n      comparisonOperator: cw.ComparisonOperator.LESS_THAN_THRESHOLD,\n      threshold: freeLocalStorageInByte,\n      evaluationPeriods: 1,\n    };\n  }\n}\n"]}

package/lib/watchful/dynamodb.d.ts

@@ -0,0 +1,69 @@
+import { aws_dynamodb as dynamodb } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { IWatchful } from './watchful';
+/**
+ * Options for defining alarms.
+ */
+export interface WatchDynamoDbTableOptions {
+    /**
+       * Threshold of read throttle events.
+       *
+       * @default 1
+       */
+    readonly readThrottleEventsThreshold?: number;
+    /**
+       * Threshold of write throttle events.
+       *
+       * @default 1
+       */
+    readonly writeThrottleEventsThreshold?: number;
+    /**
+       * Threshold of throttled requests events.
+       *
+       * @default 1
+       */
+    readonly throttledRequestsEventsThreshold?: number;
+    /**
+       * Threshold of user errors.
+       *
+       * @default 1
+       */
+    readonly userErrorsThreshold?: number;
+    /**
+       * Threshold of system errors.
+       *
+       * @default 1
+       */
+    readonly systemErrorsThreshold?: number;
+}
+/**
+ * Properties for defining a WatchDynamoDbTable
+ */
+export interface WatchDynamoDbTableProps extends WatchDynamoDbTableOptions {
+    /**
+       * The reference to IWatchful class. Used internally.
+       */
+    readonly watchful: IWatchful;
+    /**
+       * The DynamoDb table that should be watched.
+       * [disable-awslint:ref-via-interface]
+       */
+    readonly dynamoDbTable: dynamodb.Table;
+}
+/**
+ * A Construct which creates the following alarms for DynamoDb tables:
+ *
+ * - read throttles
+ * - write throttles
+ * - throttled requests
+ * - user errors
+ * - system errors
+ */
+export declare class WatchDynamoDbTable extends Construct {
+    private readonly watchful;
+    private readonly dynamoDb;
+    constructor(scope: Construct, id: string, props: WatchDynamoDbTableProps);
+    private createReadThrottleEventsAlarm;
+    private createWriteThrottleEventsAlarm;
+    private createThrottledRequestsEventsAlarm;
+}

package/lib/watchful/dynamodb.js

@@ -0,0 +1,87 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchDynamoDbTable = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+/**
+ * A Construct which creates the following alarms for DynamoDb tables:
+ *
+ * - read throttles
+ * - write throttles
+ * - throttled requests
+ * - user errors
+ * - system errors
+ */
+class WatchDynamoDbTable extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.watchful = props.watchful;
+        this.dynamoDb = props.dynamoDbTable;
+        this.watchful.createAlarm(this, 'ReadThrottleEvents', this.createReadThrottleEventsAlarm(props.readThrottleEventsThreshold));
+        this.watchful.createAlarm(this, 'WriteThrottleEvents', this.createWriteThrottleEventsAlarm(props.writeThrottleEventsThreshold));
+        this.watchful.createAlarm(this, 'ThrottledRequestsEvents', this.createThrottledRequestsEventsAlarm(props.throttledRequestsEventsThreshold));
+    }
+    createReadThrottleEventsAlarm(readThrottleEventsThreshold = 1) {
+        const dynamoDbMetric = new aws_cdk_lib_1.aws_cloudwatch.Metric({
+            metricName: 'ReadThrottleEvents',
+            namespace: 'AWS/DynamoDB',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            statistic: aws_cdk_lib_1.aws_cloudwatch.Statistic.SUM,
+            dimensionsMap: {
+                TableName: this.dynamoDb.tableName,
+            },
+        });
+        return {
+            metric: dynamoDbMetric,
+            alarmDescription: 'Reads are throttled. Lower ReadCapacityUnitsUtilizationTarget or increase MaxReadCapacityUnits.',
+            comparisonOperator: aws_cdk_lib_1.aws_cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            threshold: readThrottleEventsThreshold,
+            treatMissingData: aws_cdk_lib_1.aws_cloudwatch.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: 1,
+        };
+    }
+    createWriteThrottleEventsAlarm(writeThrottleEventsThreshold = 1) {
+        const dynamoDbMetric = new aws_cdk_lib_1.aws_cloudwatch.Metric({
+            metricName: 'WriteThrottleEvents',
+            namespace: 'AWS/DynamoDB',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            statistic: aws_cdk_lib_1.aws_cloudwatch.Statistic.SUM,
+            dimensionsMap: {
+                TableName: this.dynamoDb.tableName,
+            },
+        });
+        return {
+            metric: dynamoDbMetric,
+            alarmDescription: 'Writes are throttled. Lower WriteCapacityUnitsUtilizationTarget or increase MaxWriteCapacityUnits.',
+            comparisonOperator: aws_cdk_lib_1.aws_cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            threshold: writeThrottleEventsThreshold,
+            treatMissingData: aws_cdk_lib_1.aws_cloudwatch.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: 1,
+        };
+    }
+    createThrottledRequestsEventsAlarm(throttledRequestsEventsThreshold = 1) {
+        const dynamoDbMetric = new aws_cdk_lib_1.aws_cloudwatch.Metric({
+            metricName: 'ThrottledRequests',
+            namespace: 'AWS/DynamoDB',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            statistic: aws_cdk_lib_1.aws_cloudwatch.Statistic.SUM,
+            dimensionsMap: {
+                TableName: this.dynamoDb.tableName,
+            },
+        });
+        return {
+            metric: dynamoDbMetric,
+            alarmDescription: 'Batch requests are throttled. Lower {Read/Write}CapacityUnitsUtilizationTarget or increase Max{Read/Write}CapacityUnits.',
+            comparisonOperator: aws_cdk_lib_1.aws_cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            threshold: throttledRequestsEventsThreshold,
+            treatMissingData: aws_cdk_lib_1.aws_cloudwatch.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: 1,
+        };
+    }
+}
+exports.WatchDynamoDbTable = WatchDynamoDbTable;
+_a = JSII_RTTI_SYMBOL_1;
+WatchDynamoDbTable[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.WatchDynamoDbTable", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamodb.js","sourceRoot":"","sources":["../../src/watchful/dynamodb.ts"],"names":[],"mappings":";;;;;AAAA,6CAAuF;AACvF,2CAAuC;AAyDvC;;;;;;;;GAQG;AACH,MAAa,kBAAmB,SAAQ,sBAAS;IAI/C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA8B;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,aAAa,CAAC;QAEpC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAC5B,oBAAoB,EACpB,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,2BAA2B,CAAC,CACtE,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAC5B,qBAAqB,EACrB,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,4BAA4B,CAAC,CACxE,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAC5B,yBAAyB,EACzB,IAAI,CAAC,kCAAkC,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAChF,CAAC;IACJ,CAAC;IAEO,6BAA6B,CAAC,2BAA2B,GAAG,CAAC;QAEnE,MAAM,cAAc,GAAG,IAAI,4BAAE,CAAC,MAAM,CAAC;YACnC,UAAU,EAAE,oBAAoB;YAChC,SAAS,EAAE,cAAc;YACzB,MAAM,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,SAAS,EAAE,4BAAE,CAAC,SAAS,CAAC,GAAG;YAC3B,aAAa,EAAE;gBACb,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;aACnC;SACF,CAAC,CAAC;QACH,OAAO;YACL,MAAM,EAAE,cAAc;YACtB,gBAAgB,EACd,iGAAiG;YACnG,kBAAkB,EAAE,4BAAE,CAAC,kBAAkB,CAAC,kCAAkC;YAC5E,SAAS,EAAE,2BAA2B;YACtC,gBAAgB,EAAE,4BAAE,CAAC,gBAAgB,CAAC,aAAa;YACnD,iBAAiB,EAAE,CAAC;SACrB,CAAC;IACJ,CAAC;IACO,8BAA8B,CAAC,4BAA4B,GAAG,CAAC;QACrE,MAAM,cAAc,GAAG,IAAI,4BAAE,CAAC,MAAM,CAAC;YACnC,UAAU,EAAE,qBAAqB;YACjC,SAAS,EAAE,cAAc;YACzB,MAAM,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,SAAS,EAAE,4BAAE,CAAC,SAAS,CAAC,GAAG;YAC3B,aAAa,EAAE;gBACb,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;aACnC;SACF,CAAC,CAAC;QACH,OAAO;YACL,MAAM,EAAE,cAAc;YACtB,gBAAgB,EACd,oGAAoG;YACtG,kBAAkB,EAAE,4BAAE,CAAC,kBAAkB,CAAC,kCAAkC;YAC5E,SAAS,EAAE,4BAA4B;YACvC,gBAAgB,EAAE,4BAAE,CAAC,gBAAgB,CAAC,aAAa;YACnD,iBAAiB,EAAE,CAAC;SACrB,CAAC;IACJ,CAAC;IACO,kCAAkC,CAAC,gCAAgC,GAAG,CAAC;QAC7E,MAAM,cAAc,GAAG,IAAI,4BAAE,CAAC,MAAM,CAAC;YACnC,UAAU,EAAE,mBAAmB;YAC/B,SAAS,EAAE,cAAc;YACzB,MAAM,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,SAAS,EAAE,4BAAE,CAAC,SAAS,CAAC,GAAG;YAC3B,aAAa,EAAE;gBACb,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;aACnC;SACF,CAAC,CAAC;QACH,OAAO;YACL,MAAM,EAAE,cAAc;YACtB,gBAAgB,EACd,0HAA0H;YAC5H,kBAAkB,EAAE,4BAAE,CAAC,kBAAkB,CAAC,kCAAkC;YAC5E,SAAS,EAAE,gCAAgC;YAC3C,gBAAgB,EAAE,4BAAE,CAAC,gBAAgB,CAAC,aAAa;YACnD,iBAAiB,EAAE,CAAC;SACrB,CAAC;IACJ,CAAC;;AApFH,gDAqFC","sourcesContent":["import { aws_cloudwatch as cw, aws_dynamodb as dynamodb, Duration } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { MetricAlarmProps } from './metric-alarm';\nimport { IWatchful } from './watchful';\n\n/**\n * Options for defining alarms.\n */\nexport interface WatchDynamoDbTableOptions {\n  /**\n     * Threshold of read throttle events.\n     *\n     * @default 1\n     */\n  readonly readThrottleEventsThreshold?: number;\n  /**\n     * Threshold of write throttle events.\n     *\n     * @default 1\n     */\n  readonly writeThrottleEventsThreshold?: number;\n  /**\n     * Threshold of throttled requests events.\n     *\n     * @default 1\n     */\n  readonly throttledRequestsEventsThreshold?: number;\n  /**\n     * Threshold of user errors.\n     *\n     * @default 1\n     */\n  readonly userErrorsThreshold?: number;\n\n  /**\n     * Threshold of system errors.\n     *\n     * @default 1\n     */\n  readonly systemErrorsThreshold?: number;\n}\n\n/**\n * Properties for defining a WatchDynamoDbTable\n */\nexport interface WatchDynamoDbTableProps extends WatchDynamoDbTableOptions {\n  /**\n     * The reference to IWatchful class. Used internally.\n     */\n  readonly watchful: IWatchful;\n\n  /**\n     * The DynamoDb table that should be watched.\n     * [disable-awslint:ref-via-interface]\n     */\n  readonly dynamoDbTable: dynamodb.Table;\n}\n\n/**\n * A Construct which creates the following alarms for DynamoDb tables:\n *\n * - read throttles\n * - write throttles\n * - throttled requests\n * - user errors\n * - system errors\n */\nexport class WatchDynamoDbTable extends Construct {\n  private readonly watchful: IWatchful;\n  private readonly dynamoDb: dynamodb.Table;\n\n  constructor(scope: Construct, id: string, props: WatchDynamoDbTableProps) {\n    super(scope, id);\n\n    this.watchful = props.watchful;\n    this.dynamoDb = props.dynamoDbTable;\n\n    this.watchful.createAlarm(this,\n      'ReadThrottleEvents',\n      this.createReadThrottleEventsAlarm(props.readThrottleEventsThreshold),\n    );\n    this.watchful.createAlarm(this,\n      'WriteThrottleEvents',\n      this.createWriteThrottleEventsAlarm(props.writeThrottleEventsThreshold),\n    );\n    this.watchful.createAlarm(this,\n      'ThrottledRequestsEvents',\n      this.createThrottledRequestsEventsAlarm(props.throttledRequestsEventsThreshold),\n    );\n  }\n\n  private createReadThrottleEventsAlarm(readThrottleEventsThreshold = 1): MetricAlarmProps {\n\n    const dynamoDbMetric = new cw.Metric({\n      metricName: 'ReadThrottleEvents',\n      namespace: 'AWS/DynamoDB',\n      period: Duration.seconds(60),\n      statistic: cw.Statistic.SUM,\n      dimensionsMap: {\n        TableName: this.dynamoDb.tableName,\n      },\n    });\n    return {\n      metric: dynamoDbMetric,\n      alarmDescription:\n        'Reads are throttled. Lower ReadCapacityUnitsUtilizationTarget or increase MaxReadCapacityUnits.',\n      comparisonOperator: cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      threshold: readThrottleEventsThreshold,\n      treatMissingData: cw.TreatMissingData.NOT_BREACHING,\n      evaluationPeriods: 1,\n    };\n  }\n  private createWriteThrottleEventsAlarm(writeThrottleEventsThreshold = 1): MetricAlarmProps {\n    const dynamoDbMetric = new cw.Metric({\n      metricName: 'WriteThrottleEvents',\n      namespace: 'AWS/DynamoDB',\n      period: Duration.seconds(60),\n      statistic: cw.Statistic.SUM,\n      dimensionsMap: {\n        TableName: this.dynamoDb.tableName,\n      },\n    });\n    return {\n      metric: dynamoDbMetric,\n      alarmDescription:\n        'Writes are throttled. Lower WriteCapacityUnitsUtilizationTarget or increase MaxWriteCapacityUnits.',\n      comparisonOperator: cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      threshold: writeThrottleEventsThreshold,\n      treatMissingData: cw.TreatMissingData.NOT_BREACHING,\n      evaluationPeriods: 1,\n    };\n  }\n  private createThrottledRequestsEventsAlarm(throttledRequestsEventsThreshold = 1): MetricAlarmProps {\n    const dynamoDbMetric = new cw.Metric({\n      metricName: 'ThrottledRequests',\n      namespace: 'AWS/DynamoDB',\n      period: Duration.seconds(60),\n      statistic: cw.Statistic.SUM,\n      dimensionsMap: {\n        TableName: this.dynamoDb.tableName,\n      },\n    });\n    return {\n      metric: dynamoDbMetric,\n      alarmDescription:\n        'Batch requests are throttled. Lower {Read/Write}CapacityUnitsUtilizationTarget or increase Max{Read/Write}CapacityUnits.',\n      comparisonOperator: cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      threshold: throttledRequestsEventsThreshold,\n      treatMissingData: cw.TreatMissingData.NOT_BREACHING,\n      evaluationPeriods: 1,\n    };\n  }\n}\n"]}

package/lib/watchful/ecs.d.ts

@@ -0,0 +1,50 @@
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import { Construct } from 'constructs';
+import { IWatchful } from './watchful';
+/**
+ * Options for defining alarms.
+ */
+export interface WatchEcsServiceOptions {
+    /**
+       * Threshold for the cpu utilization alarm as percentage.
+       *
+       * @default 80
+       */
+    readonly cpuUtilizationThresholdPercent?: number;
+    /**
+       * Threshold for the memory utilization alarm as percentage.
+       *
+       * @default 95
+       */
+    readonly memoryUtilizationThresholdPercent?: number;
+}
+/**
+ * Properties for defining a WatchEcsService
+ */
+export interface WatchEcsServiceProps extends WatchEcsServiceOptions {
+    /**
+       * The reference to IWatchful class. Used internally.
+       */
+    readonly watchful: IWatchful;
+    /**
+       * The ECS service that should be watched.
+       * [disable-awslint:ref-via-interface]
+       */
+    readonly service: ecs.BaseService;
+}
+/**
+ * A Construct which creates default alarms for ECS services.
+ * A Construct which creates the following alarms for ECS services:
+ *
+ * - cpu utilization
+ * - memory utilization
+ * - error log alert
+ */
+export declare class WatchEcsService extends Construct {
+    private readonly watchful;
+    private readonly service;
+    constructor(scope: Construct, id: string, props: WatchEcsServiceProps);
+    private createLogErrorMonitor;
+    private createCpuUtilizationMonitor;
+    private createMemoryUtilizationMonitor;
+}