@rio-cloud/cdk-v2-constructs 4.13.1 → 4.14.0

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDogMetricAlarm = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const datadogv2_1 = require("../datadogv2");
+const upperToLower_1 = require("../watchful/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) {
+        super(scope, id);
+        new datadogv2_1.DatadogMonitor(this, 'ErrorMonitorMetricAlert', {
+            serviceName: props.serviceName,
+            name: `${this.node.scope?.node.id} ${id}`,
+            monitorType: datadogv2_1.DatadogMonitorQueryAlertType.QUERY_ALERT,
+            query: this.alarmToDataDogQuery(props),
+            message: this.getMessage(props),
+            notification: props.notification,
+        });
+    }
+    getMessage(props) {
+        return `
+{{#is_alert}}
+${props.alarmDescription}
+{{/is_alert}} 
+
+{{#is_alert_recovery}}
+${props.alarmDescription} is back to normal.
+{{/is_alert_recovery}}`;
+    }
+    /**
+     * Helper function to convert a generic alarm into a DataDog query string.
+     */
+    alarmToDataDogQuery(alarm) {
+        let unit;
+        let totalPeriod;
+        if (alarm.metric.period.toSeconds() < 60) {
+            totalPeriod = alarm.metric.period.toSeconds() * alarm.evaluationPeriods;
+            unit = 's';
+        }
+        else 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 cdk.aws_cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD:
+                comparisonOperator = '>=';
+                break;
+            case cdk.aws_cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD:
+                comparisonOperator = '>';
+                break;
+            case cdk.aws_cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD:
+                comparisonOperator = '<=';
+                break;
+            case cdk.aws_cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD:
+                comparisonOperator = '<';
+                break;
+        }
+        let alarmStatistic = 'not supported';
+        switch (alarm.metric.statistic) {
+            case cdk.aws_cloudwatch.Statistic.AVERAGE:
+                alarmStatistic = 'avg';
+                break;
+            case cdk.aws_cloudwatch.Statistic.MAXIMUM:
+                alarmStatistic = 'max';
+                break;
+            case cdk.aws_cloudwatch.Statistic.MINIMUM:
+                alarmStatistic = 'min';
+                break;
+            case cdk.aws_cloudwatch.Statistic.SAMPLE_COUNT:
+                break;
+            case cdk.aws_cloudwatch.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: upperToLower_1.UpperToLower.getOrCreate(this).provider.serviceToken,
+                    properties: {
+                        Upper: alarm.metric.dimensions[key],
+                    },
+                });
+                const value = upperToLowerCr.getAtt('Lower');
+                dimensions += `,${key.toLocaleLowerCase()}:${value}`;
+            }
+        }
+        switch (alarm.treatMissingData) {
+            case cdk.aws_cloudwatch.TreatMissingData.NOT_BREACHING:
+                return `${alarmStatistic}(last_${totalPeriod}${unit}):default_zero(${alarmStatistic}:${metric}{${dimensions}}) ${comparisonOperator} ${alarm.threshold}`;
+            case cdk.aws_cloudwatch.TreatMissingData.BREACHING:
+            case cdk.aws_cloudwatch.TreatMissingData.IGNORE:
+            default:
+                return `${alarmStatistic}(last_${totalPeriod}${unit}):${alarmStatistic}:${metric}{${dimensions}} ${comparisonOperator} ${alarm.threshold}`;
+        }
+    }
+}
+exports.DataDogMetricAlarm = DataDogMetricAlarm;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-metric-alarm.js","sourceRoot":"","sources":["../../src/watchfulv2/datadog-metric-alarm.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { CustomResource, Stack } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { DatadogMonitor, DatadogMonitorQueryAlertType, INotification } from '../datadogv2';\nimport { MetricAlarmProps } from '../watchful/metric-alarm';\nimport { UpperToLower } from '../watchful/upperToLower';\n\n\n/**\n * Interface for DataDogMonitor implementation.\n */\nexport interface DataDogMetricAlarmProps extends MetricAlarmProps {\n\n  /**\n     * The service name used to name and tag the monitors.\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 notification?: INotification;\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\n  constructor(scope: Construct, id: string, props: DataDogMetricAlarmProps) {\n    super(scope, id);\n\n    new DatadogMonitor(this,\n      'ErrorMonitorMetricAlert',\n      {\n        serviceName: props.serviceName,\n        name: `${this.node.scope?.node.id} ${id}`,\n        monitorType: DatadogMonitorQueryAlertType.QUERY_ALERT,\n        query: this.alarmToDataDogQuery(props),\n        message: this.getMessage(props),\n        notification: props.notification,\n      });\n\n  }\n\n  private getMessage(props: DataDogMetricAlarmProps) {\n    return `\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\n  /**\n   * Helper function to convert a generic alarm into a DataDog query string.\n   */\n  alarmToDataDogQuery(alarm: MetricAlarmProps): string {\n    let unit: string;\n    let totalPeriod: number;\n    if (alarm.metric.period.toSeconds() < 60) {\n      totalPeriod = alarm.metric.period.toSeconds() * alarm.evaluationPeriods;\n      unit = 's';\n    } else 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 cdk.aws_cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD:\n        comparisonOperator = '>=';\n        break;\n      case cdk.aws_cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD:\n        comparisonOperator = '>';\n        break;\n      case cdk.aws_cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD:\n        comparisonOperator = '<=';\n        break;\n      case cdk.aws_cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD:\n        comparisonOperator = '<';\n        break;\n    }\n\n    let alarmStatistic = 'not supported';\n    switch (alarm.metric.statistic) {\n      case cdk.aws_cloudwatch.Statistic.AVERAGE:\n        alarmStatistic = 'avg';\n        break;\n      case cdk.aws_cloudwatch.Statistic.MAXIMUM:\n        alarmStatistic = 'max';\n        break;\n      case cdk.aws_cloudwatch.Statistic.MINIMUM:\n        alarmStatistic = 'min';\n        break;\n      case cdk.aws_cloudwatch.Statistic.SAMPLE_COUNT:\n        break;\n      case cdk.aws_cloudwatch.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: UpperToLower.getOrCreate(this).provider.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 cdk.aws_cloudwatch.TreatMissingData.NOT_BREACHING:\n        return `${alarmStatistic}(last_${totalPeriod}${unit}):default_zero(${alarmStatistic}:${metric}{${dimensions}}) ${comparisonOperator} ${alarm.threshold}`;\n      case cdk.aws_cloudwatch.TreatMissingData.BREACHING:\n      case cdk.aws_cloudwatch.TreatMissingData.IGNORE:\n      default:\n        return `${alarmStatistic}(last_${totalPeriod}${unit}):${alarmStatistic}:${metric}{${dimensions}} ${comparisonOperator} ${alarm.threshold}`;\n    }\n  }\n}\n"]}

