@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/cloudwatch/main.js

@@ -0,0 +1,552 @@
+import * as cdk from 'aws-cdk-lib';
+import * as watch from 'aws-cdk-lib/aws-cloudwatch';
+import _ from 'lodash';
+import * as utils from '../../utils/index.js';
+/**
+ */
+var CloudWatchWidgetType;
+(function (CloudWatchWidgetType) {
+    CloudWatchWidgetType["Text"] = "Text";
+    CloudWatchWidgetType["SingleValue"] = "SingleValue";
+    CloudWatchWidgetType["Gauge"] = "Gauge";
+    CloudWatchWidgetType["Graph"] = "Graph";
+    CloudWatchWidgetType["AlarmStatus"] = "AlarmStatus";
+    CloudWatchWidgetType["LogQuery"] = "LogQuery";
+})(CloudWatchWidgetType || (CloudWatchWidgetType = {}));
+/**
+ * @classdesc Provides operations on AWS CloudWatch.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.cloudWatchManager.createAlarmForMetric('MyAlarm', this, metric)
+ *   }
+ * }
+ * @see [CDK CloudWatch Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch-readme.html}
+ */
+export class CloudWatchManager {
+    /**
+     * @summary Method to create a cloudwatch alarm for a given expression
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createAlarmForExpression(id, scope, props) {
+        if (!props)
+            throw `Alarm props undefined for ${id}`;
+        if (!props.expression)
+            throw `Could not find expression for Alarm props for id:${id}`;
+        if (!props.metricProps)
+            throw `Could not find metricProps for Alarm props for id:${id}`;
+        const metrics = {};
+        _.map(this.determineMetrics(scope, props.metricProps), (metric, index) => {
+            metrics[`m${index}`] = metric;
+        });
+        const expression = new watch.MathExpression({
+            ...props,
+            expression: props.expression,
+            period: props.periodInSecs ? cdk.Duration.seconds(props.periodInSecs) : cdk.Duration.minutes(5),
+            usingMetrics: metrics,
+        });
+        const alarm = expression.createAlarm(scope, `${id}`, {
+            ...props,
+        });
+        utils.createCfnOutput(`${id}-alarmArn`, scope, alarm.alarmArn);
+        utils.createCfnOutput(`${id}-alarmName`, scope, alarm.alarmName);
+        return alarm;
+    }
+    /**
+     * @summary Method to create a cloudwatch alarm for a given metric
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param metric
+     */
+    createAlarmForMetric(id, scope, props, metric) {
+        if (!props)
+            throw `Alarm props undefined for ${id}`;
+        const alarm = metric.createAlarm(scope, `${id}`, {
+            ...props,
+        });
+        utils.createCfnOutput(`${id}-alarmArn`, scope, alarm.alarmArn);
+        utils.createCfnOutput(`${id}-alarmName`, scope, alarm.alarmName);
+        return alarm;
+    }
+    /**
+     * @summary Method to create a cloudwatch dashboard
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param widgets
+     */
+    createDashboard(id, scope, props, widgets) {
+        if (!props)
+            throw `Dashboard props undefined for ${id}`;
+        if (!props.dashboardName)
+            throw `Dashboard dashboardName undefined for ${id}`;
+        const dashboard = new watch.Dashboard(scope, `${id}`, {
+            ...props,
+            dashboardName: scope.resourceNameFormatter.format(props.dashboardName, scope.props.resourceNameOptions?.cloudwatch),
+            end: CloudWatchManager.determineTimeRange(props.end),
+            start: CloudWatchManager.determineTimeRange(props.start),
+            widgets,
+        });
+        utils.createCfnOutput(`${id}-dashboardName`, scope, props.dashboardName);
+        return dashboard;
+    }
+    /**
+     * @summary Method to create cloudwatch widgets
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createWidgets(scope, props) {
+        if (!props || props.length == 0)
+            throw `Widget props undefined`;
+        const widgets = [];
+        _.forEach(props, (widgetProps) => {
+            widgets.push(this.createWidget(widgetProps.id, scope, widgetProps));
+        });
+        return widgets;
+    }
+    /**
+     * @summary Method to create a cloudwatch widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createWidget(id, scope, props) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metrics = this.determineMetrics(scope, props.metricProps);
+        let alarms, logGroupNames = [];
+        switch (props.type) {
+            case CloudWatchWidgetType.Text:
+                return this.createTextWidget(id, scope, props);
+            case CloudWatchWidgetType.SingleValue:
+                return this.createSingleValueWidget(id, scope, props, metrics);
+            case CloudWatchWidgetType.Gauge:
+                return this.createGuageWidget(id, scope, props, metrics);
+            case CloudWatchWidgetType.Graph:
+                return this.createGraphWidget(id, scope, props, metrics);
+            case CloudWatchWidgetType.AlarmStatus:
+                alarms = this.determineAlarms(id, scope, props.alarmProps);
+                return this.createAlarmStatusWidget(id, scope, props, alarms);
+            case CloudWatchWidgetType.LogQuery:
+                logGroupNames = props.logGroupNames.map((name) => `${name}-${scope.props.stage}`);
+                return this.createLogQueryWidget(id, scope, props, logGroupNames);
+            default:
+                throw `Unsupported widget type ${props.type}`;
+        }
+    }
+    /**
+     * @summary Method to create a cloudfront distribution widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param distributionId the cloudfront distribution id
+     */
+    createCloudfrontDistributionWidget(id, scope, props, distributionId) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, distributionId })),
+        });
+    }
+    /**
+     * @summary Method to create a step function widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param stateMachineArn the step function arn
+     */
+    createStateWidget(id, scope, props, stateMachineArn) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, stateMachineArn })),
+        });
+    }
+    /**
+     * @summary Method to create an event widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param eventBusName the event bus name
+     * @param ruleName the event rule name
+     */
+    createEventWidget(id, scope, props, eventBusName, ruleName) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, eventBusName, ruleName })),
+        });
+    }
+    /**
+     * @summary Method to create an api gateway widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param apiName the api name
+     */
+    createApiGatewayWidget(id, scope, props, apiName) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, apiName })),
+        });
+    }
+    /**
+     * @summary Method to create a lambda function widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param functionName the lambda function name
+     */
+    createLambdaWidget(id, scope, props, functionName) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, functionName })),
+        });
+    }
+    /**
+     * @summary Method to create a custom widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param service the service identifier
+     */
+    createCustomWidget(id, scope, props, service) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, service })),
+        });
+    }
+    /**
+     * @summary Method to create an ecs cluster widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param clusterName the ecs cluster name
+     */
+    createEcsClusterWidget(id, scope, props, clusterName) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, clusterName })),
+        });
+    }
+    /**
+     * @summary Method to create an ecs service widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param clusterName the ecs cluster name
+     * @param serviceName the ecs service name
+     */
+    createEcsServiceWidget(id, scope, props, clusterName, serviceName) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, clusterName, serviceName })),
+        });
+    }
+    /**
+     * @summary Method to create an elb widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param loadBalancer the loadbalancer reference
+     */
+    createElbWidget(id, scope, props, loadBalancer) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, loadBalancer })),
+        });
+    }
+    /**
+     * @summary Method to create an elasticache widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cacheClusterId the elasticache cluster id
+     */
+    createCacheWidget(id, scope, props, cacheClusterId) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const metricProps = props.metricProps;
+        return this.createWidget(id, scope, {
+            ...props,
+            metricProps: metricProps.map(metricProp => ({ ...metricProp, cacheClusterId })),
+        });
+    }
+    /**
+     * @summary Method to create a cloudwatch text widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createTextWidget(id, scope, props) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.TextWidget({
+            ...props,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Method to create a cloudwatch numeric widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param metrics
+     */
+    createSingleValueWidget(id, scope, props, metrics) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.SingleValueWidget({
+            ...props,
+            metrics,
+            region: props.region ?? scope.props.region,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Method to create a cloudwatch guage widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param metrics
+     */
+    createGuageWidget(id, scope, props, metrics) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.GaugeWidget({
+            ...props,
+            metrics,
+            region: props.region ?? scope.props.region,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Method to create a cloudwatch graph widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param leftYMetrics
+     * @param rightYMetrics
+     */
+    createGraphWidget(id, scope, props, leftYMetrics, rightYMetrics) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.GraphWidget({
+            ...props,
+            left: leftYMetrics,
+            region: props.region ?? scope.props.region,
+            right: rightYMetrics,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Method to create a cloudwatch alarm status widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param alarms
+     */
+    createAlarmStatusWidget(id, scope, props, alarms) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.AlarmStatusWidget({
+            ...props,
+            alarms,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Method to create a cloudwatch log query widget
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param logGroupNames
+     */
+    createLogQueryWidget(id, scope, props, logGroupNames) {
+        if (!props)
+            throw `Widget props undefined for ${id}`;
+        const widget = new watch.LogQueryWidget({
+            ...props,
+            logGroupNames,
+            region: props.region ?? scope.props.region,
+        });
+        if (props.positionX && props.positionY)
+            widget.position(props.positionX, props.positionY);
+        return widget;
+    }
+    /**
+     * @summary Utility method to determine the metrics and dimensions
+     * @param scope scope in which this resource is defined
+     * @param metricProps
+     */
+    determineMetrics(scope, metricProps) {
+        const metrics = [];
+        if (metricProps) {
+            metricProps.forEach((metricProp) => {
+                let metricDimensions = metricProp.dimensionsMap || {};
+                if (metricProp.functionName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        FunctionName: `${metricProp.functionName}`,
+                    };
+                }
+                if (metricProp.serviceName && metricProp.clusterName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        ClusterName: `${metricProp.clusterName}`,
+                        ServiceName: `${metricProp.serviceName}`,
+                    };
+                }
+                if (!metricProp.serviceName && metricProp.clusterName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        ClusterName: `${metricProp.clusterName}`,
+                    };
+                }
+                if (metricProp.serviceName && !metricProp.clusterName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        ServiceName: `${metricProp.serviceName}`,
+                    };
+                }
+                if (metricProp.loadBalancer) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        LoadBalancer: `${metricProp.loadBalancer}`,
+                    };
+                }
+                if (metricProp.service) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        service: `${metricProp.service}`,
+                    };
+                }
+                if (metricProp.distributionId) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        DistributionId: `${metricProp.distributionId}`,
+                        Region: `Global`,
+                    };
+                }
+                if (metricProp.apiName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        ApiName: `${metricProp.apiName}`,
+                    };
+                }
+                if (metricProp.cacheClusterId) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        CacheClusterId: `${metricProp.cacheClusterId}`,
+                    };
+                }
+                if (metricProp.dbClusterIdentifier) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        DBClusterIdentifier: `${metricProp.dbClusterIdentifier}`,
+                    };
+                }
+                if (metricProp.stateMachineArn) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        StateMachineArn: `${metricProp.stateMachineArn}`,
+                    };
+                }
+                if (metricProp.eventBusName && metricProp.ruleName) {
+                    metricDimensions = {
+                        ...metricProp.dimensionsMap,
+                        EventBusName: `${metricProp.eventBusName}`,
+                        RuleName: `${metricProp.ruleName}`,
+                    };
+                }
+                const metric = new watch.Metric({
+                    dimensionsMap: metricDimensions,
+                    metricName: metricProp.stageSuffix ? `${metricProp.metricName}-${scope.props.stage}` : metricProp.metricName,
+                    namespace: metricProp.stageSuffix ? `${metricProp.namespace}-${scope.props.stage}` : metricProp.namespace,
+                    period: metricProp.periodInSecs ? cdk.Duration.seconds(metricProp.periodInSecs) : cdk.Duration.minutes(5),
+                    region: metricProp.region,
+                    statistic: metricProp.statistic,
+                });
+                metrics.push(metric);
+            });
+        }
+        return metrics;
+    }
+    /**
+     * @summary Utility method to determine the time range
+     * @param range
+     */
+    static determineTimeRange(range) {
+        const moment = require('moment');
+        switch (range) {
+            case 'START_TODAY':
+                return moment().startOf('day').format();
+            case 'END_TODAY':
+                return moment().endOf('day').format();
+            default:
+                return range;
+        }
+    }
+    /**
+     * @summary Utility method to determine the configured alarms
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param alarmProps
+     */
+    determineAlarms(id, scope, alarmProps) {
+        const alarms = [];
+        if (alarmProps) {
+            _.forEach(alarmProps, (alarmProp) => {
+                if (!alarmProp.alarmName)
+                    throw `Alarm name undefined for ${id}`;
+                const alarmArn = `arn:aws:cloudwatch:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:alarm:${alarmProp.alarmName}`;
+                const alarm = watch.Alarm.fromAlarmArn(scope, `${alarmProp.alarmName}`, alarmArn);
+                alarms.push(alarm);
+            });
+        }
+        return alarms;
+    }
+}

