@digitraffic/common 2022.10.5

package/aws/infra/sqs-integration.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachQueueToApiGatewayResource = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+function attachQueueToApiGatewayResource(stack, queue, resource, requestValidator, resourceName, apiKeyRequired, requestModels) {
+    // role for API Gateway
+    const apiGwRole = new aws_iam_1.Role(stack, `${resourceName}APIGatewayToSQSRole`, {
+        assumedBy: new aws_iam_1.ServicePrincipal('apigateway.amazonaws.com'),
+    });
+    // grants API Gateway the right to send SQS messages
+    apiGwRole.addToPolicy(new aws_iam_1.PolicyStatement({
+        resources: [
+            queue.queueArn,
+        ],
+        actions: [
+            'sqs:SendMessage',
+        ],
+    }));
+    // grants API Gateway the right write CloudWatch Logs
+    apiGwRole.addToPolicy(new aws_iam_1.PolicyStatement({
+        resources: [
+            '*',
+        ],
+        actions: [
+            'logs:CreateLogGroup',
+            'logs:CreateLogStream',
+            'logs:DescribeLogGroups',
+            'logs:DescribeLogStreams',
+            'logs:PutLogEvents',
+            'logs:GetLogEvents',
+            'logs:FilterLogEvents',
+        ],
+    }));
+    // create an integration between API Gateway and an SQS queue
+    const fifoMessageGroupId = queue.fifo ? '&MessageGroupId=AlwaysSameFifoGroup' : '';
+    const sqsIntegration = new aws_apigateway_1.AwsIntegration({
+        service: 'sqs',
+        integrationHttpMethod: 'POST',
+        options: {
+            passthroughBehavior: aws_apigateway_1.PassthroughBehavior.NEVER,
+            credentialsRole: apiGwRole,
+            requestParameters: {
+                // SQS requires the Content-Type of the HTTP request to be application/x-www-form-urlencoded
+                'integration.request.header.Content-Type': "'application/x-www-form-urlencoded'",
+            },
+            requestTemplates: {
+                // map the JSON request to a form parameter, FIFO needs also MessageGroupId
+                // https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html
+                'application/json': `Action=SendMessage${fifoMessageGroupId}&MessageBody=$util.urlEncode($input.body)`,
+            },
+            // these are required by SQS
+            integrationResponses: [
+                {
+                    statusCode: '200',
+                    responseTemplates: {
+                        'text/html': 'Success',
+                    },
+                },
+                {
+                    statusCode: '500',
+                    responseTemplates: {
+                        'text/html': 'Error',
+                    },
+                    selectionPattern: '500',
+                },
+            ],
+        },
+        path: `${aws_cdk_lib_1.Aws.ACCOUNT_ID}/${queue.queueName}`,
+    });
+    resource.addMethod('POST', sqsIntegration, {
+        requestValidator,
+        apiKeyRequired,
+        requestModels: requestModels ?? {},
+        methodResponses: [
+            {
+                statusCode: '200',
+                responseParameters: {
+                    'method.response.header.Content-Type': true,
+                },
+            },
+            {
+                statusCode: '500',
+                responseParameters: {
+                    'method.response.header.Content-Type': true,
+                },
+            },
+        ],
+    });
+}
+exports.attachQueueToApiGatewayResource = attachQueueToApiGatewayResource;
+//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/sqs-queue.d.ts

@@ -0,0 +1,16 @@
+import { Queue, QueueProps } from "aws-cdk-lib/aws-sqs";
+import { Construct } from "constructs";
+import { DigitrafficStack } from "./stack/stack";
+/**
+ * Construct for creating SQS-queues.
+ *
+ * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket
+ * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.
+ */
+export declare class DigitrafficSqsQueue extends Queue {
+    constructor(scope: Construct, name: string, props: QueueProps);
+    static create(stack: DigitrafficStack, name: string, props: QueueProps): DigitrafficSqsQueue;
+}
+export declare class DigitrafficDLQueue {
+    static create(stack: DigitrafficStack, name: string): DigitrafficSqsQueue;
+}

