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

package/lib/watchful/alb.d.ts

@@ -0,0 +1,47 @@
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { Construct } from 'constructs';
+import { IWatchful } from './watchful';
+/**
+ * Options for defining alarms.
+ */
+export interface WatchApplicationLoadBalancerOptions {
+    /**
+       * Number of allowed rejected connections per minute.
+       *
+       * @default 0
+       */
+    readonly rejectedConnectionPerMinuteThreshold?: number;
+    /**
+       * Number of allowed HTTP 5xx requests per minute.
+       *
+       * @default 0
+       */
+    readonly http5xxPerMinuteThreshold?: number;
+}
+/**
+ * Properties for defining a WatchApplicationLoadBalancer
+ */
+export interface WatchApplicationLoadBalancerProps extends WatchApplicationLoadBalancerOptions {
+    /**
+       * The reference to IWatchful class. Used internally.
+       */
+    readonly watchful: IWatchful;
+    /**
+       * The application load balancer that should be watched.
+       * [disable-awslint:ref-via-interface]
+       */
+    readonly alb: elbv2.ApplicationLoadBalancer;
+}
+/**
+ * A Construct which creates the following alarms for application load balancers:
+ *
+ * - rejected connections
+ * - http-code 5xx
+ */
+export declare class WatchApplicationLoadBalancer extends Construct {
+    private readonly watchful;
+    private readonly alb;
+    constructor(scope: Construct, id: string, props: WatchApplicationLoadBalancerProps);
+    private createRejectedConnectionMonitor;
+    private createHttpCode5xxMonitor;
+}

package/lib/watchful/alb.js