package/dist/src/services/cloudwatch/types.d.ts

@@ -0,0 +1,89 @@
+import * as watch from 'aws-cdk-lib/aws-cloudwatch';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import { TagProps } from '../../types/index.js';
+/**
+ */
+export interface AlarmProps extends watch.AlarmProps {
+    expression?: string;
+    metricProps?: MetricProps[];
+    periodInSecs?: number;
+}
+/**
+ */
+export interface DashboardProps extends watch.DashboardProps {
+}
+/**
+ */
+export interface MetricProps extends watch.MetricProps {
+    apiName?: string;
+    cacheClusterId?: string;
+    clusterName?: string;
+    dbClusterIdentifier?: string;
+    distributionId?: string;
+    eventBusName?: string;
+    functionName?: string;
+    loadBalancer?: string;
+    periodInSecs?: number;
+    ruleName?: string;
+    service?: string;
+    serviceName?: string;
+    stageSuffix: boolean;
+    stateMachineArn?: string;
+}
+/**
+ */
+export interface TextWidgetProps extends watch.TextWidgetProps {
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface NumericWidgetProps extends watch.SingleValueWidgetProps {
+    metricProps: watch.MetricProps[];
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface GuageWidgetProps extends watch.GaugeWidgetProps {
+    metricProps: watch.MetricProps[];
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface GraphWidgetProps extends watch.GraphWidgetProps {
+    metricProps: MetricProps[];
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface AlarmStatusWidgetProps extends watch.AlarmStatusWidgetProps {
+    alarmProps: watch.AlarmProps[];
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface LogQueryWidgetProps extends watch.LogQueryWidgetProps {
+    positionX: number;
+    positionY: number;
+    type: string;
+}
+/**
+ */
+export interface MetricFilterProps extends logs.MetricFilterProps {
+    options: watch.MetricOptions;
+    periodInSecs: number;
+}
+/**
+ */
+export interface LogProps extends logs.LogGroupProps {
+    tags?: TagProps[];
+}

package/dist/src/services/cloudwatch/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/codebuild/index.d.ts

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

package/dist/src/services/codebuild/index.js

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

package/dist/src/services/codebuild/main.d.ts

@@ -0,0 +1,36 @@
+import { Project } from 'aws-cdk-lib/aws-codebuild';
+import { CommonConstruct } from '../../common/index.js';
+/**
+ * @classdesc Provides operations on AWS Code Build.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.codeBuildManager.createImageForCloudfrontInvalidation('MyInvalidation', this, './docker ')
+ *   }
+ * }
+ * @see [CDK Codebuild Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild-readme.html}
+ */
+export declare class CodeBuildManager {
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerfilePath
+     */
+    createImageForCloudfrontInvalidation(id: string, scope: CommonConstruct, dockerfilePath: string): import("aws-cdk-lib/aws-ecr-assets").DockerImageAsset;
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerFilepath
+     * @param distributionId
+     * @param paths
+     */
+    createProjectForCloudfrontInvalidation(id: string, scope: CommonConstruct, dockerFilepath: string, distributionId: string, paths?: string): Project;
+}