package/aws/infra/sqs-queue.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitrafficDLQueue = exports.DigitrafficSqsQueue = void 0;
+const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_lambda_event_sources_1 = require("aws-cdk-lib/aws-lambda-event-sources");
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
+const monitoredfunction_1 = require("./stack/monitoredfunction");
+/**
+ * Construct for creating SQS-queues.
+ *
+ * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket
+ * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.
+ */
+class DigitrafficSqsQueue extends aws_sqs_1.Queue {
+    constructor(scope, name, props) {
+        super(scope, name, props);
+    }
+    static create(stack, name, props) {
+        const queueName = `${stack.configuration.shortName}-${name}-Queue`;
+        const queueProps = { ...props, ...{
+                encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+                queueName,
+                deadLetterQueue: props.deadLetterQueue || {
+                    maxReceiveCount: 2,
+                    queue: DigitrafficDLQueue.create(stack, name),
+                },
+            } };
+        return new DigitrafficSqsQueue(stack, queueName, queueProps);
+    }
+}
+exports.DigitrafficSqsQueue = DigitrafficSqsQueue;
+class DigitrafficDLQueue {
+    static create(stack, name) {
+        const dlqName = `${stack.configuration.shortName}-${name}-DLQ`;
+        const dlq = new DigitrafficSqsQueue(stack, dlqName, {
+            queueName: dlqName,
+            visibilityTimeout: aws_cdk_lib_1.Duration.seconds(60),
+            encryption: aws_sqs_1.QueueEncryption.KMS_MANAGED,
+        });
+        const dlqBucket = new aws_s3_1.Bucket(stack, `${dlqName}-Bucket`, {
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+        });
+        const dlqFunctionName = `${dlqName}-Function`;
+        const lambda = monitoredfunction_1.MonitoredFunction.create(stack, dlqFunctionName, {
+            runtime: aws_lambda_1.Runtime.NODEJS_14_X,
+            logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+            functionName: dlqFunctionName,
+            code: getDlqCode(dlqBucket.bucketName),
+            timeout: aws_cdk_lib_1.Duration.seconds(10),
+            handler: 'index.handler',
+            memorySize: 128,
+            reservedConcurrentExecutions: 1,
+        });
+        const statement = new aws_iam_1.PolicyStatement();
+        statement.addActions('s3:PutObject');
+        statement.addActions('s3:PutObjectAcl');
+        statement.addResources(dlqBucket.bucketArn + '/*');
+        lambda.addToRolePolicy(statement);
+        lambda.addEventSource(new aws_lambda_event_sources_1.SqsEventSource(dlq));
+        addDLQAlarm(stack, dlqName, dlq);
+        return dlq;
+    }
+}
+exports.DigitrafficDLQueue = DigitrafficDLQueue;
+function addDLQAlarm(stack, dlqName, dlq) {
+    const alarmName = `${dlqName}-Alarm`;
+    dlq.metricNumberOfMessagesReceived({
+        period: aws_cdk_lib_1.Duration.minutes(5),
+    }).createAlarm(stack, alarmName, {
+        alarmName,
+        threshold: 0,
+        evaluationPeriods: 1,
+        treatMissingData: aws_cloudwatch_1.TreatMissingData.NOT_BREACHING,
+        comparisonOperator: aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD,
+    }).addAlarmAction(new aws_cloudwatch_actions_1.SnsAction(stack.warningTopic));
+}
+function getDlqCode(bName) {
+    const functionBody = DLQ_LAMBDA_CODE
+        .replace("__bucketName__", bName)
+        .replace("__upload__", uploadToS3.toString())
+        .replace("__doUpload__", doUpload.toString())
+        .replace("__handler__", createHandler().toString().substring(23)); // remove function handler() from signature
+    return new aws_lambda_1.InlineCode(functionBody);
+}
+async function uploadToS3(s3, bName, body, objectName) {
+    try {
+        console.info('writing %s to %s', objectName, bName);
+        await doUpload(s3, bName, body, objectName);
+    }
+    catch (error) {
+        console.warn(error);
+        console.warn('method=uploadToS3 retrying upload to bucket %s', bName);
+        try {
+            await doUpload(s3, bName, body, objectName);
+        }
+        catch (e2) {
+            console.error('method=uploadToS3 failed retrying upload to bucket %s', bName);
+        }
+    }
+}
+function doUpload(s3, bName, Body, Key) {
+    return s3.upload({
+        Bucket: bName, Body, Key,
+    }).promise();
+}
+// bucketName is unused, will be overridden in the actual lambda code below
+const bucketName = '';
+function createHandler() {
+    return async function handler(event) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const AWS = require('aws-sdk');
+        const millis = new Date().getTime();
+        await Promise.all(event.Records.map((e, idx) => uploadToS3(new AWS.S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));
+    };
+}
+const DLQ_LAMBDA_CODE = `const AWS = require('aws-sdk');
+const bucketName = "__bucketName__";
+
+__upload__
+__doUpload__
+
+exports.handler = async (event) => __handler__
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqs-queue.js","sourceRoot":"","sources":["../../../src/aws/infra/sqs-queue.ts"],"names":[],"mappings":"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","sourcesContent":["import {Queue, QueueEncryption, QueueProps} from \"aws-cdk-lib/aws-sqs\";\nimport {Duration} from \"aws-cdk-lib\";\nimport {BlockPublicAccess, Bucket} from \"aws-cdk-lib/aws-s3\";\nimport {PolicyStatement} from \"aws-cdk-lib/aws-iam\";\nimport {InlineCode, Runtime} from \"aws-cdk-lib/aws-lambda\";\nimport {RetentionDays} from \"aws-cdk-lib/aws-logs\";\nimport {SqsEventSource} from \"aws-cdk-lib/aws-lambda-event-sources\";\nimport {ComparisonOperator, TreatMissingData} from \"aws-cdk-lib/aws-cloudwatch\";\nimport {SnsAction} from \"aws-cdk-lib/aws-cloudwatch-actions\";\nimport {ManagedUpload} from \"aws-sdk/clients/s3\";\nimport {S3} from \"aws-sdk\";\nimport {SQSEvent, SQSHandler, SQSRecord} from \"aws-lambda\";\nimport {Construct} from \"constructs\";\nimport {DigitrafficStack} from \"./stack/stack\";\nimport {MonitoredFunction} from \"./stack/monitoredfunction\";\n\n/**\n * Construct for creating SQS-queues.\n *\n * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket\n * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.\n */\nexport class DigitrafficSqsQueue extends Queue {\n    constructor(scope: Construct, name: string, props: QueueProps) {\n        super(scope, name, props);\n    }\n\n    static create(stack: DigitrafficStack, name: string, props: QueueProps): DigitrafficSqsQueue {\n        const queueName = `${stack.configuration.shortName}-${name}-Queue`;\n        const queueProps = {...props, ...{\n            encryption: QueueEncryption.KMS_MANAGED,\n            queueName,\n            deadLetterQueue: props.deadLetterQueue || {\n                maxReceiveCount: 2,\n                queue: DigitrafficDLQueue.create(stack, name),\n            },\n        }};\n\n        return new DigitrafficSqsQueue(stack, queueName, queueProps);\n    }\n}\n\nexport class DigitrafficDLQueue {\n    static create(stack: DigitrafficStack, name: string): DigitrafficSqsQueue {\n        const dlqName = `${stack.configuration.shortName}-${name}-DLQ`;\n\n        const dlq = new DigitrafficSqsQueue(stack, dlqName, {\n            queueName: dlqName,\n            visibilityTimeout: Duration.seconds(60),\n            encryption: QueueEncryption.KMS_MANAGED,\n        });\n\n        const dlqBucket = new Bucket(stack, `${dlqName}-Bucket`, {\n            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n        });\n\n        const dlqFunctionName = `${dlqName}-Function`;\n        const lambda = MonitoredFunction.create(stack, dlqFunctionName, {\n            runtime: Runtime.NODEJS_14_X,\n            logRetention: RetentionDays.ONE_YEAR,\n            functionName: dlqFunctionName,\n            code: getDlqCode(dlqBucket.bucketName),\n            timeout: Duration.seconds(10),\n            handler: 'index.handler',\n            memorySize: 128,\n            reservedConcurrentExecutions: 1,\n        });\n\n        const statement = new PolicyStatement();\n        statement.addActions('s3:PutObject');\n        statement.addActions('s3:PutObjectAcl');\n        statement.addResources(dlqBucket.bucketArn + '/*');\n\n        lambda.addToRolePolicy(statement);\n        lambda.addEventSource(new SqsEventSource(dlq));\n\n        addDLQAlarm(stack, dlqName, dlq);\n\n        return dlq;\n    }\n}\n\nfunction addDLQAlarm(stack: DigitrafficStack, dlqName: string, dlq: Queue) {\n    const alarmName = `${dlqName}-Alarm`;\n    dlq.metricNumberOfMessagesReceived({\n        period: Duration.minutes(5),\n    }).createAlarm(stack, alarmName, {\n        alarmName,\n        threshold: 0,\n        evaluationPeriods: 1,\n        treatMissingData: TreatMissingData.NOT_BREACHING,\n        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,\n    }).addAlarmAction(new SnsAction(stack.warningTopic));\n}\n\nfunction getDlqCode(bName: string): InlineCode {\n    const functionBody = DLQ_LAMBDA_CODE\n        .replace(\"__bucketName__\", bName)\n        .replace(\"__upload__\", uploadToS3.toString())\n        .replace(\"__doUpload__\", doUpload.toString())\n        .replace(\"__handler__\", createHandler().toString().substring(23)); // remove function handler() from signature\n\n    return new InlineCode(functionBody);\n}\n\nasync function uploadToS3(s3: S3, bName: string, body: string, objectName: string): Promise<void> {\n    try {\n        console.info('writing %s to %s', objectName, bName);\n        await doUpload(s3, bName, body, objectName);\n    } catch (error) {\n        console.warn(error);\n        console.warn('method=uploadToS3 retrying upload to bucket %s', bName);\n        try {\n            await doUpload(s3, bName, body, objectName);\n        } catch (e2) {\n            console.error('method=uploadToS3 failed retrying upload to bucket %s', bName);\n        }\n    }\n}\n\nfunction doUpload(s3: S3, bName: string, Body: string, Key: string): Promise<ManagedUpload.SendData> {\n    return s3.upload({\n        Bucket: bName, Body, Key,\n    }).promise();\n}\n\n// bucketName is unused, will be overridden in the actual lambda code below\nconst bucketName = '';\n\nfunction createHandler(): SQSHandler {\n    return async function handler(event: SQSEvent): Promise<void> {\n        // eslint-disable-next-line @typescript-eslint/no-var-requires\n        const AWS = require('aws-sdk');\n\n        const millis = new Date().getTime();\n        await Promise.all(event.Records.map((e: SQSRecord, idx: number) =>\n            uploadToS3(new AWS.S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));\n    };\n}\n\nconst DLQ_LAMBDA_CODE = `const AWS = require('aws-sdk');\nconst bucketName = \"__bucketName__\";\n\n__upload__\n__doUpload__\n\nexports.handler = async (event) => __handler__\n`;\n"]}