@@ -0,0 +1,52 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchApplicationLoadBalancer = 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 elbv2 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const constructs_1 = require("constructs");
+/**
+ * A Construct which creates the following alarms for application load balancers:
+ *
+ * - rejected connections
+ * - http-code 5xx
+ */
+class WatchApplicationLoadBalancer extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.watchful = props.watchful;
+        this.alb = props.alb;
+        this.watchful.createAlarm(this, 'RejectedConnection', this.createRejectedConnectionMonitor(props.rejectedConnectionPerMinuteThreshold));
+        this.watchful.createAlarm(this, 'HttpCode5xx', this.createHttpCode5xxMonitor(props.http5xxPerMinuteThreshold));
+    }
+    createRejectedConnectionMonitor(rejectedConnectionPerMinuteThreshold = 0) {
+        const rejectedMetric = this.alb.metricRejectedConnectionCount().with({ period: aws_cdk_lib_1.Duration.seconds(60) });
+        return {
+            metric: rejectedMetric,
+            alarmDescription: `Over ${rejectedConnectionPerMinuteThreshold} rejected connections per minute`,
+            comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: rejectedConnectionPerMinuteThreshold,
+            treatMissingData: cw.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: 1,
+        };
+    }
+    createHttpCode5xxMonitor(http5xxPerMinuteThreshold = 0) {
+        const http5xxMetric = this.alb
+            .metricHttpCodeElb(elbv2.HttpCodeElb.ELB_5XX_COUNT)
+            .with({ period: aws_cdk_lib_1.Duration.seconds(60) });
+        return {
+            metric: http5xxMetric,
+            alarmDescription: `Over ${http5xxPerMinuteThreshold} 5xx requests per minute`,
+            comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            threshold: http5xxPerMinuteThreshold,
+            treatMissingData: cw.TreatMissingData.NOT_BREACHING,
+            evaluationPeriods: 1,
+        };
+    }
+}
+exports.WatchApplicationLoadBalancer = WatchApplicationLoadBalancer;
+_a = JSII_RTTI_SYMBOL_1;
+WatchApplicationLoadBalancer[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.WatchApplicationLoadBalancer", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/watchful/aspect.d.ts

@@ -0,0 +1,16 @@
+import { IAspect } from 'aws-cdk-lib';
+import { IConstruct } from 'constructs';
+import { Watchful } from './watchful';
+/**
+ * A CDK aspect that can automatically watch all resources within a scope.
+ */
+export declare class WatchfulAspect implements IAspect {
+    private readonly watchful;
+    /**
+       * Defines a watchful aspect
+       * @param watchful The watchful to add those resources to
+       * @param props Options
+       */
+    constructor(watchful: Watchful);
+    visit(node: IConstruct): void;
+}

package/lib/watchful/aspect.js

@@ -0,0 +1,55 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchfulAspect = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cloudfront = require("aws-cdk-lib/aws-cloudfront");
+const docdb = require("aws-cdk-lib/aws-docdb");
+const dynamodb = require("aws-cdk-lib/aws-dynamodb");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const elbv2 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const rds = require("aws-cdk-lib/aws-rds");
+/**
+ * A CDK aspect that can automatically watch all resources within a scope.
+ */
+class WatchfulAspect {
+    /**
+       * Defines a watchful aspect
+       * @param watchful The watchful to add those resources to
+       * @param props Options
+       */
+    constructor(watchful) {
+        this.watchful = watchful;
+    }
+    visit(node) {
+        if (node instanceof lambda.Function) {
+            this.watchful.watchLambdaFunction(node);
+        }
+        if (node instanceof ecs.BaseService) {
+            this.watchful.watchEcsService(node);
+        }
+        if (node instanceof elbv2.ApplicationLoadBalancer) {
+            this.watchful.watchAlb(node);
+        }
+        if (node instanceof elbv2.ApplicationTargetGroup) {
+            this.watchful.watchApplicationTargetGroup(node);
+        }
+        if (node instanceof docdb.DatabaseCluster) {
+            this.watchful.watchDocDb(node);
+        }
+        if (node instanceof rds.DatabaseCluster) {
+            this.watchful.watchDatabaseCluster(node);
+        }
+        if (node instanceof cloudfront.Distribution) {
+            this.watchful.watchCloudfrontDistribution(node);
+        }
+        if (node instanceof dynamodb.Table) {
+            this.watchful.watchDynamoDbTable(node);
+        }
+    }
+}
+exports.WatchfulAspect = WatchfulAspect;
+_a = JSII_RTTI_SYMBOL_1;
+WatchfulAspect[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.WatchfulAspect", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNwZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dhdGNoZnVsL2FzcGVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLHlEQUF5RDtBQUN6RCwrQ0FBK0M7QUFDL0MscURBQXFEO0FBQ3JELDJDQUEyQztBQUMzQyxnRUFBZ0U7QUFDaEUsaURBQWlEO0FBQ2pELDJDQUEyQztBQUkzQzs7R0FFRztBQUNILE1BQWEsY0FBYztJQUN6Qjs7OztTQUlLO0lBQ0wsWUFBNkIsUUFBa0I7UUFBbEIsYUFBUSxHQUFSLFFBQVEsQ0FBVTtJQUFHLENBQUM7SUFFNUMsS0FBSyxDQUFDLElBQWdCO1FBQzNCLElBQUksSUFBSSxZQUFZLE1BQU0sQ0FBQyxRQUFRLEVBQUU7WUFDbkMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUN6QztRQUNELElBQUksSUFBSSxZQUFZLEdBQUcsQ0FBQyxXQUFXLEVBQUU7WUFDbkMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDckM7UUFDRCxJQUFJLElBQUksWUFBWSxLQUFLLENBQUMsdUJBQXVCLEVBQUU7WUFDakQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDOUI7UUFDRCxJQUFJLElBQUksWUFBWSxLQUFLLENBQUMsc0JBQXNCLEVBQUU7WUFDaEQsSUFBSSxDQUFDLFFBQVEsQ0FBQywyQkFBMkIsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNqRDtRQUNELElBQUksSUFBSSxZQUFZLEtBQUssQ0FBQyxlQUFlLEVBQUU7WUFDekMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDaEM7UUFDRCxJQUFJLElBQUksWUFBWSxHQUFHLENBQUMsZUFBZSxFQUFFO1lBQ3ZDLElBQUksQ0FBQyxRQUFRLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDMUM7UUFDRCxJQUFJLElBQUksWUFBWSxVQUFVLENBQUMsWUFBWSxFQUFFO1lBQzNDLElBQUksQ0FBQyxRQUFRLENBQUMsMkJBQTJCLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDakQ7UUFDRCxJQUFJLElBQUksWUFBWSxRQUFRLENBQUMsS0FBSyxFQUFFO1lBQ2xDLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDeEM7SUFDSCxDQUFDOztBQWpDSCx3Q0FrQ0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJQXNwZWN0IH0gZnJvbSAnYXdzLWNkay1saWInO1xuaW1wb3J0ICogYXMgY2xvdWRmcm9udCBmcm9tICdhd3MtY2RrLWxpYi9hd3MtY2xvdWRmcm9udCc7XG5pbXBvcnQgKiBhcyBkb2NkYiBmcm9tICdhd3MtY2RrLWxpYi9hd3MtZG9jZGInO1xuaW1wb3J0ICogYXMgZHluYW1vZGIgZnJvbSAnYXdzLWNkay1saWIvYXdzLWR5bmFtb2RiJztcbmltcG9ydCAqIGFzIGVjcyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtZWNzJztcbmltcG9ydCAqIGFzIGVsYnYyIGZyb20gJ2F3cy1jZGstbGliL2F3cy1lbGFzdGljbG9hZGJhbGFuY2luZ3YyJztcbmltcG9ydCAqIGFzIGxhbWJkYSBmcm9tICdhd3MtY2RrLWxpYi9hd3MtbGFtYmRhJztcbmltcG9ydCAqIGFzIHJkcyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtcmRzJztcbmltcG9ydCB7IElDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCB7IFdhdGNoZnVsIH0gZnJvbSAnLi93YXRjaGZ1bCc7XG5cbi8qKlxuICogQSBDREsgYXNwZWN0IHRoYXQgY2FuIGF1dG9tYXRpY2FsbHkgd2F0Y2ggYWxsIHJlc291cmNlcyB3aXRoaW4gYSBzY29wZS5cbiAqL1xuZXhwb3J0IGNsYXNzIFdhdGNoZnVsQXNwZWN0IGltcGxlbWVudHMgSUFzcGVjdCB7XG4gIC8qKlxuICAgICAqIERlZmluZXMgYSB3YXRjaGZ1bCBhc3BlY3RcbiAgICAgKiBAcGFyYW0gd2F0Y2hmdWwgVGhlIHdhdGNoZnVsIHRvIGFkZCB0aG9zZSByZXNvdXJjZXMgdG9cbiAgICAgKiBAcGFyYW0gcHJvcHMgT3B0aW9uc1xuICAgICAqL1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHdhdGNoZnVsOiBXYXRjaGZ1bCkge31cblxuICBwdWJsaWMgdmlzaXQobm9kZTogSUNvbnN0cnVjdCk6IHZvaWQge1xuICAgIGlmIChub2RlIGluc3RhbmNlb2YgbGFtYmRhLkZ1bmN0aW9uKSB7XG4gICAgICB0aGlzLndhdGNoZnVsLndhdGNoTGFtYmRhRnVuY3Rpb24obm9kZSk7XG4gICAgfVxuICAgIGlmIChub2RlIGluc3RhbmNlb2YgZWNzLkJhc2VTZXJ2aWNlKSB7XG4gICAgICB0aGlzLndhdGNoZnVsLndhdGNoRWNzU2VydmljZShub2RlKTtcbiAgICB9XG4gICAgaWYgKG5vZGUgaW5zdGFuY2VvZiBlbGJ2Mi5BcHBsaWNhdGlvbkxvYWRCYWxhbmNlcikge1xuICAgICAgdGhpcy53YXRjaGZ1bC53YXRjaEFsYihub2RlKTtcbiAgICB9XG4gICAgaWYgKG5vZGUgaW5zdGFuY2VvZiBlbGJ2Mi5BcHBsaWNhdGlvblRhcmdldEdyb3VwKSB7XG4gICAgICB0aGlzLndhdGNoZnVsLndhdGNoQXBwbGljYXRpb25UYXJnZXRHcm91cChub2RlKTtcbiAgICB9XG4gICAgaWYgKG5vZGUgaW5zdGFuY2VvZiBkb2NkYi5EYXRhYmFzZUNsdXN0ZXIpIHtcbiAgICAgIHRoaXMud2F0Y2hmdWwud2F0Y2hEb2NEYihub2RlKTtcbiAgICB9XG4gICAgaWYgKG5vZGUgaW5zdGFuY2VvZiByZHMuRGF0YWJhc2VDbHVzdGVyKSB7XG4gICAgICB0aGlzLndhdGNoZnVsLndhdGNoRGF0YWJhc2VDbHVzdGVyKG5vZGUpO1xuICAgIH1cbiAgICBpZiAobm9kZSBpbnN0YW5jZW9mIGNsb3VkZnJvbnQuRGlzdHJpYnV0aW9uKSB7XG4gICAgICB0aGlzLndhdGNoZnVsLndhdGNoQ2xvdWRmcm9udERpc3RyaWJ1dGlvbihub2RlKTtcbiAgICB9XG4gICAgaWYgKG5vZGUgaW5zdGFuY2VvZiBkeW5hbW9kYi5UYWJsZSkge1xuICAgICAgdGhpcy53YXRjaGZ1bC53YXRjaER5bmFtb0RiVGFibGUobm9kZSk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/lib/watchful/cloudfront.d.ts

@@ -0,0 +1,50 @@
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+import { Construct } from 'constructs';
+import { IWatchful } from './watchful';
+/**
+ * Options for defining alarms.
+ */
+export interface WatchCloudfrontDistributionOptions {
+    /**
+       * Number of allowed errors per minute. If there are more errors than that, an alarm will trigger.
+       *
+       * @default 0
+       */
+    readonly errorsPerMinuteThreshold?: number;
+    /**
+       * Threshold for the cache hit alarm as percentage of the Cloudfront Distribution
+       *
+       * If this is set to 40%, the alarm will be set when the cache hit perentage is
+       * lower than the threshold setting
+       *
+       * @default 40
+       */
+    readonly cacheHitPercent?: number;
+}
+/**
+ * Properties for defining a WatchCloudfrontDistribution
+ */
+export interface WatchCloudfrontDistributionProps extends WatchCloudfrontDistributionOptions {
+    /**
+       * The reference to IWatchful class. Used internally.
+       */
+    readonly watchful: IWatchful;
+    /**
+       * The cloudfront distribution that should be watched.
+       * [disable-awslint:ref-via-interface]
+       */
+    readonly cf: cloudfront.Distribution;
+}
+/**
+ * A Construct which creates the following alarms for cloudfront distributions:
+ *
+ * - http-code 5xx
+ * - low cache hits
+ */
+export declare class WatchCloudfrontDistribution extends Construct {
+    private readonly watchful;
+    private readonly cf;
+    constructor(scope: Construct, id: string, props: WatchCloudfrontDistributionProps);
+    private create5xxMonitor;
+    private createCacheHitMonitor;
+}

package/lib/watchful/cloudfront.js

@@ -0,0 +1,65 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchCloudfrontDistribution = 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 cloudfront distributions:
+ *
+ * - http-code 5xx
+ * - low cache hits
+ */
+class WatchCloudfrontDistribution extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.watchful = props.watchful;
+        this.cf = props.cf;
+        this.watchful.createAlarm(this, '5xxError', this.create5xxMonitor(props.errorsPerMinuteThreshold));
+        this.watchful.createAlarm(this, 'cacheHitRate', this.createCacheHitMonitor(props.cacheHitPercent));
+    }
+    create5xxMonitor(errorsPerMinuteThreshold = 0) {
+        const errorMetrics5xx = new cw.Metric({
+            metricName: '5xxErrorRate',
+            namespace: 'AWS/CloudFront',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                Region: 'Global',
+                DistributionId: this.cf.distributionId,
+            },
+        });
+        return {
+            metric: errorMetrics5xx,
+            alarmDescription: `Over ${errorsPerMinuteThreshold} 5xx errors per minute`,
+            threshold: errorsPerMinuteThreshold,
+            comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            evaluationPeriods: 3,
+        };
+    }
+    createCacheHitMonitor(cacheHitRateThreshold = 40) {
+        const cacheHitRateMetric = new cw.Metric({
+            metricName: 'CacheHitRate',
+            namespace: 'AWS/CloudFront',
+            period: aws_cdk_lib_1.Duration.seconds(600),
+            statistic: cw.Statistic.AVERAGE,
+            dimensionsMap: {
+                Region: 'Global',
+                DistributionId: this.cf.distributionId,
+            },
+        });
+        return {
+            metric: cacheHitRateMetric,
+            alarmDescription: `Cache hit rate less than ${cacheHitRateThreshold}`,
+            threshold: cacheHitRateThreshold,
+            comparisonOperator: cw.ComparisonOperator.LESS_THAN_THRESHOLD,
+            evaluationPeriods: 3,
+        };
+    }
+}
+exports.WatchCloudfrontDistribution = WatchCloudfrontDistribution;
+_a = JSII_RTTI_SYMBOL_1;
+WatchCloudfrontDistribution[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.WatchCloudfrontDistribution", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvdWRmcm9udC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YXRjaGZ1bC9jbG91ZGZyb250LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsNkNBQXVDO0FBRXZDLGlEQUFpRDtBQUNqRCwyQ0FBdUM7QUEwQ3ZDOzs7OztHQUtHO0FBQ0gsTUFBYSwyQkFBNEIsU0FBUSxzQkFBUztJQUl4RCxZQUFZLEtBQWdCLEVBQUUsRUFBVSxFQUFFLEtBQXVDO1FBQy9FLEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUMsUUFBUSxDQUFDO1FBQy9CLElBQUksQ0FBQyxFQUFFLEdBQUcsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNuQixJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQyxDQUFDO1FBQ25HLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxjQUFjLEVBQUUsSUFBSSxDQUFDLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDO0lBQ3JHLENBQUM7SUFFTyxnQkFBZ0IsQ0FBQyx3QkFBd0IsR0FBRyxDQUFDO1FBQ25ELE1BQU0sZUFBZSxHQUFHLElBQUksRUFBRSxDQUFDLE1BQU0sQ0FBQztZQUNwQyxVQUFVLEVBQUUsY0FBYztZQUMxQixTQUFTLEVBQUUsZ0JBQWdCO1lBQzNCLE1BQU0sRUFBRSxzQkFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7WUFDN0IsU0FBUyxFQUFFLEVBQUUsQ0FBQyxTQUFTLENBQUMsT0FBTztZQUMvQixhQUFhLEVBQUU7Z0JBQ2IsTUFBTSxFQUFFLFFBQVE7Z0JBQ2hCLGNBQWMsRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLGNBQWM7YUFDdkM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPO1lBQ0wsTUFBTSxFQUFFLGVBQWU7WUFDdkIsZ0JBQWdCLEVBQUUsUUFBUSx3QkFBd0Isd0JBQXdCO1lBQzFFLFNBQVMsRUFBRSx3QkFBd0I7WUFDbkMsa0JBQWtCLEVBQUUsRUFBRSxDQUFDLGtCQUFrQixDQUFDLHNCQUFzQjtZQUNoRSxpQkFBaUIsRUFBRSxDQUFDO1NBQ3JCLENBQUM7SUFDSixDQUFDO0lBRU8scUJBQXFCLENBQUMscUJBQXFCLEdBQUcsRUFBRTtRQUN0RCxNQUFNLGtCQUFrQixHQUFHLElBQUksRUFBRSxDQUFDLE1BQU0sQ0FBQztZQUN2QyxVQUFVLEVBQUUsY0FBYztZQUMxQixTQUFTLEVBQUUsZ0JBQWdCO1lBQzNCLE1BQU0sRUFBRSxzQkFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7WUFDN0IsU0FBUyxFQUFFLEVBQUUsQ0FBQyxTQUFTLENBQUMsT0FBTztZQUMvQixhQUFhLEVBQUU7Z0JBQ2IsTUFBTSxFQUFFLFFBQVE7Z0JBQ2hCLGNBQWMsRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLGNBQWM7YUFDdkM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPO1lBQ0wsTUFBTSxFQUFFLGtCQUFrQjtZQUMxQixnQkFBZ0IsRUFBRSw0QkFBNEIscUJBQXFCLEVBQUU7WUFDckUsU0FBUyxFQUFFLHFCQUFxQjtZQUNoQyxrQkFBa0IsRUFBRSxFQUFFLENBQUMsa0JBQWtCLENBQUMsbUJBQW1CO1lBQzdELGlCQUFpQixFQUFFLENBQUM7U0FDckIsQ0FBQztJQUNKLENBQUM7O0FBbkRILGtFQW9EQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IER1cmF0aW9uIH0gZnJvbSAnYXdzLWNkay1saWInO1xuaW1wb3J0ICogYXMgY2xvdWRmcm9udCBmcm9tICdhd3MtY2RrLWxpYi9hd3MtY2xvdWRmcm9udCc7XG5pbXBvcnQgKiBhcyBjdyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtY2xvdWR3YXRjaCc7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCB7IE1ldHJpY0FsYXJtUHJvcHMgfSBmcm9tICcuL21ldHJpYy1hbGFybSc7XG5pbXBvcnQgeyBJV2F0Y2hmdWwgfSBmcm9tICcuL3dhdGNoZnVsJztcblxuLyoqXG4gKiBPcHRpb25zIGZvciBkZWZpbmluZyBhbGFybXMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgV2F0Y2hDbG91ZGZyb250RGlzdHJpYnV0aW9uT3B0aW9ucyB7XG4gIC8qKlxuICAgICAqIE51bWJlciBvZiBhbGxvd2VkIGVycm9ycyBwZXIgbWludXRlLiBJZiB0aGVyZSBhcmUgbW9yZSBlcnJvcnMgdGhhbiB0aGF0LCBhbiBhbGFybSB3aWxsIHRyaWdnZXIuXG4gICAgICpcbiAgICAgKiBAZGVmYXVsdCAwXG4gICAgICovXG4gIHJlYWRvbmx5IGVycm9yc1Blck1pbnV0ZVRocmVzaG9sZD86IG51bWJlcjtcblxuICAvKipcbiAgICAgKiBUaHJlc2hvbGQgZm9yIHRoZSBjYWNoZSBoaXQgYWxhcm0gYXMgcGVyY2VudGFnZSBvZiB0aGUgQ2xvdWRmcm9udCBEaXN0cmlidXRpb25cbiAgICAgKlxuICAgICAqIElmIHRoaXMgaXMgc2V0IHRvIDQwJSwgdGhlIGFsYXJtIHdpbGwgYmUgc2V0IHdoZW4gdGhlIGNhY2hlIGhpdCBwZXJlbnRhZ2UgaXNcbiAgICAgKiBsb3dlciB0aGFuIHRoZSB0aHJlc2hvbGQgc2V0dGluZ1xuICAgICAqXG4gICAgICogQGRlZmF1bHQgNDBcbiAgICAgKi9cbiAgcmVhZG9ubHkgY2FjaGVIaXRQZXJjZW50PzogbnVtYmVyO1xufVxuXG4vKipcbiAqIFByb3BlcnRpZXMgZm9yIGRlZmluaW5nIGEgV2F0Y2hDbG91ZGZyb250RGlzdHJpYnV0aW9uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgV2F0Y2hDbG91ZGZyb250RGlzdHJpYnV0aW9uUHJvcHMgZXh0ZW5kcyBXYXRjaENsb3VkZnJvbnREaXN0cmlidXRpb25PcHRpb25zIHtcbiAgLyoqXG4gICAgICogVGhlIHJlZmVyZW5jZSB0byBJV2F0Y2hmdWwgY2xhc3MuIFVzZWQgaW50ZXJuYWxseS5cbiAgICAgKi9cbiAgcmVhZG9ubHkgd2F0Y2hmdWw6IElXYXRjaGZ1bDtcblxuICAvKipcbiAgICAgKiBUaGUgY2xvdWRmcm9udCBkaXN0cmlidXRpb24gdGhhdCBzaG91bGQgYmUgd2F0Y2hlZC5cbiAgICAgKiBbZGlzYWJsZS1hd3NsaW50OnJlZi12aWEtaW50ZXJmYWNlXVxuICAgICAqL1xuICByZWFkb25seSBjZjogY2xvdWRmcm9udC5EaXN0cmlidXRpb247XG59XG5cbi8qKlxuICogQSBDb25zdHJ1Y3Qgd2hpY2ggY3JlYXRlcyB0aGUgZm9sbG93aW5nIGFsYXJtcyBmb3IgY2xvdWRmcm9udCBkaXN0cmlidXRpb25zOlxuICpcbiAqIC0gaHR0cC1jb2RlIDV4eFxuICogLSBsb3cgY2FjaGUgaGl0c1xuICovXG5leHBvcnQgY2xhc3MgV2F0Y2hDbG91ZGZyb250RGlzdHJpYnV0aW9uIGV4dGVuZHMgQ29uc3RydWN0IHtcbiAgcHJpdmF0ZSByZWFkb25seSB3YXRjaGZ1bDogSVdhdGNoZnVsO1xuICBwcml2YXRlIHJlYWRvbmx5IGNmOiBjbG91ZGZyb250LkRpc3RyaWJ1dGlvbjtcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBwcm9wczogV2F0Y2hDbG91ZGZyb250RGlzdHJpYnV0aW9uUHJvcHMpIHtcbiAgICBzdXBlcihzY29wZSwgaWQpO1xuXG4gICAgdGhpcy53YXRjaGZ1bCA9IHByb3BzLndhdGNoZnVsO1xuICAgIHRoaXMuY2YgPSBwcm9wcy5jZjtcbiAgICB0aGlzLndhdGNoZnVsLmNyZWF0ZUFsYXJtKHRoaXMsICc1eHhFcnJvcicsIHRoaXMuY3JlYXRlNXh4TW9uaXRvcihwcm9wcy5lcnJvcnNQZXJNaW51dGVUaHJlc2hvbGQpKTtcbiAgICB0aGlzLndhdGNoZnVsLmNyZWF0ZUFsYXJtKHRoaXMsICdjYWNoZUhpdFJhdGUnLCB0aGlzLmNyZWF0ZUNhY2hlSGl0TW9uaXRvcihwcm9wcy5jYWNoZUhpdFBlcmNlbnQpKTtcbiAgfVxuXG4gIHByaXZhdGUgY3JlYXRlNXh4TW9uaXRvcihlcnJvcnNQZXJNaW51dGVUaHJlc2hvbGQgPSAwKTogTWV0cmljQWxhcm1Qcm9wcyB7XG4gICAgY29uc3QgZXJyb3JNZXRyaWNzNXh4ID0gbmV3IGN3Lk1ldHJpYyh7XG4gICAgICBtZXRyaWNOYW1lOiAnNXh4RXJyb3JSYXRlJyxcbiAgICAgIG5hbWVzcGFjZTogJ0FXUy9DbG91ZEZyb250JyxcbiAgICAgIHBlcmlvZDogRHVyYXRpb24uc2Vjb25kcyg2MDApLFxuICAgICAgc3RhdGlzdGljOiBjdy5TdGF0aXN0aWMuQVZFUkFHRSxcbiAgICAgIGRpbWVuc2lvbnNNYXA6IHtcbiAgICAgICAgUmVnaW9uOiAnR2xvYmFsJyxcbiAgICAgICAgRGlzdHJpYnV0aW9uSWQ6IHRoaXMuY2YuZGlzdHJpYnV0aW9uSWQsXG4gICAgICB9LFxuICAgIH0pO1xuICAgIHJldHVybiB7XG4gICAgICBtZXRyaWM6IGVycm9yTWV0cmljczV4eCxcbiAgICAgIGFsYXJtRGVzY3JpcHRpb246IGBPdmVyICR7ZXJyb3JzUGVyTWludXRlVGhyZXNob2xkfSA1eHggZXJyb3JzIHBlciBtaW51dGVgLFxuICAgICAgdGhyZXNob2xkOiBlcnJvcnNQZXJNaW51dGVUaHJlc2hvbGQsXG4gICAgICBjb21wYXJpc29uT3BlcmF0b3I6IGN3LkNvbXBhcmlzb25PcGVyYXRvci5HUkVBVEVSX1RIQU5fVEhSRVNIT0xELFxuICAgICAgZXZhbHVhdGlvblBlcmlvZHM6IDMsXG4gICAgfTtcbiAgfVxuXG4gIHByaXZhdGUgY3JlYXRlQ2FjaGVIaXRNb25pdG9yKGNhY2hlSGl0UmF0ZVRocmVzaG9sZCA9IDQwKTogTWV0cmljQWxhcm1Qcm9wcyB7XG4gICAgY29uc3QgY2FjaGVIaXRSYXRlTWV0cmljID0gbmV3IGN3Lk1ldHJpYyh7XG4gICAgICBtZXRyaWNOYW1lOiAnQ2FjaGVIaXRSYXRlJyxcbiAgICAgIG5hbWVzcGFjZTogJ0FXUy9DbG91ZEZyb250JyxcbiAgICAgIHBlcmlvZDogRHVyYXRpb24uc2Vjb25kcyg2MDApLFxuICAgICAgc3RhdGlzdGljOiBjdy5TdGF0aXN0aWMuQVZFUkFHRSxcbiAgICAgIGRpbWVuc2lvbnNNYXA6IHtcbiAgICAgICAgUmVnaW9uOiAnR2xvYmFsJyxcbiAgICAgICAgRGlzdHJpYnV0aW9uSWQ6IHRoaXMuY2YuZGlzdHJpYnV0aW9uSWQsXG4gICAgICB9LFxuICAgIH0pO1xuICAgIHJldHVybiB7XG4gICAgICBtZXRyaWM6IGNhY2hlSGl0UmF0ZU1ldHJpYyxcbiAgICAgIGFsYXJtRGVzY3JpcHRpb246IGBDYWNoZSBoaXQgcmF0ZSBsZXNzIHRoYW4gJHtjYWNoZUhpdFJhdGVUaHJlc2hvbGR9YCxcbiAgICAgIHRocmVzaG9sZDogY2FjaGVIaXRSYXRlVGhyZXNob2xkLFxuICAgICAgY29tcGFyaXNvbk9wZXJhdG9yOiBjdy5Db21wYXJpc29uT3BlcmF0b3IuTEVTU19USEFOX1RIUkVTSE9MRCxcbiAgICAgIGV2YWx1YXRpb25QZXJpb2RzOiAzLFxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/lib/watchful/datadog-log-alarm.d.ts

@@ -0,0 +1,37 @@
+import { Duration } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export interface DataDogLogQueryAlarmProps extends DataDogProps, LogAlarmProps {
+}
+export declare enum UnitOfPeriod {
+    SECONDS = "s",
+    MINUTES = "m",
+    HOURS = "h",
+    DAYS = "d"
+}
+export declare enum ComparisonOperator {
+    GREATER_THAN_OR_EQUAL_TO_THRESHOLD = ">=",
+    GREATER_THAN_THRESHOLD = ">",
+    LESS_THAN_OR_EQUAL_TO_THRESHOLD = "<=",
+    LESS_THAN_THRESHOLD = "<"
+}
+export interface DataDogProps {
+    readonly serviceToken: string;
+    readonly serviceName: string;
+}
+export interface LogAlarmProps {
+    readonly autoCloseOpsGenieAlerts: boolean;
+    readonly period: Duration;
+    readonly unitOfPeriod?: UnitOfPeriod;
+    readonly periodOperator: ComparisonOperator;
+    readonly statistic: 'count';
+    readonly queryFilters: 'error' | 'warn';
+    readonly alarmDescription: string;
+    readonly threshold: number;
+    readonly priority: number;
+    readonly index: string;
+}
+export declare class DataDogLogAlarm extends Construct {
+    constructor(scope: Construct, id: string, props: DataDogLogQueryAlarmProps);
+    private alarmToDataDogQuery;
+    private convertToDatadogPeriod;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDogLogAlarm = exports.ComparisonOperator = exports.UnitOfPeriod = 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");
+var UnitOfPeriod;
+(function (UnitOfPeriod) {
+    UnitOfPeriod["SECONDS"] = "s";
+    UnitOfPeriod["MINUTES"] = "m";
+    UnitOfPeriod["HOURS"] = "h";
+    UnitOfPeriod["DAYS"] = "d";
+})(UnitOfPeriod = exports.UnitOfPeriod || (exports.UnitOfPeriod = {}));
+const DEFAULT_UNIT_OF_PERIOD = UnitOfPeriod.SECONDS;
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["GREATER_THAN_OR_EQUAL_TO_THRESHOLD"] = ">=";
+    ComparisonOperator["GREATER_THAN_THRESHOLD"] = ">";
+    ComparisonOperator["LESS_THAN_OR_EQUAL_TO_THRESHOLD"] = "<=";
+    ComparisonOperator["LESS_THAN_THRESHOLD"] = "<";
+})(ComparisonOperator = exports.ComparisonOperator || (exports.ComparisonOperator = {}));
+class DataDogLogAlarm extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        var _b;
+        super(scope, id);
+        new aws_cdk_lib_1.CustomResource(this, 'DDMonitor', {
+            serviceToken: props.serviceToken,
+            pascalCaseProperties: true,
+            resourceType: 'Custom::DataDogMonitor',
+            properties: {
+                alertTypes: ['opsgenie'],
+                autoCloseOpsGenieAlerts: props.autoCloseOpsGenieAlerts,
+                ServiceName: props.serviceName,
+                version: '1.0.0',
+                monitor: {
+                    type: 'log alert',
+                    priority: props.priority,
+                    query: this.alarmToDataDogQuery(props),
+                    name: `${(_b = this.node.scope) === null || _b === void 0 ? void 0 : _b.node.id} ${id}`,
+                    message: `${props.alarmDescription}: {{log.link}}`,
+                    options: {
+                        notify_audit: false,
+                        locked: false,
+                        silenced: {},
+                        include_tags: true,
+                        require_full_window: false,
+                        notify_no_data: false,
+                        escalation_message: '',
+                        enable_logs_sample: true,
+                        renotify_interval: 10,
+                        renotify_statuses: ['alert'],
+                    },
+                },
+            },
+        });
+    }
+    alarmToDataDogQuery(alarm) {
+        const [periodValue, periodUnit] = this.convertToDatadogPeriod(alarm.period, alarm.unitOfPeriod);
+        let comparisonOperator = alarm.periodOperator;
+        const filters = new Map([
+            ['service', alarm.serviceName],
+            ['account_id', aws_cdk_lib_1.Stack.of(this).account],
+            ['status', alarm.queryFilters],
+        ]);
+        const concatenatedFilters = Array.from(filters.entries())
+            .map(([filterKey, filterValue]) => `${filterKey}:${filterValue}`)
+            .join(' ');
+        return `logs("${concatenatedFilters}").index("${alarm.index}").rollup("${alarm.statistic}").last("${periodValue}${periodUnit}") ${comparisonOperator} ${alarm.threshold}`;
+    }
+    convertToDatadogPeriod(period, unitOfPeriod) {
+        const unit = unitOfPeriod !== null && unitOfPeriod !== void 0 ? unitOfPeriod : DEFAULT_UNIT_OF_PERIOD;
+        const mapPeriodToDatadogTime = {
+            [UnitOfPeriod.SECONDS]: () => period.toSeconds(),
+            [UnitOfPeriod.MINUTES]: () => period.toMinutes(),
+            [UnitOfPeriod.HOURS]: () => period.toHours(),
+            [UnitOfPeriod.DAYS]: () => period.toDays(),
+        };
+        return [
+            mapPeriodToDatadogTime[unit](),
+            unit.toString(),
+        ];
+    }
+}
+exports.DataDogLogAlarm = DataDogLogAlarm;
+_a = JSII_RTTI_SYMBOL_1;
+DataDogLogAlarm[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.DataDogLogAlarm", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-log-alarm.js","sourceRoot":"","sources":["../../src/watchful/datadog-log-alarm.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Stack, CustomResource } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\n\nexport interface DataDogLogQueryAlarmProps extends DataDogProps, LogAlarmProps {\n}\n\nexport enum UnitOfPeriod {\n  SECONDS = 's',\n  MINUTES = 'm',\n  HOURS = 'h',\n  DAYS = 'd',\n}\n\nconst DEFAULT_UNIT_OF_PERIOD = UnitOfPeriod.SECONDS;\n\nexport enum ComparisonOperator {\n  GREATER_THAN_OR_EQUAL_TO_THRESHOLD = '>=',\n  GREATER_THAN_THRESHOLD = '>',\n  LESS_THAN_OR_EQUAL_TO_THRESHOLD = '<=',\n  LESS_THAN_THRESHOLD = '<',\n}\n\nexport interface DataDogProps {\n  readonly serviceToken: string; // points to DD monitor custom resource lambda or sns topic\n  readonly serviceName: string; // needs to match the service name used in datadog-integration\n}\n\nexport interface LogAlarmProps {\n  readonly autoCloseOpsGenieAlerts: boolean;\n  readonly period: Duration;\n  readonly unitOfPeriod?: UnitOfPeriod; // unit which will be used to create the alert. if none is provided the periods unit will default to seconds\n  readonly periodOperator: ComparisonOperator;\n  readonly statistic: 'count'; // aggregation function\n  readonly queryFilters: 'error'|'warn'; // it should either say error or warn\n  readonly alarmDescription: string;\n  readonly threshold: number;\n  readonly priority: number;\n  readonly index: string;\n}\n\nexport class DataDogLogAlarm extends Construct {\n  constructor(scope: Construct, id: string, props: DataDogLogQueryAlarmProps) {\n    super(scope, id);\n\n    new CustomResource(this, 'DDMonitor', {\n      serviceToken: props.serviceToken,\n      pascalCaseProperties: true,\n      resourceType: 'Custom::DataDogMonitor',\n      properties: {\n        alertTypes: ['opsgenie'], // alert Type is needed to integrate with OpsGenie and to set the autoCloseOpsGenieAlerts option\n        autoCloseOpsGenieAlerts: props.autoCloseOpsGenieAlerts,\n        ServiceName: props.serviceName,\n        version: '1.0.0',\n        monitor: {\n          type: 'log alert',\n          priority: props.priority,\n          query: this.alarmToDataDogQuery(props),\n          name: `${this.node.scope?.node.id} ${id}`, // datadog-integration custom resource prepend it with Team and ServiceName\n          message: `${props.alarmDescription}: {{log.link}}`,\n          options: {\n            notify_audit: false,\n            locked: false,\n            silenced: {},\n            include_tags: true,\n            require_full_window: false,\n            notify_no_data: false,\n            escalation_message: '',\n            enable_logs_sample: true,\n            renotify_interval: 10,\n            renotify_statuses: ['alert'],\n          },\n        },\n      },\n    });\n  }\n\n  private alarmToDataDogQuery(alarm: DataDogLogQueryAlarmProps): string {\n\n    const [periodValue, periodUnit] = this.convertToDatadogPeriod(alarm.period, alarm.unitOfPeriod);\n\n    let comparisonOperator = alarm.periodOperator;\n\n    const filters = new Map([\n      ['service', alarm.serviceName],\n      ['account_id', Stack.of(this).account],\n      ['status', alarm.queryFilters],\n    ]);\n\n    const concatenatedFilters = Array.from(filters.entries())\n      .map(([filterKey, filterValue]) => `${filterKey}:${filterValue}`)\n      .join(' ');\n\n    return `logs(\"${concatenatedFilters}\").index(\"${alarm.index}\").rollup(\"${alarm.statistic}\").last(\"${periodValue}${periodUnit}\") ${comparisonOperator} ${alarm.threshold}`;\n  }\n\n  private convertToDatadogPeriod(period: Duration, unitOfPeriod?: UnitOfPeriod): [number, string] {\n    const unit = unitOfPeriod ?? DEFAULT_UNIT_OF_PERIOD;\n    const mapPeriodToDatadogTime = {\n      [UnitOfPeriod.SECONDS]: () => period.toSeconds(),\n      [UnitOfPeriod.MINUTES]: () => period.toMinutes(),\n      [UnitOfPeriod.HOURS]: () => period.toHours(),\n      [UnitOfPeriod.DAYS]: () => period.toDays(),\n    };\n    return [\n      mapPeriodToDatadogTime[unit](),\n      unit.toString(),\n    ];\n  }\n}"]}

