@digitraffic/common 2022.12.2-1 → 2022.12.22-2

package/src/aws/infra/api/handler-factory.ts

@@ -1,8 +1,12 @@
-export type LoggingHandler<RESPONSE> = (
-    methodName: string,
-    method: () => Promise<RESPONSE>
-) => Promise<RESPONSE>;
-export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
+import { DtLogger } from "../../runtime/dt-logger";
+import { LambdaResponse } from "../../types/lambda-response";
+
+export type LoggingHandler = (
+    method: () => Promise<LambdaResponse>,
+    logger: DtLogger
+) => Promise<LambdaResponse>;
+
+export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
 
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
@@ -13,58 +17,64 @@ export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
  * You should instantiate HandlerFactory in your project with desired error handling and use the factory instance for
  * creating handler-functions for your lambdas.
  */
-export class HandlerFactory<RESPONSE> {
-    private loggingHandler: LoggingHandler<RESPONSE>;
-    private errorHandler: ErrorHandler<RESPONSE>;
+export class HandlerFactory {
+    private loggingHandler: LoggingHandler;
+    private errorHandler: ErrorHandler;
 
     constructor() {
-        this.loggingHandler = createDefaultLoggingHandler();
+        this.loggingHandler = async (method: () => Promise<LambdaResponse>) => {
+            const start = Date.now();
+
+            try {
+                return await method();
+            } finally {
+                console.info(
+                    "method=%s.handler tookMs=%d",
+                    process.env.AWS_LAMBDA_FUNCTION_NAME,
+                    Date.now() - start
+                );
+            }
+        };
 
         this.errorHandler = (error: unknown) => {
             throw error;
         };
     }
 
-    withLoggingHandler(loggingHandler: LoggingHandler<RESPONSE>) {
+    withLoggingHandler(loggingHandler: LoggingHandler) {
         this.loggingHandler = loggingHandler;
         return this;
     }
 
-    withErrorHandler(errorHandler: ErrorHandler<RESPONSE>) {
+    withErrorHandler(errorHandler: ErrorHandler) {
         this.errorHandler = errorHandler;
         return this;
     }
 
     createEventHandler(
-        methodName: string,
-        handler: (event: unknown) => Promise<RESPONSE>
+        handler: (event: unknown) => Promise<LambdaResponse>,
+        logger: DtLogger
     ) {
         return async (event: unknown) => {
-            return await this.loggingHandler(methodName, async () => {
+            return await this.loggingHandler(async () => {
                 try {
                     return await handler(event);
                 } catch (error) {
-                    return this.errorHandler(error);
+                    return this.errorHandler(error, logger);
                 }
-            });
+            }, logger);
         };
     }
 }
 
-export function createNoLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE> {
-    return (methodName: string, method: () => Promise<RESPONSE>) => {
-        return method();
-    };
-}
-
-function createDefaultLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE> {
-    return (methodName: string, method: () => Promise<RESPONSE>) => {
+export function createJsonLoggingHandler(): LoggingHandler {
+    return async (method: () => Promise<LambdaResponse>, logger: DtLogger) => {
         const start = Date.now();
 
         try {
-            return method();
+            return await method();
         } finally {
-            console.info("method=%s tookMs=%d", methodName, Date.now() - start);
+            logger.info({ tookMs: Date.now() - start });
         }
     };
 }

package/src/aws/infra/api/integration.ts

@@ -25,13 +25,13 @@ export class DigitrafficIntegration {
         this.mediaType = mediaType;
     }
 
-    addPathParameter(...names: string[]): DigitrafficIntegration {
+    addPathParameter(...names: string[]): this {
         names.forEach((name) => this.parameters.push({ type: "path", name }));
 
         return this;
     }
 
-    addQueryParameter(...names: string[]): DigitrafficIntegration {
+    addQueryParameter(...names: string[]): this {
         names.forEach((name) =>
             this.parameters.push({ type: "querystring", name })
         );

package/src/aws/infra/api/responses.ts

@@ -64,7 +64,7 @@ export function methodResponse(
     return {
         statusCode: status,
         responseModels: createResponses(contentType, model),
-        responseParameters: parameters || {},
+        responseParameters: parameters ?? {},
     };
 }
 
@@ -83,7 +83,9 @@ export function corsMethod(response: MethodResponse): MethodResponse {
 }
 
 interface IntegrationOptions {
+    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
     requestParameters?: { [dest: string]: string };
+    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
     requestTemplates?: { [contentType: string]: string };
     responses?: IntegrationResponse[];
     disableCors?: boolean;
@@ -104,14 +106,14 @@ export function defaultIntegration(
 ): LambdaIntegration {
     return new LambdaIntegration(lambdaFunction, {
         proxy: false,
-        integrationResponses: options?.responses || [
+        integrationResponses: options?.responses ?? [
             getResponse(RESPONSE_200_OK, options),
             getResponse(RESPONSE_400_BAD_REQUEST, options),
             getResponse(RESPONSE_404_NOT_FOUND, options),
             getResponse(RESPONSE_500_SERVER_ERROR, options),
         ],
-        requestParameters: options?.requestParameters || {},
-        requestTemplates: options?.requestTemplates || {},
+        requestParameters: options?.requestParameters ?? {},
+        requestTemplates: options?.requestTemplates ?? {},
         passthroughBehavior:
             options?.passthroughBehavior ?? PassthroughBehavior.WHEN_NO_MATCH,
     });

package/src/aws/infra/canaries/canary-parameters.ts

@@ -1,9 +1,9 @@
-import {Schedule} from "@aws-cdk/aws-synthetics-alpha";
+import { Schedule } from "@aws-cdk/aws-synthetics-alpha";
 
 /** Optional env parameters for canary */
 type CanaryEnv = Record<string, string>;
 
-export type CanaryParameters = {
+export interface CanaryParameters {
     readonly name: string;
     readonly schedule?: Schedule;
     readonly secret?: string;
@@ -14,6 +14,6 @@ export type CanaryParameters = {
         readonly evalutionPeriods?: number;
         readonly threshold?: number;
         readonly topicArn?: string;
-    }
+    };
     readonly canaryEnv?: CanaryEnv;
 }

package/src/aws/infra/canaries/canary-role.ts

@@ -1,5 +1,11 @@
-import {ManagedPolicy, PolicyStatement, PolicyStatementProps, Role, ServicePrincipal} from "aws-cdk-lib/aws-iam";
-import {Construct} from "constructs";
+import {
+    ManagedPolicy,
+    PolicyStatement,
+    PolicyStatementProps,
+    Role,
+    ServicePrincipal,
+} from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
 
 const BASE_POLICY_STATEMENT_PROPS: PolicyStatementProps = {
     actions: [
@@ -13,12 +19,10 @@ const BASE_POLICY_STATEMENT_PROPS: PolicyStatementProps = {
 };
 
 const CLOUDWATCH_STATEMENT_PROPS: PolicyStatementProps = {
-    actions: [
-        "cloudwatch:PutMetricData",
-    ],
+    actions: ["cloudwatch:PutMetricData"],
     resources: ["*"],
     conditions: {
-        "StringEquals": {
+        StringEquals: {
             "cloudwatch:namespace": "CloudWatchSynthetics",
         },
     },
@@ -26,10 +30,12 @@ const CLOUDWATCH_STATEMENT_PROPS: PolicyStatementProps = {
 
 export class DigitrafficCanaryRole extends Role {
     constructor(stack: Construct, canaryName: string) {
-        super(stack, 'canary-role-' + canaryName, {
+        super(stack, "canary-role-" + canaryName, {
             assumedBy: new ServicePrincipal("lambda.amazonaws.com"),
             managedPolicies: [
-                ManagedPolicy.fromAwsManagedPolicyName("CloudWatchSyntheticsFullAccess"),
+                ManagedPolicy.fromAwsManagedPolicyName(
+                    "CloudWatchSyntheticsFullAccess"
+                ),
             ],
         });
 
@@ -37,11 +43,15 @@ export class DigitrafficCanaryRole extends Role {
         this.addToPolicy(new PolicyStatement(CLOUDWATCH_STATEMENT_PROPS));
     }
 
-    withDatabaseAccess(): DigitrafficCanaryRole {
+    withDatabaseAccess(): this {
         // Won't work :(
         // this.addToPolicy(new PolicyStatement(DB_STATEMENT_PROPS));
         // Works
-        this.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSLambdaVPCAccessExecutionRole"));
+        this.addManagedPolicy(
+            ManagedPolicy.fromAwsManagedPolicyName(
+                "service-role/AWSLambdaVPCAccessExecutionRole"
+            )
+        );
         return this;
     }
 }

package/src/aws/infra/documentation.ts

@@ -1,5 +1,5 @@
-import {Construct} from "constructs";
-import {CfnDocumentationPart, Resource} from "aws-cdk-lib/aws-apigateway";
+import { Construct } from "constructs";
+import { CfnDocumentationPart, Resource } from "aws-cdk-lib/aws-apigateway";
 
 // Documentation parts are objects that describe an API Gateway API or parts of an API
 // https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-documenting-api.html
@@ -13,18 +13,20 @@ import {CfnDocumentationPart, Resource} from "aws-cdk-lib/aws-apigateway";
  *
  * @deprecated Use DigitrafficRestApi.documentResource
  */
-export function addQueryParameterDescription(name: string,
+export function addQueryParameterDescription(
+    name: string,
     description: string,
     resource: Resource,
-    stack: Construct) {
+    stack: Construct
+) {
     new CfnDocumentationPart(stack, `${name}Documentation`, {
         restApiId: resource.api.restApiId,
         location: {
-            type: 'QUERY_PARAMETER',
+            type: "QUERY_PARAMETER",
             name,
             path: resource.path,
         },
-        properties: JSON.stringify({description}),
+        properties: JSON.stringify({ description }),
     });
 }
 
@@ -35,14 +37,16 @@ export function addQueryParameterDescription(name: string,
  * @param resource REST API resource
  * @param stack CloudFormation stack
  */
-export function addDocumentation(methodDescription: string,
+export function addDocumentation(
+    methodDescription: string,
     documentationProperties: object,
     resource: Resource,
-    stack: Construct) {
+    stack: Construct
+) {
     new CfnDocumentationPart(stack, `${methodDescription}Documentation`, {
         restApiId: resource.api.restApiId,
         location: {
-            type: 'METHOD',
+            type: "METHOD",
             path: resource.path,
         },
         properties: JSON.stringify(documentationProperties),
@@ -56,11 +60,13 @@ export function addDocumentation(methodDescription: string,
  * @param resource REST API resource
  * @param stack CloudFormation stack
  */
-export function addTags(methodDescription: string,
+export function addTags(
+    methodDescription: string,
     tags: string[],
     resource: Resource,
-    stack: Construct) {
-    addDocumentation(methodDescription, {tags}, resource, stack);
+    stack: Construct
+) {
+    addDocumentation(methodDescription, { tags }, resource, stack);
 }
 
 /**
@@ -79,16 +85,16 @@ export function addTagsAndSummary(
     tags: string[],
     summary: string,
     resource: Resource,
-    stack: Construct,
+    stack: Construct
 ) {
-    addDocumentation(methodDescription, {tags, summary}, resource, stack);
+    addDocumentation(methodDescription, { tags, summary }, resource, stack);
 }
 
 export interface DocumentationProperties {
-    description?: string
-    tags?: string[]
-    summary?: string
-    deprecated?: boolean
+    description?: string;
+    tags?: string[];
+    summary?: string;
+    deprecated?: boolean;
 }
 
 export class DocumentationPart {
@@ -96,29 +102,41 @@ export class DocumentationPart {
     readonly type: string;
     readonly documentationProperties: DocumentationProperties;
 
-    private constructor(parameterName: string, documentationProperties: DocumentationProperties, type: string) {
+    private constructor(
+        parameterName: string,
+        documentationProperties: DocumentationProperties,
+        type: string
+    ) {
         this.parameterName = parameterName;
         this.documentationProperties = documentationProperties;
         this.type = type;
     }
 
-    deprecated(note: string): DocumentationPart {
+    deprecated(note: string): this {
         // deprecated is not supported ATM: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html
         this.documentationProperties.deprecated = true;
-        this.documentationProperties.summary+= '. ' + note;
+        this.documentationProperties.summary += ". " + note;
 
         return this;
     }
 
     static queryParameter(parameterName: string, description: string) {
-        return new DocumentationPart(parameterName, {description}, "QUERY_PARAMETER");
+        return new DocumentationPart(
+            parameterName,
+            { description },
+            "QUERY_PARAMETER"
+        );
     }
 
     static pathParameter(parameterName: string, description: string) {
-        return new DocumentationPart(parameterName, {description}, "PATH_PARAMETER");
+        return new DocumentationPart(
+            parameterName,
+            { description },
+            "PATH_PARAMETER"
+        );
     }
 
     static method(tags: string[], name: string, summary: string) {
-        return new DocumentationPart(name, {tags, summary}, "METHOD");
+        return new DocumentationPart(name, { tags, summary }, "METHOD");
     }
 }

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

@@ -16,7 +16,7 @@ import { TrafficType } from "../../../types/traffictype";
 /**
  * Allows customization of CloudWatch Alarm properties
  */
-export type MonitoredFunctionAlarmProps = {
+export interface MonitoredFunctionAlarmProps {
     /**
      * Setting this to false will not create a CloudWatch alarm
      */
@@ -29,9 +29,9 @@ export type MonitoredFunctionAlarmProps = {
     readonly datapointsToAlarm?: number;
 
     readonly comparisonOperator?: ComparisonOperator;
-};
+}
 
-export type MonitoredFunctionProps = {
+export interface MonitoredFunctionProps {
     readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
 
     readonly durationWarningProps?: MonitoredFunctionAlarmProps;
@@ -39,7 +39,7 @@ export type MonitoredFunctionProps = {
     readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
 
     readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
-};
+}
 
 /**
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
@@ -115,7 +115,7 @@ export class MonitoredFunction extends Function {
         functionParameters?: Partial<MonitoredFunctionParameters>
     ): MonitoredFunction {
         const functionName =
-            functionParameters?.functionName ||
+            functionParameters?.functionName ??
             `${stack.configuration.shortName}-${pascalCase(name)}`;
         const functionProps = databaseFunctionProps(
             stack,
@@ -313,7 +313,7 @@ export class MonitoredDBFunction {
         functionParameters?: Partial<MonitoredFunctionParameters>
     ): MonitoredFunction {
         const functionName =
-            functionParameters?.functionName ||
+            functionParameters?.functionName ??
             `${stack.configuration.shortName}-${pascalCase(name)}`;
         const env = environment ? environment : stack.createLambdaEnvironment();
         const functionProps = databaseFunctionProps(

package/src/aws/infra/stack/stack-checking-aspect.ts

@@ -183,19 +183,17 @@ export class StackCheckingAspect implements IAspect {
             const c =
                 node.publicAccessBlockConfiguration as CfnBucket.PublicAccessBlockConfigurationProperty;
 
-            if (c) {
-                if (
-                    !c.blockPublicAcls ||
-                    !c.blockPublicPolicy ||
-                    !c.ignorePublicAcls ||
-                    !c.restrictPublicBuckets
-                ) {
-                    this.addAnnotation(
-                        node,
-                        ResourceType.bucketPublicity,
-                        "Check bucket publicity"
-                    );
-                }
+            if (
+                !c.blockPublicAcls ||
+                !c.blockPublicPolicy ||
+                !c.ignorePublicAcls ||
+                !c.restrictPublicBuckets
+            ) {
+                this.addAnnotation(
+                    node,
+                    ResourceType.bucketPublicity,
+                    "Check bucket publicity"
+                );
             }
         }
     }
@@ -227,9 +225,11 @@ export class StackCheckingAspect implements IAspect {
                 );
             }
         } else if (node instanceof CfnMethod) {
-            const integration = node.integration as IntegrationProperty;
+            const integration = node.integration as
+                | IntegrationProperty
+                | undefined;
 
-            if (integration && integration.requestParameters) {
+            if (integration?.requestParameters) {
                 Object.keys(integration.requestParameters).forEach((key) => {
                     const split = key.split(".");
                     const type = split[2];

package/src/aws/infra/stacks/db-stack.ts

@@ -104,7 +104,8 @@ export class DbStack extends Stack {
                       }),
                       parameters: {
                           "pg_stat_statements.track": "ALL",
-                          random_page_cost: "1",
+                          "random_page_cost": "1",
+                          "work_mem": "512MB"
                       },
                   }
               )

package/src/aws/runtime/dt-logger.ts

@@ -0,0 +1,61 @@
+import { Writable } from "stream";
+
+type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+
+export interface LoggerConfiguration {
+    lambdaName?: string;
+    fileName?: string;
+    runTime?: string;
+    writeStream?: Writable;
+}
+
+export type LoggableType = string | number | Record<string, unknown>;
+
+/**
+ * Helper class for json-logging.  Logged line will include
+ * * log-level (see LOG_LEVEL)
+ * * lambdaName (taken from process environment)
+ * * runtime (taken from process environment)
+ * * the actual message (as json or as string)
+ */
+export class DtLogger {
+    readonly lambdaName?: string;
+    readonly fileName?: string;
+    readonly runtime?: string;
+
+    readonly writeStream: Writable;
+
+    constructor(config?: LoggerConfiguration) {
+        this.lambdaName =
+            config?.lambdaName ?? process.env.AWS_LAMBDA_FUNCTION_NAME;
+        this.fileName = config?.fileName;
+        this.runtime = config?.runTime ?? process.env.AWS_EXECUTION_ENV;
+        this.writeStream = config?.writeStream ?? process.stdout;
+    }
+
+    info(message: LoggableType) {
+        this.log("INFO", message);
+    }
+
+    error(message: LoggableType) {
+        this.log("ERROR", message);
+    }
+
+    log(level: LOG_LEVEL, message: LoggableType) {
+        // put string/number messages into message object
+        const actualMessage =
+            typeof message == "object" ? message : { message: message };
+
+        const logMessage = {
+            ...actualMessage,
+            ...{
+                level,
+                fileName: this.fileName,
+                lambdaName: this.lambdaName,
+                runtime: this.runtime,
+            },
+        };
+
+        this.writeStream.write(JSON.stringify(logMessage) + "\n");
+    }
+}

package/src/aws/runtime/secrets/dbsecret.ts

@@ -1,11 +1,11 @@
 import { GenericSecret, withSecret, withSecretAndPrefix } from "./secret";
 
-export type DbSecret = {
+export interface DbSecret {
     readonly username: string;
     readonly password: string;
     readonly host: string;
     readonly ro_host: string;
-};
+}
 
 export enum RdsProxySecretKey {
     username = "username",
@@ -53,10 +53,10 @@ const missingSecretErrorText = "Missing or empty secretId";
  * The secret that is passed to the given function will not include the prefix in it's keys.
 
  */
-export type SecretOptions = {
+export interface SecretOptions {
     readonly expectedKeys?: string[];
     readonly prefix?: string;
-};
+}
 
 export type SecretToPromiseFunction<Secret, Response = void> = (
     secret: Secret
@@ -140,7 +140,7 @@ export function checkExpectedSecretKeys<Secret extends GenericSecret>(
     const missingKeys = keys.filter((key) => !(key in secret));
     if (missingKeys.length) {
         console.error(
-            `method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys}`
+            `method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys.toString()}`
         );
         throw new Error("Expected keys were not found");
     }

package/src/aws/types/proxytypes.ts

@@ -3,11 +3,11 @@
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaResponse = {
-    readonly statusCode: number
-    readonly body: string
-    readonly headers?: Record<string, string>
-    readonly multiValueHeaders?: Record<string, string[]>
+export interface ProxyLambdaResponse {
+    readonly statusCode: number;
+    readonly body: string;
+    readonly headers?: Record<string, string>;
+    readonly multiValueHeaders?: Record<string, string[]>;
 }
 
 /**
@@ -15,13 +15,13 @@ export type ProxyLambdaResponse = {
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaRequest = {
-    readonly resource: string
-    readonly path: string
-    readonly httpMethod: string
-    readonly headers: Record<string, string>
-    readonly multiValueHeaders: Record<string, string[]>
-    readonly queryStringParameters: Record<string, string>
-    readonly multiValueQueryStringParameters: Record<string, string[]>
-    readonly body?: string
+export interface ProxyLambdaRequest {
+    readonly resource: string;
+    readonly path: string;
+    readonly httpMethod: string;
+    readonly headers: Record<string, string>;
+    readonly multiValueHeaders: Record<string, string[]>;
+    readonly queryStringParameters: Record<string, string>;
+    readonly multiValueQueryStringParameters: Record<string, string[]>;
+    readonly body?: string;
 }