package/aws/infra/stack/lambda-configs.d.ts

@@ -0,0 +1,72 @@
+import { Architecture, Code, FunctionProps, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { ISecurityGroup, IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { DigitrafficStack } from "./stack";
+import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
+export declare type LambdaEnvironment = Record<string, string>;
+export declare type DBLambdaEnvironment = LambdaEnvironment & {
+    SECRET_ID?: string;
+    DB_APPLICATION: string;
+};
+export interface LambdaConfiguration {
+    vpcId: string;
+    allowFromIpAddresses?: string[];
+    privateSubnetIds: string[];
+    availabilityZones: string[];
+    lambdaDbSgId: string;
+    dbProps?: DbProps;
+    defaultLambdaDurationSeconds?: number;
+    logsDestinationArn: string;
+    memorySize?: number;
+    runtime?: Runtime;
+}
+declare interface DbProps {
+    username: string;
+    password: string;
+    uri?: string;
+    ro_uri?: string;
+}
+export declare function databaseFunctionProps(stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: FunctionParameters): FunctionProps;
+export declare function lambdaFunctionProps(stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: FunctionParameters): FunctionProps;
+/**
+ * Creates a base configuration for a Lambda that uses an RDS database
+ * @param vpc "Private" Lambdas are associated with a VPC
+ * @param lambdaDbSg Security Group shared by Lambda and RDS
+ * @param props Database connection properties for the Lambda
+ * @param config Lambda configuration
+ */
+export declare function dbLambdaConfiguration(vpc: IVpc, lambdaDbSg: ISecurityGroup, props: LambdaConfiguration, config: FunctionParameters): FunctionProps;
+export declare function defaultLambdaConfiguration(config: FunctionParameters): FunctionProps;
+export interface FunctionParameters {
+    memorySize?: number;
+    timeout?: number;
+    functionName?: string;
+    code?: Code;
+    handler?: string;
+    readOnly?: boolean;
+    environment?: {
+        [key: string]: string;
+    };
+    reservedConcurrentExecutions?: number;
+    role?: Role;
+    vpc?: IVpc;
+    vpcSubnets?: SubnetSelection;
+    runtime?: Runtime;
+    architecture?: Architecture;
+    singleLambda?: boolean;
+}
+export declare type MonitoredFunctionParameters = {
+    readonly memorySize?: number;
+    readonly timeout?: number;
+    readonly functionName?: string;
+    readonly reservedConcurrentExecutions?: number;
+    readonly role?: Role;
+    readonly runtime?: Runtime;
+    readonly architecture?: Architecture;
+    readonly singleLambda?: boolean;
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+};
+export {};

package/aws/infra/stack/lambda-configs.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLambdaConfiguration = exports.dbLambdaConfiguration = exports.lambdaFunctionProps = exports.databaseFunctionProps = void 0;
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+    const vpcSubnets = stack.vpc ? {
+        subnets: stack.vpc.privateSubnets,
+    } : undefined;
+    return { ...lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config), ...{
+            vpc: stack.vpc || undefined,
+            vpcSubnets,
+            securityGroup: stack.lambdaDbSg || undefined,
+        } };
+}
+exports.databaseFunctionProps = databaseFunctionProps;
+function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
+    return {
+        runtime: config?.runtime || aws_lambda_1.Runtime.NODEJS_14_X,
+        architecture: config?.architecture || aws_lambda_1.Architecture.ARM_64,
+        memorySize: config?.memorySize || 128,
+        functionName: lambdaName,
+        role: config?.role,
+        timeout: aws_cdk_lib_1.Duration.seconds(config?.timeout || 60),
+        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        reservedConcurrentExecutions: config?.reservedConcurrentExecutions || 2,
+        code: getAssetCode(simpleLambdaName, config),
+        handler: `${simpleLambdaName}.handler`,
+        environment,
+    };
+}
+exports.lambdaFunctionProps = lambdaFunctionProps;
+function getAssetCode(simpleLambdaName, config) {
+    const lambdaPath = config?.singleLambda ? `dist/lambda/` : `dist/lambda/${simpleLambdaName}`;
+    return new aws_lambda_1.AssetCode(lambdaPath);
+}
+/**
+ * Creates a base configuration for a Lambda that uses an RDS database
+ * @param vpc "Private" Lambdas are associated with a VPC
+ * @param lambdaDbSg Security Group shared by Lambda and RDS
+ * @param props Database connection properties for the Lambda
+ * @param config Lambda configuration
+ */
+function dbLambdaConfiguration(vpc, lambdaDbSg, props, config) {
+    return {
+        runtime: props.runtime || aws_lambda_1.Runtime.NODEJS_14_X,
+        memorySize: props.memorySize || config.memorySize || 1024,
+        functionName: config.functionName,
+        code: config.code,
+        role: config.role,
+        handler: config.handler,
+        timeout: aws_cdk_lib_1.Duration.seconds(config.timeout || props.defaultLambdaDurationSeconds || 60),
+        environment: config.environment || {
+            DB_USER: props.dbProps?.username,
+            DB_PASS: props.dbProps?.password,
+            DB_URI: (config.readOnly ? props.dbProps?.ro_uri : props.dbProps?.uri),
+        },
+        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        vpc: vpc,
+        vpcSubnets: {
+            subnets: vpc.privateSubnets,
+        },
+        securityGroups: [lambdaDbSg],
+        reservedConcurrentExecutions: config.reservedConcurrentExecutions || 3,
+    };
+}
+exports.dbLambdaConfiguration = dbLambdaConfiguration;
+function defaultLambdaConfiguration(config) {
+    const props = {
+        runtime: aws_lambda_1.Runtime.NODEJS_14_X,
+        memorySize: config.memorySize ?? 128,
+        functionName: config.functionName,
+        handler: config.handler,
+        environment: config.environment ?? {},
+        logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
+        reservedConcurrentExecutions: config.reservedConcurrentExecutions,
+        code: config.code,
+        role: config.role,
+        timeout: aws_cdk_lib_1.Duration.seconds(config.timeout || 10),
+    };
+    if (config.vpc) {
+        return { ...props, ...{
+                vpc: config.vpc,
+                vpcSubnets: {
+                    subnets: config.vpc?.privateSubnets,
+                },
+            } };
+    }
+    return props;
+}
+exports.defaultLambdaConfiguration = defaultLambdaConfiguration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-configs.js","sourceRoot":"","sources":["../../../../src/aws/infra/stack/lambda-configs.ts"],"names":[],"mappings":"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","sourcesContent":["import {Architecture, AssetCode, Code, FunctionProps, Runtime} from 'aws-cdk-lib/aws-lambda';\r\nimport {Duration} from \"aws-cdk-lib\";\r\nimport {ISecurityGroup, IVpc, SubnetSelection} from \"aws-cdk-lib/aws-ec2\";\r\nimport {RetentionDays} from 'aws-cdk-lib/aws-logs';\r\nimport {Role} from 'aws-cdk-lib/aws-iam';\r\nimport {DigitrafficStack} from \"./stack\";\r\nimport {MonitoredFunctionAlarmProps} from \"./monitoredfunction\";\r\n\r\nexport type LambdaEnvironment = Record<string, string>;\r\n\r\nexport type DBLambdaEnvironment = LambdaEnvironment & {\r\n    SECRET_ID?: string\r\n    DB_APPLICATION: string\r\n}\r\n\r\nexport interface LambdaConfiguration {\r\n    vpcId: string;\r\n    allowFromIpAddresses?: string[];\r\n    privateSubnetIds: string[];\r\n    availabilityZones: string[];\r\n    lambdaDbSgId: string;\r\n    dbProps?: DbProps;\r\n    defaultLambdaDurationSeconds?: number;\r\n    logsDestinationArn: string;\r\n    memorySize?: number,\r\n    runtime?: Runtime;\r\n}\r\n\r\ndeclare interface DbProps {\r\n    username: string;\r\n    password: string;\r\n    uri?: string;\r\n    ro_uri?: string;\r\n}\r\n\r\nexport function databaseFunctionProps(\r\n    stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: FunctionParameters,\r\n): FunctionProps {\r\n    const vpcSubnets = stack.vpc ? {\r\n        subnets: stack.vpc.privateSubnets,\r\n    } : undefined;\r\n\r\n    return {...lambdaFunctionProps(\r\n        stack, environment, lambdaName, simpleLambdaName, config,\r\n    ), ...{\r\n        vpc: stack.vpc || undefined,\r\n        vpcSubnets,\r\n        securityGroup: stack.lambdaDbSg || undefined,\r\n    }};\r\n}\r\n\r\nexport function lambdaFunctionProps(\r\n    stack: DigitrafficStack, environment: LambdaEnvironment, lambdaName: string, simpleLambdaName: string, config?: FunctionParameters,\r\n): FunctionProps {\r\n    return {\r\n        runtime: config?.runtime || Runtime.NODEJS_14_X,\r\n        architecture: config?.architecture || Architecture.ARM_64,\r\n        memorySize: config?.memorySize || 128,\r\n        functionName: lambdaName,\r\n        role: config?.role,\r\n        timeout: Duration.seconds(config?.timeout || 60),\r\n        logRetention: RetentionDays.ONE_YEAR,\r\n        reservedConcurrentExecutions: config?.reservedConcurrentExecutions || 2,\r\n        code: getAssetCode(simpleLambdaName, config),\r\n        handler: `${simpleLambdaName}.handler`,\r\n        environment,\r\n    };\r\n}\r\n\r\nfunction getAssetCode(simpleLambdaName: string, config?: FunctionParameters): AssetCode {\r\n    const lambdaPath = config?.singleLambda ? `dist/lambda/` : `dist/lambda/${simpleLambdaName}`;\r\n\r\n    return new AssetCode(lambdaPath);\r\n}\r\n\r\n/**\r\n * Creates a base configuration for a Lambda that uses an RDS database\r\n * @param vpc \"Private\" Lambdas are associated with a VPC\r\n * @param lambdaDbSg Security Group shared by Lambda and RDS\r\n * @param props Database connection properties for the Lambda\r\n * @param config Lambda configuration\r\n */\r\nexport function dbLambdaConfiguration(vpc: IVpc,\r\n    lambdaDbSg: ISecurityGroup,\r\n    props: LambdaConfiguration,\r\n    config: FunctionParameters): FunctionProps {\r\n\r\n    return {\r\n        runtime: props.runtime || Runtime.NODEJS_14_X,\r\n        memorySize: props.memorySize || config.memorySize || 1024,\r\n        functionName: config.functionName,\r\n        code: config.code as Code,\r\n        role: config.role,\r\n        handler: config.handler as string,\r\n        timeout: Duration.seconds(config.timeout || props.defaultLambdaDurationSeconds || 60),\r\n        environment: config.environment || {\r\n            DB_USER: props.dbProps?.username as string,\r\n            DB_PASS: props.dbProps?.password as string,\r\n            DB_URI: (config.readOnly ? props.dbProps?.ro_uri : props.dbProps?.uri) as string,\r\n        },\r\n        logRetention: RetentionDays.ONE_YEAR,\r\n        vpc: vpc,\r\n        vpcSubnets: {\r\n            subnets: vpc.privateSubnets,\r\n        },\r\n        securityGroups: [lambdaDbSg],\r\n        reservedConcurrentExecutions: config.reservedConcurrentExecutions || 3,\r\n    };\r\n}\r\n\r\nexport function defaultLambdaConfiguration(config: FunctionParameters): FunctionProps {\r\n    const props: FunctionProps = {\r\n        runtime: Runtime.NODEJS_14_X,\r\n        memorySize: config.memorySize ?? 128,\r\n        functionName: config.functionName,\r\n        handler: config.handler as string,\r\n        environment: config.environment ?? {},\r\n        logRetention: RetentionDays.ONE_YEAR,\r\n        reservedConcurrentExecutions: config.reservedConcurrentExecutions,\r\n        code: config.code as Code,\r\n        role: config.role,\r\n        timeout: Duration.seconds(config.timeout || 10),\r\n    };\r\n    if (config.vpc) {\r\n        return {...props, ...{\r\n            vpc: config.vpc,\r\n            vpcSubnets: {\r\n                subnets: config.vpc?.privateSubnets,\r\n            },\r\n        }};\r\n    }\r\n    return props;\r\n}\r\n\r\nexport interface FunctionParameters {\r\n    memorySize?: number;\r\n    timeout?: number;\r\n    functionName?: string;\r\n    code?: Code;\r\n    handler?: string;\r\n    readOnly?: boolean;\r\n    environment?: {\r\n        [key: string]: string;\r\n    };\r\n    reservedConcurrentExecutions?: number;\r\n    role?: Role;\r\n    vpc?: IVpc;\r\n    vpcSubnets?: SubnetSelection;\r\n    runtime?: Runtime;\r\n    architecture?: Architecture;\r\n    singleLambda?: boolean;\r\n}\r\n\r\nexport type MonitoredFunctionParameters = {\r\n    readonly memorySize?: number;\r\n    readonly timeout?: number;\r\n    readonly functionName?: string;\r\n    readonly reservedConcurrentExecutions?: number;\r\n    readonly role?: Role;\r\n    readonly runtime?: Runtime;\r\n    readonly architecture?: Architecture;\r\n    readonly singleLambda?: boolean;\r\n\r\n    readonly durationAlarmProps?: MonitoredFunctionAlarmProps\r\n    readonly durationWarningProps?: MonitoredFunctionAlarmProps\r\n    readonly errorAlarmProps?: MonitoredFunctionAlarmProps\r\n    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps\r\n}\r\n"]}