package/lib/watchful/datadog-metric-alarm.d.ts

@@ -0,0 +1,32 @@
+import { Construct } from 'constructs';
+import { MetricAlarmProps } from './metric-alarm';
+/**
+ * Interface for DataDogMonitor implementation.
+ */
+export interface DataDogMetricAlarmProps extends MetricAlarmProps {
+    /**
+       * Service token which points to the DataDog Monitor custom resource lambda or sns topic.
+       */
+    readonly serviceToken: string;
+    /**
+     * The service name used to name the montors (in datadog-integration).
+     */
+    readonly serviceName: string;
+    /**
+     * The name of DataDog's OpsGenie integration. Used to automatically create OpsGenie alarms for the created DataDog Monitor.
+     */
+    readonly dataDogOpsGenieIntegrationName: string;
+}
+/**
+ * A wrapper for a custom resource that creates a DataDog Monitor.
+ *
+ * To use this construct, the DataDog integration needs to be installed.
+ */
+export declare class DataDogMetricAlarm extends Construct {
+    private serviceToken;
+    constructor(scope: Construct, id: string, props: DataDogMetricAlarmProps);
+    /**
+       * Helper function to convert a generic alarm into a DataDog query string.
+       */
+    alarmToDataDogQuery(alarm: MetricAlarmProps): string;
+}