@liflig/cdk 3.22.19 → 3.23.1

package/lib/alarms/slack-alarm.d.ts

@@ -1,4 +1,5 @@
 import * as cloudwatchActions from "aws-cdk-lib/aws-cloudwatch-actions";
+import * as lambda from "aws-cdk-lib/aws-lambda";
 import type * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
 import * as sns from "aws-cdk-lib/aws-sns";
 import * as constructs from "constructs";
@@ -15,11 +16,15 @@ export interface SlackAlarmProps {
     slackWebhookUrlSecret: secretsmanager.ISecret;
 }
 /**
- * SNS Topic that can be used to action alarms, with a Lambda
+ * Creates
+ * - SNS Topic that can be used to action alarms, with a Lambda
  * that will send a message to Slack for the alarm.
+ * - A reusable Lambda that accepts CloudWatch Logs subscription events and posts
+ * formatted error messages to Slack.
  */
 export declare class SlackAlarm extends constructs.Construct {
     readonly alarmTopic: sns.Topic;
     readonly snsAction: cloudwatchActions.SnsAction;
+    readonly logHandler: lambda.Function;
     constructor(scope: constructs.Construct, id: string, props: SlackAlarmProps);
 }

package/lib/alarms/slack-alarm.js

@@ -7,21 +7,25 @@ import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as sns from "aws-cdk-lib/aws-sns";
 import * as constructs from "constructs";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __file = fileURLToPath(import.meta.url);