package/aws/infra/stack/monitoredfunction.d.ts

@@ -0,0 +1,84 @@
+import { Function, FunctionProps } from 'aws-cdk-lib/aws-lambda';
+import { Stack } from "aws-cdk-lib";
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+import { DigitrafficStack } from "../stack/stack";
+import { ITopic } from "aws-cdk-lib/aws-sns";
+import { LambdaEnvironment, MonitoredFunctionParameters } from "../stack/lambda-configs";
+import { TrafficType } from "../../../types/traffictype";
+/**
+ * Allows customization of CloudWatch Alarm properties
+ */
+export declare type MonitoredFunctionAlarmProps = {
+    /**
+     * Setting this to false will not create a CloudWatch alarm
+     */
+    readonly create: boolean;
+    readonly threshold?: number;
+    readonly evaluationPeriods?: number;
+    readonly datapointsToAlarm?: number;
+    readonly comparisonOperator?: ComparisonOperator;
+};
+export declare type MonitoredFunctionProps = {
+    readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly durationWarningProps?: MonitoredFunctionAlarmProps;
+    readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
+    readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
+};
+/**
+ * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
+ */
+export declare class MonitoredFunction extends Function {
+    readonly givenName: string;
+    /** disable all alarms */
+    static readonly DISABLE_ALARMS: MonitoredFunctionProps;
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack: DigitrafficStack, id: string, functionProps: FunctionProps, props?: MonitoredFunctionProps): MonitoredFunction;
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack: DigitrafficStack, name: string, environment: LambdaEnvironment, functionParameters?: MonitoredFunctionParameters): MonitoredFunction;
+    /**
+     * @param scope Stack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param alarmSnsTopic SNS topic for alarms
+     * @param warningSnsTopic SNS topic for warnings
+     * @param production Is the stack a production stack, used for determining the alarm topic
+     * @param trafficType Traffic type, used for alarm names. Set to null if Lambda is not related to any traffic type.
+     * @param props Monitored function properties
+     */
+    constructor(scope: Stack, id: string, functionProps: FunctionProps, alarmSnsTopic: ITopic, warningSnsTopic: ITopic, production: boolean, trafficType: TrafficType | null, props?: MonitoredFunctionProps);
+    private createAlarm;
+    private getAlarmActionForEnv;
+}
+export declare class MonitoredDBFunction {
+    /**
+     * Create new MonitoredDBFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     * Grant secret and create log subscription.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * If you don't need to pass any extra arguments to lambda-environment, you can leave environment out and this function will create the
+     * default Lambda Environment with SECRET_ID and DB_APPLICATION.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static create(stack: DigitrafficStack, name: string, environment?: LambdaEnvironment, functionParameters?: MonitoredFunctionParameters): MonitoredFunction;
+}