package/lib/watchfulv2/index.d.ts

@@ -0,0 +1 @@
+export * from './watchful';

package/lib/watchfulv2/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./watchful"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2F0Y2hmdWx2Mi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dhdGNoZnVsJzsiXX0=

package/lib/watchfulv2/watchful.d.ts

@@ -0,0 +1,53 @@
+import { Construct } from 'constructs';
+import { INotification } from '../datadogv2';
+import { MetricAlarmProps, AbstractWatchful } from '../watchful';
+import { LogAlarmProps } from './datadog-log-alarm';
+/**
+ * Properties for defining Watchful
+ */
+export interface WatchfulProps {
+    /**
+     * The service name.
+     *
+     * @defaultValue The stack name.
+     */
+    readonly serviceName?: string;
+    /**
+     * Set the way how monitors should notify in case of an alert.
+     *
+     * @defaultValue {@link DefaultSlackNotification}
+     */
+    readonly notification?: INotification;
+}
+/**
+ * A construct to watch given scope or resources. Opinionated DataDog alarms are automatically created for watched resources.
+ *
+ * Usage with non-default notification:
+ * ```ts
+ * const dw = new watchfulv2.Watchful(this, 'Watchful', {
+ *   serviceName: props.serviceName,
+ *   notification: new datadogv2.SlackNotification({channel: 'team-alert-channel'})
+ * });
+ * dw.watchScope(this);
+ *```
+ */
+export declare class Watchful extends AbstractWatchful {
+    private readonly notification;
+    private readonly serviceName;
+    constructor(scope: Construct, id: string, props?: WatchfulProps);
+    /**
+     * Adds the alarmTopic as alarm action to the given alarm.
+     *
+     * @param alarm - The watchful to add those resources to
+     */
+    createAlarm(scope: Construct, id: string, alarm: MetricAlarmProps): void;
+    /**
+     * Adds an alert for error logs
+     * @param scope
+     */
+    createLogAlarm(scope: Construct, id: string, alarm: LogAlarmProps): void;
+    /**
+     * Watches the given scope and adds alarms for known resources.
+     */
+    watchScope(scope: Construct): void;
+}

package/lib/watchfulv2/watchful.js