+const __dir = path.dirname(__file);
 /**
- * SNS Topic that can be used to action alarms, with a Lambda
+ * Creates
+ * - SNS Topic that can be used to action alarms, with a Lambda
  * that will send a message to Slack for the alarm.
+ * - A reusable Lambda that accepts CloudWatch Logs subscription events and posts
+ * formatted error messages to Slack.
  */
 export class SlackAlarm extends constructs.Construct {
     alarmTopic;
     snsAction;
+    logHandler;
     constructor(scope, id, props) {
         super(scope, id);
         this.alarmTopic = new sns.Topic(this, "Topic");
         this.snsAction = new cloudwatchActions.SnsAction(this.alarmTopic);
         const slackLambda = new lambda.Function(this, "Function", {
-            code: lambda.Code.fromAsset(path.join(__dirname, "../../assets/slack-alarm-lambda")),
+            code: lambda.Code.fromAsset(path.join(__dir, "../../assets/slack-alarm-lambda")),
             description: "Receives CloudWatch Alarms through SNS and sends a formatted version to Slack",
             handler: "index.handler",
             memorySize: 128,
@@ -33,6 +37,20 @@ export class SlackAlarm extends constructs.Construct {
                 ENVIRONMENT_NAME: props.envName,
             },
         });
+        this.logHandler = new lambda.Function(this, "LogHandler", {
+            code: lambda.Code.fromAsset(path.join(__dir, "../../assets", "slack-error-log-handler-lambda")),
+            description: "Receives CloudWatch Logs subscription events and sends formatted errors to Slack",
+            handler: "index.handler",
+            memorySize: 128,
+            runtime: lambda.Runtime.PYTHON_3_14,
+            timeout: Duration.seconds(10),
+            environment: {
+                SLACK_URL_SECRET_NAME: props.slackWebhookUrlSecret.secretName,
+                PROJECT_NAME: props.projectName,
+                ENVIRONMENT_NAME: props.envName,
+            },
+        });
+        props.slackWebhookUrlSecret.grantRead(this.logHandler);
         props.slackWebhookUrlSecret.grantRead(slackLambda);
         slackLambda.addPermission("InvokePermission", {
             action: "lambda:InvokeFunction",
@@ -51,4 +69,4 @@ export class SlackAlarm extends constructs.Construct {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slack-alarm.js","sourceRoot":"","sources":["../../src/alarms/slack-alarm.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport { Duration } from \"aws-cdk-lib\"\nimport * as cloudwatchActions from \"aws-cdk-lib/aws-cloudwatch-actions\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport { Effect, PolicyStatement } from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport type * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as sns from \"aws-cdk-lib/aws-sns\"\nimport * as constructs from \"constructs\"\n\nconst __file = fileURLToPath(import.meta.url)\nconst __dir = path.dirname(__file)\n\nexport interface SlackAlarmProps {\n  projectName: string\n  envName: string\n  /**\n   * A plaintext secret containing the URL of a Slack incoming webhook.\n   * The webhook should be created through a Slack app, and only allows posting to one specific Slack channel.\n   * See Slack's official documentation (e.g., https://api.slack.com/messaging/webhooks) for more details.\n   *\n   * NOTE: Incoming webhooks created through legacy custom integrations in Slack are not supported.\n   */\n  slackWebhookUrlSecret: secretsmanager.ISecret\n}\n\n/**\n * Creates\n * - SNS Topic that can be used to action alarms, with a Lambda\n * that will send a message to Slack for the alarm.\n * - A reusable Lambda that accepts CloudWatch Logs subscription events and posts\n * formatted error messages to Slack.\n */\nexport class SlackAlarm extends constructs.Construct {\n  public readonly alarmTopic: sns.Topic\n  public readonly snsAction: cloudwatchActions.SnsAction\n  public readonly logHandler: lambda.Function\n\n  constructor(scope: constructs.Construct, id: string, props: SlackAlarmProps) {\n    super(scope, id)\n\n    this.alarmTopic = new sns.Topic(this, \"Topic\")\n\n    this.snsAction = new cloudwatchActions.SnsAction(this.alarmTopic)\n\n    const slackLambda = new lambda.Function(this, \"Function\", {\n      code: lambda.Code.fromAsset(\n        path.join(__dir, \"../../assets/slack-alarm-lambda\"),\n      ),\n      description:\n        \"Receives CloudWatch Alarms through SNS and sends a formatted version to Slack\",\n      handler: \"index.handler\",\n      memorySize: 128,\n      runtime: lambda.Runtime.PYTHON_3_13,\n      timeout: Duration.seconds(6),\n      environment: {\n        SLACK_URL_SECRET_NAME: props.slackWebhookUrlSecret.secretName,\n        PROJECT_NAME: props.projectName,\n        ENVIRONMENT_NAME: props.envName,\n      },\n    })\n\n    this.logHandler = new lambda.Function(this, \"LogHandler\", {\n      code: lambda.Code.fromAsset(\n        path.join(__dir, \"../../assets\", \"slack-error-log-handler-lambda\"),\n      ),\n      description:\n        \"Receives CloudWatch Logs subscription events and sends formatted errors to Slack\",\n      handler: \"index.handler\",\n      memorySize: 128,\n      runtime: lambda.Runtime.PYTHON_3_14,\n      timeout: Duration.seconds(10),\n      environment: {\n        SLACK_URL_SECRET_NAME: props.slackWebhookUrlSecret.secretName,\n        PROJECT_NAME: props.projectName,\n        ENVIRONMENT_NAME: props.envName,\n      },\n    })\n\n    props.slackWebhookUrlSecret.grantRead(this.logHandler)\n    props.slackWebhookUrlSecret.grantRead(slackLambda)\n\n    slackLambda.addPermission(\"InvokePermission\", {\n      action: \"lambda:InvokeFunction\",\n      principal: new iam.ServicePrincipal(\"sns.amazonaws.com\"),\n      sourceArn: this.alarmTopic.topicArn,\n    })\n    slackLambda.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\"cloudwatch:DescribeAlarms\"],\n        effect: Effect.ALLOW,\n        resources: [\"*\"],\n      }),\n    )\n\n    new sns.Subscription(this, \"Subscription\", {\n      endpoint: slackLambda.functionArn,\n      protocol: sns.SubscriptionProtocol.LAMBDA,\n      topic: this.alarmTopic,\n    })\n  }\n}\n"]}

package/lib/ecs/fargate-service.d.ts

@@ -1,10 +1,107 @@
 import * as cdk from "aws-cdk-lib";
+import type * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import * as ec2 from "aws-cdk-lib/aws-ec2";
 import * as ecs from "aws-cdk-lib/aws-ecs";
 import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import type * as lambda from "aws-cdk-lib/aws-lambda";
 import * as logs from "aws-cdk-lib/aws-logs";
 import * as constructs from "constructs";
-import type { Parameter } from "../configure-parameters/configure-parameters";
+import { ServiceAlarms } from "../alarms";
+import type { Parameter } from "../configure-parameters";
+/**
+ * Configure service alarms.
+ *
+ * Alarms are enabled by default when a config object with `alarmAction` and
+ * `warningAction` is provided. To explicitly disable automatic alarms use
+ * `{ enabled: false }`.
+ */
+export type ServiceAlarmsConfig = {
+    enabled: false;
+} | {
+    alarmAction: cloudwatch.IAlarmAction;
+    warningAction: cloudwatch.IAlarmAction;
+    loadBalancerFullName: string;
+    /** Optional Lambda function that will receive
+     * forwarded log events */
+    logHandler?: lambda.IFunction;
+    /**
+     * Individual alarm configuration overrides defaults.
+     */
+    jsonErrorAlarm?: {
+        /**
+         * @default true
+         */
+        enabled?: boolean;
+        alarmDescription?: string;
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
+    };
+    uncaughtJavaExceptionAlarm?: {
+        /**
+         * @default false
+         */
+        enabled?: boolean;
+        alarmDescription?: string;
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
+    };
+    targetHealthAlarm?: {
+        /**
+         * @default true
+         */
+        enabled?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        period?: cdk.Duration;
+        evaluationPeriods?: number;
+        threshold?: number;
+        description?: string;
+    };
+    tooMany5xxResponsesFromTargetsAlarm?: {
+        /**
+         * @default true
+         */
+        enabled?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        period?: cdk.Duration;
+        evaluationPeriods?: number;
+        threshold?: number;
+        description?: string;
+    };
+    targetResponseTimeAlarm?: {
+        /**
+         * @default true
+         */
+        enabled?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        period?: cdk.Duration;
+        evaluationPeriods?: number;
+        threshold?: cdk.Duration;
+        description?: string;
+    };
+    single5xxResponseAlarm?: {
+        /**
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * An action to use for CloudWatch alarm state changes instead of the default action
+         */
+        action?: cloudwatch.IAlarmAction;
+        /**
+         * @default 60 seconds
+         */
+        period?: cdk.Duration;
+        /**
+         * @default 1
+         */
+        evaluationPeriods?: number;
+        /**
+         * @default 1
+         */
+        threshold?: number;
+        description?: string;
+    };
+};
 export interface FargateServiceProps {
     serviceName: string;
     vpc: ec2.IVpc;
@@ -66,6 +163,18 @@ export interface FargateServiceProps {
      * @default false
      */
     enableCircuitBreaker?: boolean;
+    /**
+     *  Either
+     *  - `{ enabled: false }` to disable all alarms.
+     *  - object with required `alarmAction`, `warningAction`, and `loadBalancerFullName`.
+     *
+     *  When enabled, the construct will:
+     *  - (By default) add a log-based JSON error alarm (enabled by default).
+     *  - (By default) add target-group related alarms (target health, 5xx responses, response time)
+     *  when a target group is present.
+     *  - (Opt-in) optionally enable the uncaught Java exception alarm
+     */
+    alarms: ServiceAlarmsConfig;
 }
 export declare class FargateService extends constructs.Construct {
     readonly fargateService: ecs.FargateService;
@@ -73,5 +182,6 @@ export declare class FargateService extends constructs.Construct {
     readonly taskDefinition: ecs.TaskDefinition;
     readonly targetGroup: elb.ApplicationTargetGroup | undefined;
     readonly logGroup: logs.LogGroup;
+    readonly serviceAlarms: ServiceAlarms | undefined;
     constructor(scope: constructs.Construct, id: string, props: FargateServiceProps);
 }

package/lib/ecs/fargate-service.js

@@ -5,6 +5,7 @@ import * as ecs from "aws-cdk-lib/aws-ecs";
 import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import * as logs from "aws-cdk-lib/aws-logs";
 import * as constructs from "constructs";
+import { ServiceAlarms } from "../alarms";
 import { ConfigureParameters } from "../configure-parameters";
 export class FargateService extends constructs.Construct {
     fargateService;
@@ -12,6 +13,7 @@ export class FargateService extends constructs.Construct {
     taskDefinition;
     targetGroup;
     logGroup;
+    serviceAlarms;
     constructor(scope, id, props) {
         super(scope, id);
         /**
@@ -37,7 +39,7 @@ export class FargateService extends constructs.Construct {
         });
         parameters.grantRead(this.taskDefinition.taskRole);
         const port = props.containerPort ?? 8080;
-        const container = this.taskDefinition.addContainer("Container", {
+        this.taskDefinition.addContainer("Container", {
             logging: ecs.LogDriver.awsLogs({
                 logGroup: this.logGroup,
                 streamPrefix: "ecs",
@@ -111,6 +113,48 @@ export class FargateService extends constructs.Construct {
                 ...props.overrideHealthCheck,
             });
         }
+        // Require explicit alarmAction and warningAction when enabled.
+        if (props.alarms && "alarmAction" in props.alarms) {
+            const alarms = props.alarms;
+            this.serviceAlarms = new ServiceAlarms(this, "Alarms", {
+                serviceName: props.serviceName,
+                alarmAction: alarms.alarmAction,
+                warningAction: alarms.warningAction,
+                logHandler: alarms.logHandler,
+            });
+            // Enabled by default (opt-out).
+            const jsonErrorOverrides = alarms.jsonErrorAlarm;
+            if (jsonErrorOverrides?.enabled ?? true) {
+                this.serviceAlarms.addJsonErrorAlarm({
+                    logGroup: this.logGroup,
+                    alarmDescription: jsonErrorOverrides?.alarmDescription,
+                    enableOkAlarm: jsonErrorOverrides?.enableOkAlarm,
+                    action: jsonErrorOverrides?.action,
+                });
+            }
+            // Not enabled by default (opt-in).
+            const javaExceptionOverrides = alarms.uncaughtJavaExceptionAlarm;
+            if (javaExceptionOverrides?.enabled) {
+                this.serviceAlarms.addUncaughtJavaExceptionAlarm({
+                    logGroup: this.logGroup,
+                    alarmDescription: javaExceptionOverrides.alarmDescription,
+                    enableOkAlarm: javaExceptionOverrides.enableOkAlarm,
+                    action: javaExceptionOverrides.action,
+                    enabled: true,
+                });
+            }
+            if (!props.skipTargetGroup) {
+                // All alarms enabled by-default (opt-out individually)
+                this.serviceAlarms.addTargetGroupAlarms({
+                    targetGroupFullName: this.targetGroup.targetGroupFullName,
+                    loadBalancerFullName: alarms.loadBalancerFullName,
+                    targetHealthAlarm: alarms.targetHealthAlarm,
+                    single5xxResponseAlarm: alarms.single5xxResponseAlarm,
+                    tooMany5xxResponsesFromTargetsAlarm: alarms.tooMany5xxResponsesFromTargetsAlarm,
+                    targetResponseTimeAlarm: alarms.targetResponseTimeAlarm,
+                });
+            }
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-service.js","sourceRoot":"","sources":["../../src/ecs/fargate-service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport { Duration } from \"aws-cdk-lib\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport type { CfnService } from \"aws-cdk-lib/aws-ecs\"\nimport * as ecs from \"aws-cdk-lib/aws-ecs\"\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as constructs from \"constructs\"\nimport { ConfigureParameters } from \"../configure-parameters\"\nimport type { Parameter } from \"../configure-parameters/configure-parameters\"\n\nexport interface FargateServiceProps {\n  serviceName: string\n  vpc: ec2.IVpc\n  cluster: ecs.ICluster\n  desiredCount: number\n  ecsImage: ecs.ContainerImage\n  portMappings?: ecs.PortMapping[]\n  containerHealthCheck?: ecs.HealthCheck\n  /**\n   * @default 256\n   */\n  cpu?: number\n  /**\n   * @default undefined\n   */\n  runtimePlatform?: ecs.RuntimePlatform\n  /**\n   * @default 512\n   */\n  memoryLimitMiB?: number\n  /**\n   * @default 2 weeks\n   */\n  logsRetention?: logs.RetentionDays\n  /**\n   * @default AwsLogDriverMode.BLOCKING\n   */\n  logDriverMode?: ecs.AwsLogDriverMode\n  /**\n   * @default 15 seconds\n   */\n  deregistrationDelay?: cdk.Duration\n  /**\n   * @default 8080\n   */\n  containerPort?: number\n  /**\n   * @default 60 seconds\n   */\n  healthCheckGracePeriod?: cdk.Duration\n  /**\n   * Use this as workaround when adding the service to a load balancer after\n   * it has been created. For avoiding 'Health check grace period is only valid for services configured to use load balancers'\n   * Link to GitHub issue: https://github.com/aws/aws-cdk/issues/19842\n   */\n  skipHealthCheckGracePeriod?: boolean\n  parameters?: Parameter[]\n  overrideFargateServiceProps?: Partial<ecs.FargateServiceProps>\n  overrideHealthCheck?: Partial<elb.HealthCheck>\n  overrideTargetGroupProps?: Partial<elb.ApplicationTargetGroupProps>\n  overrideContainerProps?: Partial<ecs.ContainerDefinitionOptions>\n  secrets?: Record<string, ecs.Secret>\n  environment?: Record<string, string>\n  /**\n   * @default false\n   */\n  skipTargetGroup?: boolean\n  /**\n   * @default false\n   */\n  enableCircuitBreaker?: boolean\n}\n\nexport class FargateService extends constructs.Construct {\n  public readonly fargateService: ecs.FargateService\n  public readonly securityGroup: ec2.SecurityGroup\n  public readonly taskDefinition: ecs.TaskDefinition\n  public readonly targetGroup: elb.ApplicationTargetGroup | undefined\n  public readonly logGroup: logs.LogGroup\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: FargateServiceProps,\n  ) {\n    super(scope, id)\n\n    /**\n     * Set this flag to disable this stack creating a completely new service and attempting replace when enabling circuit breakers\n     * Mitigating the deployment error: 'a service with the name <...> already exists'\n     * See: github.com/aws/aws-cdk/pull/22467\n     */\n    this.node.setContext(\n      \"@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker\",\n      true,\n    )\n\n    const parameters = new ConfigureParameters(this, {\n      ssmPrefix: `/liflig-cdk/${cdk.Stack.of(this).stackName}/${\n        this.node.addr\n      }/parameters`,\n      parameters: props.parameters ?? [],\n    })\n\n    this.logGroup = new logs.LogGroup(this, \"LogGroup\", {\n      retention: props.logsRetention ?? logs.RetentionDays.TWO_WEEKS,\n    })\n\n    this.securityGroup = new ec2.SecurityGroup(this, \"SecurityGroup\", {\n      vpc: props.vpc,\n    })\n\n    this.taskDefinition = new ecs.FargateTaskDefinition(\n      this,\n      \"TaskDefinition\",\n      {\n        cpu: props.cpu ?? 256,\n        memoryLimitMiB: props.memoryLimitMiB ?? 512,\n        runtimePlatform: props.runtimePlatform,\n      },\n    )\n\n    parameters.grantRead(this.taskDefinition.taskRole)\n\n    const port = props.containerPort ?? 8080\n    const container = this.taskDefinition.addContainer(\"Container\", {\n      logging: ecs.LogDriver.awsLogs({\n        logGroup: this.logGroup,\n        streamPrefix: \"ecs\",\n        datetimeFormat: \"%Y-%m-%dT%H:%M:%S\",\n        mode: props.logDriverMode ?? ecs.AwsLogDriverMode.BLOCKING,\n      }),\n      image: props.ecsImage,\n      secrets: props.secrets,\n      healthCheck: props.containerHealthCheck,\n      portMappings: props.portMappings ?? [\n        {\n          containerPort: port,\n          hostPort: port,\n        },\n      ],\n      environment: {\n        SSM_PREFIX: parameters.ssmPrefix,\n        // Not read by the application, only used to help with redeployments.\n        PARAMS_HASH: parameters.hashValue,\n        ...(props.environment ?? {}),\n      },\n      linuxParameters: new ecs.LinuxParameters(this, \"LinuxParameters\", {\n        initProcessEnabled: true,\n      }),\n      ...props.overrideContainerProps,\n    })\n\n    const enableCircuitBreaker = props.enableCircuitBreaker ?? false\n\n    this.fargateService = new ecs.FargateService(this, \"Service\", {\n      serviceName: props.serviceName,\n      vpcSubnets: {\n        subnetType: ec2.SubnetType.PUBLIC,\n      },\n      taskDefinition: this.taskDefinition,\n      cluster: props.cluster,\n      minHealthyPercent: 100,\n      healthCheckGracePeriod: props.healthCheckGracePeriod,\n      desiredCount: props.desiredCount,\n      assignPublicIp: true,\n      securityGroups: [this.securityGroup],\n      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,\n      enableExecuteCommand: true,\n      circuitBreaker: enableCircuitBreaker\n        ? {\n            enable: true,\n            rollback: true,\n          }\n        : undefined,\n      ...props.overrideFargateServiceProps,\n    })\n\n    if (props.skipHealthCheckGracePeriod) {\n      ;(\n        this.fargateService.node.defaultChild as CfnService\n      ).healthCheckGracePeriodSeconds = undefined\n    }\n\n    for (const param of parameters.parameters) {\n      this.fargateService.node.addDependency(param)\n    }\n\n    if (!props.skipTargetGroup) {\n      this.targetGroup = new elb.ApplicationTargetGroup(this, \"TargetGroup\", {\n        protocol: elb.ApplicationProtocol.HTTP,\n        port: port,\n        vpc: props.vpc,\n        targetType: elb.TargetType.IP,\n        targets: [this.fargateService],\n        deregistrationDelay:\n          props.deregistrationDelay ?? cdk.Duration.seconds(15),\n        ...props.overrideTargetGroupProps,\n      })\n\n      this.targetGroup.configureHealthCheck({\n        interval: Duration.seconds(10),\n        path: \"/health\",\n        healthyThresholdCount: 2,\n        ...props.overrideHealthCheck,\n      })\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-service.js","sourceRoot":"","sources":["../../src/ecs/fargate-service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport { Duration } from \"aws-cdk-lib\"\nimport type * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport type { CfnService } from \"aws-cdk-lib/aws-ecs\"\nimport * as ecs from \"aws-cdk-lib/aws-ecs\"\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\"\nimport type * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as constructs from \"constructs\"\nimport { ServiceAlarms } from \"../alarms\"\nimport type { Parameter } from \"../configure-parameters\"\nimport { ConfigureParameters } from \"../configure-parameters\"\n\n/**\n * Configure service alarms.\n *\n * Alarms are enabled by default when a config object with `alarmAction` and\n * `warningAction` is provided. To explicitly disable automatic alarms use\n * `{ enabled: false }`.\n */\nexport type ServiceAlarmsConfig =\n  | { enabled: false }\n  | {\n      alarmAction: cloudwatch.IAlarmAction\n      warningAction: cloudwatch.IAlarmAction\n      loadBalancerFullName: string\n      /** Optional Lambda function that will receive\n       * forwarded log events */\n      logHandler?: lambda.IFunction\n      /**\n       * Individual alarm configuration overrides defaults.\n       */\n      jsonErrorAlarm?: {\n        /**\n         * @default true\n         */\n        enabled?: boolean\n        alarmDescription?: string\n        enableOkAlarm?: boolean\n        action?: cloudwatch.IAlarmAction\n      }\n      uncaughtJavaExceptionAlarm?: {\n        /**\n         * @default false\n         */\n        enabled?: boolean\n        alarmDescription?: string\n        enableOkAlarm?: boolean\n        action?: cloudwatch.IAlarmAction\n      }\n      targetHealthAlarm?: {\n        /**\n         * @default true\n         */\n        enabled?: boolean\n        action?: cloudwatch.IAlarmAction\n        period?: cdk.Duration\n        evaluationPeriods?: number\n        threshold?: number\n        description?: string\n      }\n      tooMany5xxResponsesFromTargetsAlarm?: {\n        /**\n         * @default true\n         */\n        enabled?: boolean\n        action?: cloudwatch.IAlarmAction\n        period?: cdk.Duration\n        evaluationPeriods?: number\n        threshold?: number\n        description?: string\n      }\n      targetResponseTimeAlarm?: {\n        /**\n         * @default true\n         */\n        enabled?: boolean\n        action?: cloudwatch.IAlarmAction\n        period?: cdk.Duration\n        evaluationPeriods?: number\n        threshold?: cdk.Duration\n        description?: string\n      }\n      single5xxResponseAlarm?: {\n        /**\n         * @default true\n         */\n        enabled?: boolean\n        /**\n         * An action to use for CloudWatch alarm state changes instead of the default action\n         */\n        action?: cloudwatch.IAlarmAction\n        /**\n         * @default 60 seconds\n         */\n        period?: cdk.Duration\n        /**\n         * @default 1\n         */\n        evaluationPeriods?: number\n        /**\n         * @default 1\n         */\n        threshold?: number\n        description?: string\n      }\n    }\n\nexport interface FargateServiceProps {\n  serviceName: string\n  vpc: ec2.IVpc\n  cluster: ecs.ICluster\n  desiredCount: number\n  ecsImage: ecs.ContainerImage\n  portMappings?: ecs.PortMapping[]\n  containerHealthCheck?: ecs.HealthCheck\n  /**\n   * @default 256\n   */\n  cpu?: number\n  /**\n   * @default undefined\n   */\n  runtimePlatform?: ecs.RuntimePlatform\n  /**\n   * @default 512\n   */\n  memoryLimitMiB?: number\n  /**\n   * @default 2 weeks\n   */\n  logsRetention?: logs.RetentionDays\n  /**\n   * @default AwsLogDriverMode.BLOCKING\n   */\n  logDriverMode?: ecs.AwsLogDriverMode\n  /**\n   * @default 15 seconds\n   */\n  deregistrationDelay?: cdk.Duration\n  /**\n   * @default 8080\n   */\n  containerPort?: number\n  /**\n   * @default 60 seconds\n   */\n  healthCheckGracePeriod?: cdk.Duration\n  /**\n   * Use this as workaround when adding the service to a load balancer after\n   * it has been created. For avoiding 'Health check grace period is only valid for services configured to use load balancers'\n   * Link to GitHub issue: https://github.com/aws/aws-cdk/issues/19842\n   */\n  skipHealthCheckGracePeriod?: boolean\n  parameters?: Parameter[]\n  overrideFargateServiceProps?: Partial<ecs.FargateServiceProps>\n  overrideHealthCheck?: Partial<elb.HealthCheck>\n  overrideTargetGroupProps?: Partial<elb.ApplicationTargetGroupProps>\n  overrideContainerProps?: Partial<ecs.ContainerDefinitionOptions>\n  secrets?: Record<string, ecs.Secret>\n  environment?: Record<string, string>\n  /**\n   * @default false\n   */\n  skipTargetGroup?: boolean\n  /**\n   * @default false\n   */\n  enableCircuitBreaker?: boolean\n  /**\n   *  Either\n   *  - `{ enabled: false }` to disable all alarms.\n   *  - object with required `alarmAction`, `warningAction`, and `loadBalancerFullName`.\n   *\n   *  When enabled, the construct will:\n   *  - (By default) add a log-based JSON error alarm (enabled by default).\n   *  - (By default) add target-group related alarms (target health, 5xx responses, response time)\n   *  when a target group is present.\n   *  - (Opt-in) optionally enable the uncaught Java exception alarm\n   */\n  alarms: ServiceAlarmsConfig\n}\n\nexport class FargateService extends constructs.Construct {\n  public readonly fargateService: ecs.FargateService\n  public readonly securityGroup: ec2.SecurityGroup\n  public readonly taskDefinition: ecs.TaskDefinition\n  public readonly targetGroup: elb.ApplicationTargetGroup | undefined\n  public readonly logGroup: logs.LogGroup\n  public readonly serviceAlarms: ServiceAlarms | undefined\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: FargateServiceProps,\n  ) {\n    super(scope, id)\n\n    /**\n     * Set this flag to disable this stack creating a completely new service and attempting replace when enabling circuit breakers\n     * Mitigating the deployment error: 'a service with the name <...> already exists'\n     * See: github.com/aws/aws-cdk/pull/22467\n     */\n    this.node.setContext(\n      \"@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker\",\n      true,\n    )\n\n    const parameters = new ConfigureParameters(this, {\n      ssmPrefix: `/liflig-cdk/${cdk.Stack.of(this).stackName}/${\n        this.node.addr\n      }/parameters`,\n      parameters: props.parameters ?? [],\n    })\n\n    this.logGroup = new logs.LogGroup(this, \"LogGroup\", {\n      retention: props.logsRetention ?? logs.RetentionDays.TWO_WEEKS,\n    })\n\n    this.securityGroup = new ec2.SecurityGroup(this, \"SecurityGroup\", {\n      vpc: props.vpc,\n    })\n\n    this.taskDefinition = new ecs.FargateTaskDefinition(\n      this,\n      \"TaskDefinition\",\n      {\n        cpu: props.cpu ?? 256,\n        memoryLimitMiB: props.memoryLimitMiB ?? 512,\n        runtimePlatform: props.runtimePlatform,\n      },\n    )\n\n    parameters.grantRead(this.taskDefinition.taskRole)\n\n    const port = props.containerPort ?? 8080\n    this.taskDefinition.addContainer(\"Container\", {\n      logging: ecs.LogDriver.awsLogs({\n        logGroup: this.logGroup,\n        streamPrefix: \"ecs\",\n        datetimeFormat: \"%Y-%m-%dT%H:%M:%S\",\n        mode: props.logDriverMode ?? ecs.AwsLogDriverMode.BLOCKING,\n      }),\n      image: props.ecsImage,\n      secrets: props.secrets,\n      healthCheck: props.containerHealthCheck,\n      portMappings: props.portMappings ?? [\n        {\n          containerPort: port,\n          hostPort: port,\n        },\n      ],\n      environment: {\n        SSM_PREFIX: parameters.ssmPrefix,\n        // Not read by the application, only used to help with redeployments.\n        PARAMS_HASH: parameters.hashValue,\n        ...(props.environment ?? {}),\n      },\n      linuxParameters: new ecs.LinuxParameters(this, \"LinuxParameters\", {\n        initProcessEnabled: true,\n      }),\n      ...props.overrideContainerProps,\n    })\n\n    const enableCircuitBreaker = props.enableCircuitBreaker ?? false\n\n    this.fargateService = new ecs.FargateService(this, \"Service\", {\n      serviceName: props.serviceName,\n      vpcSubnets: {\n        subnetType: ec2.SubnetType.PUBLIC,\n      },\n      taskDefinition: this.taskDefinition,\n      cluster: props.cluster,\n      minHealthyPercent: 100,\n      healthCheckGracePeriod: props.healthCheckGracePeriod,\n      desiredCount: props.desiredCount,\n      assignPublicIp: true,\n      securityGroups: [this.securityGroup],\n      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,\n      enableExecuteCommand: true,\n      circuitBreaker: enableCircuitBreaker\n        ? {\n            enable: true,\n            rollback: true,\n          }\n        : undefined,\n      ...props.overrideFargateServiceProps,\n    })\n\n    if (props.skipHealthCheckGracePeriod) {\n      ;(\n        this.fargateService.node.defaultChild as CfnService\n      ).healthCheckGracePeriodSeconds = undefined\n    }\n\n    for (const param of parameters.parameters) {\n      this.fargateService.node.addDependency(param)\n    }\n\n    if (!props.skipTargetGroup) {\n      this.targetGroup = new elb.ApplicationTargetGroup(this, \"TargetGroup\", {\n        protocol: elb.ApplicationProtocol.HTTP,\n        port: port,\n        vpc: props.vpc,\n        targetType: elb.TargetType.IP,\n        targets: [this.fargateService],\n        deregistrationDelay:\n          props.deregistrationDelay ?? cdk.Duration.seconds(15),\n        ...props.overrideTargetGroupProps,\n      })\n\n      this.targetGroup.configureHealthCheck({\n        interval: Duration.seconds(10),\n        path: \"/health\",\n        healthyThresholdCount: 2,\n        ...props.overrideHealthCheck,\n      })\n    }\n\n    // Require explicit alarmAction and warningAction when enabled.\n    if (props.alarms && \"alarmAction\" in props.alarms) {\n      const alarms = props.alarms\n\n      this.serviceAlarms = new ServiceAlarms(this, \"Alarms\", {\n        serviceName: props.serviceName,\n        alarmAction: alarms.alarmAction,\n        warningAction: alarms.warningAction,\n        logHandler: alarms.logHandler,\n      })\n\n      // Enabled by default (opt-out).\n      const jsonErrorOverrides = alarms.jsonErrorAlarm\n      if (jsonErrorOverrides?.enabled ?? true) {\n        this.serviceAlarms.addJsonErrorAlarm({\n          logGroup: this.logGroup,\n          alarmDescription: jsonErrorOverrides?.alarmDescription,\n          enableOkAlarm: jsonErrorOverrides?.enableOkAlarm,\n          action: jsonErrorOverrides?.action,\n        })\n      }\n\n      // Not enabled by default (opt-in).\n      const javaExceptionOverrides = alarms.uncaughtJavaExceptionAlarm\n      if (javaExceptionOverrides?.enabled) {\n        this.serviceAlarms.addUncaughtJavaExceptionAlarm({\n          logGroup: this.logGroup,\n          alarmDescription: javaExceptionOverrides.alarmDescription,\n          enableOkAlarm: javaExceptionOverrides.enableOkAlarm,\n          action: javaExceptionOverrides.action,\n          enabled: true,\n        })\n      }\n\n      if (!props.skipTargetGroup) {\n        // All alarms enabled by-default (opt-out individually)\n        this.serviceAlarms.addTargetGroupAlarms({\n          targetGroupFullName: this.targetGroup!.targetGroupFullName,\n          loadBalancerFullName: alarms.loadBalancerFullName,\n          targetHealthAlarm: alarms.targetHealthAlarm,\n          single5xxResponseAlarm: alarms.single5xxResponseAlarm,\n          tooMany5xxResponsesFromTargetsAlarm:\n            alarms.tooMany5xxResponsesFromTargetsAlarm,\n          targetResponseTimeAlarm: alarms.targetResponseTimeAlarm,\n        })\n      }\n    }\n  }\n}\n"]}

package/lib/load-balancer/load-balancer.js

@@ -38,7 +38,7 @@ export class LoadBalancer extends constructs.Construct {
             targetType: elb.TargetType.INSTANCE,
         });
         this.httpsListener = this.loadBalancer.addListener("HttpsListener", {
-            sslPolicy: elb.SslPolicy.TLS12,
+            sslPolicy: elb.SslPolicy.RECOMMENDED_TLS,
             protocol: elb.ApplicationProtocol.HTTPS,
             port: 443,
             certificates: props.certificates,
@@ -57,4 +57,4 @@ export class LoadBalancer extends constructs.Construct {
         this.loadBalancer.logAccessLogs(this.accessLogsBucket);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/rds/database.d.ts

@@ -1,8 +1,81 @@
 import * as cdk from "aws-cdk-lib";
+import type * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import * as ec2 from "aws-cdk-lib/aws-ec2";
 import * as rds from "aws-cdk-lib/aws-rds";
 import type * as sm from "aws-cdk-lib/aws-secretsmanager";
 import * as constructs from "constructs";
+/**
+ * Configure database alarms.
+ *
+ * Alarms are enabled by default (when you supply an `alarmAction` and
+ * `warningAction`). To explicitly disable automatic alarms use
+ * `{ enabled: false }`.
+ */
+export type DatabaseAlarmsConfig = {
+    enabled: false;
+} | {
+    /**
+     * When alarms are enabled, both actions are required.
+     */
+    alarmAction: cloudwatch.IAlarmAction;
+    warningAction: cloudwatch.IAlarmAction;
+    /**
+     * CPU credits alarm config
+     */
+    cpuCreditsAlarm?: {
+        /**
+         * @default true if instance type is burstable
+         */
+        enabled?: boolean;
+        /** Whether to attach OK actions for this alarm. @default true */
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        /** @default 10% of maximum earned credits for instance type */
+        threshold?: number;
+        appendToAlarmDescription?: string;
+    };
+    /**
+     * Storage space alarm overrides
+     */
+    storageSpaceAlarms?: {
+        /**
+         * Set to `false` to disable all storage space alarms (both low and critically low).
+         * @default true
+         */
+        enabled?: boolean;
+        lowStorageSpaceAlarm?: {
+            action?: cloudwatch.IAlarmAction;
+            /** Whether to attach OK actions for this alarm. @default true */
+            enableOkAlarm?: boolean;
+            /** @default 25% of allocated storage */
+            threshold?: cdk.Size;
+        };
+        criticallyLowStorageSpaceAlarm?: {
+            action?: cloudwatch.IAlarmAction;
+            /** Whether to attach OK actions for this alarm. @default true */
+            enableOkAlarm?: boolean;
+            /** @default 5% of allocated storage */
+            threshold?: cdk.Size;
+        };
+        appendToAlarmDescription?: string;
+    };
+    /**
+     * CPU utilization alarm overrides.
+     */
+    cpuUtilizationAlarm?: {
+        enabled?: boolean;
+        /** Whether to attach OK actions for this alarm. @default true */
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        /** @default 80 */
+        threshold?: number;
+        /** @default 5 */
+        evaluationPeriods?: number;
+        /** @default 2 minutes */
+        period?: cdk.Duration;
+        appendToAlarmDescription?: string;
+    };
+};
 export interface DatabaseProps extends cdk.StackProps {
     vpc: ec2.IVpc;
     engine: rds.IInstanceEngine;
@@ -37,6 +110,16 @@ export interface DatabaseProps extends cdk.StackProps {
      */
     usePublicSubnets?: boolean;
     overrideDbOptions?: Partial<rds.DatabaseInstanceSourceProps>;
+    /**
+     * Configure database alarms.
+     *
+     * This property is required and must be one of two shapes:
+     *  - `{ enabled: false }` to explicitly disable automatic alarms
+     *  - `{ alarmAction, warningAction }` to enable alarms and provide both channels
+     *
+     * Default: enabled.
+     */
+    alarms: DatabaseAlarmsConfig;
 }
 export declare class Database extends constructs.Construct {
     readonly secret: sm.ISecret;