@@ -0,0 +1,76 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watchful = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const datadogv2_1 = require("../datadogv2");
+const watchful_1 = require("../watchful");
+const datadog_log_alarm_1 = require("./datadog-log-alarm");
+const datadog_metric_alarm_1 = require("./datadog-metric-alarm");
+/**
+ * A construct to watch given scope or resources. Opinionated DataDog alarms are automatically created for watched resources.
+ *
+ * Usage with non-default notification:
+ * ```ts
+ * const dw = new watchfulv2.Watchful(this, 'Watchful', {
+ *   serviceName: props.serviceName,
+ *   notification: new datadogv2.SlackNotification({channel: 'team-alert-channel'})
+ * });
+ * dw.watchScope(this);
+ *```
+ */
+class Watchful extends watchful_1.AbstractWatchful {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.serviceName = props.serviceName ?? aws_cdk_lib_1.Stack.of(this).stackName;
+        this.notification = props.notification ?? new datadogv2_1.DefaultSlackNotification();
+    }
+    /**
+     * Adds the alarmTopic as alarm action to the given alarm.
+     *
+     * @param alarm - The watchful to add those resources to
+     */
+    createAlarm(scope, id, alarm) {
+        new datadog_metric_alarm_1.DataDogMetricAlarm(scope, id, {
+            serviceName: this.serviceName,
+            notification: this.notification,
+            alarmDescription: alarm.alarmDescription,
+            comparisonOperator: alarm.comparisonOperator,
+            evaluationPeriods: alarm.evaluationPeriods,
+            metric: alarm.metric,
+            threshold: alarm.threshold,
+            treatMissingData: alarm.treatMissingData,
+        });
+    }
+    /**
+     * Adds an alert for error logs
+     * @param scope
+     */
+    createLogAlarm(scope, id, alarm) {
+        new datadog_log_alarm_1.DataDogLogAlarm(scope, id, {
+            serviceName: alarm.lambdaCloudwatchGroupName ?? this.serviceName,
+            autoCloseOpsGenieAlerts: alarm.autoCloseOpsGenieAlerts,
+            period: alarm.period,
+            unitOfPeriod: alarm.unitOfPeriod,
+            periodOperator: alarm.periodOperator,
+            statistic: alarm.statistic,
+            queryFilters: alarm.queryFilters,
+            alarmDescription: alarm.alarmDescription,
+            threshold: alarm.threshold,
+            priority: alarm.priority,
+            index: alarm.index,
+        });
+    }
+    /**
+     * Watches the given scope and adds alarms for known resources.
+     */
+    watchScope(scope) {
+        const aspect = new watchful_1.WatchfulAspect(this);
+        aws_cdk_lib_1.Aspects.of(scope).add(aspect);
+    }
+}
+exports.Watchful = Watchful;
+_a = JSII_RTTI_SYMBOL_1;
+Watchful[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.watchfulv2.Watchful", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -15,9 +15,14 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "4.13.1",
+  "version": "4.14.0",
   "types": "lib/index.d.ts",
   "stability": "stable",
+  "exports": {
+    ".": "./lib/index.js",
+    "./datadogv2": "./lib/datadogv2/index.js",
+    "./watchfulv2": "./lib/watchfulv2/index.js"
+  },
   "jsii": {
     "outdir": "dist",
     "targets": {},
@@ -47,7 +52,8 @@
     "release:check-last-commit": "node release-commit-check.js",
     "release:build": "npm run build && npm run bump",
     "release:push": "echo '✅  pushing release' && git push origin master --follow-tags",
-    "release": "npm run release:check-last-commit && npm run release:build"
+    "release": "npm run release:check-last-commit && npm run release:build",
+    "release:dry-run": "npm run build && npm run release:check && standard-version --dry-run"
   },
   "devDependencies": {
     "@types/jest": "27.4.1",
@@ -55,15 +61,16 @@
     "@types/node": "17.0.23",
     "@typescript-eslint/eslint-plugin": "5.18.0",
     "@typescript-eslint/parser": "5.18.0",
-    "aws-cdk": "^2.77.0",
-    "aws-cdk-lib": "^2.77.0",
-    "constructs": "10.0.107",
+    "aws-cdk": "~2.81.0",
+    "aws-cdk-lib": "2.81.0",
+    "constructs": "10.2.69",
     "copyfiles": "2.4.1",
     "esbuild": "0.14.32",
     "eslint": "8.12.0",
     "eslint-import-resolver-node": "0.3.6",
     "eslint-import-resolver-typescript": "2.7.1",
     "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-tsdoc": "^0.2.17",
     "jest": "~27.5.1 ",
     "jest-junit": "13.1.0",
     "jsii": "~1.78.0",
@@ -74,8 +81,8 @@
     "typescript": "~4.6.4"
   },
   "peerDependencies": {
-    "aws-cdk-lib": "^2.41.0",
-    "constructs": "^10.0.107"
+    "aws-cdk-lib": "~2.81.0",
+    "constructs": "^10.2.69"
   },
   "dependencies": {
     "js-yaml": "~4.1.0"
@@ -124,5 +131,8 @@
         "tsconfig": "tsconfig.dev.json"
       }
     }
-  }
+  },
+  "bundleDependencies": [
+    "js-yaml"
+  ]
 }

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "4.13.1"
+  "version": "4.14.0"
 }