@liflig/cdk 3.22.19 → 3.23.0

package/lib/alarms/queue-alarms.js

@@ -0,0 +1,109 @@
+import * as cdk from "aws-cdk-lib";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import * as constructs from "constructs";
+/**
+ * This construct provides a thin wrapper that creates two alarms for
+ * SQS queues.
+ *
+ * Unlike RDS and ECS alarm constructs in this package, `QueueAlarms` is
+ * set up manually by consumers (it doesn't auto-wire to resources).
+ *
+ * Defaults:
+ *  - Messages-not-being-processed alarm -> sent to `alarmAction` by default
+ *  - Approximate-age alarm -> sent to `warningAction` by default
+ */
+export class QueueAlarms extends constructs.Construct {
+    alarmAction;
+    warningAction;
+    queueName;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.alarmAction = props.alarmAction;
+        this.warningAction = props.warningAction;
+        this.queueName = props.queueName;
+    }
+    /**
+     * Sets up a CloudWatch Composite Alarm that triggers if messages are not being deleted
+     * from queue, and there are visible messages on the queue.
+     */
+    addMessagesNotBeingProcessedAlarm(props) {
+        const period = props?.period ?? cdk.Duration.seconds(300);
+        const evaluationPeriodsMessagesVisible = props?.evaluationPeriodsMessagesVisible ?? 2;
+        const thresholdMessagesVisible = props?.thresholdMessagesVisible ?? 1;
+        const evaluationPeriodsMessagesDeleted = props?.evaluationPeriodsMessagesDeleted ?? 4;
+        const thresholdMessagesDeleted = props?.thresholdMessagesDeleted ?? 0;
+        const messagesVisibleAlarm = new cloudwatch.Metric({
+            metricName: "ApproximateNumberOfMessagesVisible",
+            namespace: "AWS/SQS",
+            statistic: "Minimum",
+            period,
+            dimensionsMap: {
+                QueueName: this.queueName,
+            },
+        }).createAlarm(this, "MessagesVisibleAlarm", {
+            alarmDescription: "Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).",
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            evaluationPeriods: evaluationPeriodsMessagesVisible,
+            threshold: thresholdMessagesVisible,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        const messagesNotBeingDeletedAlarm = new cloudwatch.Metric({
+            metricName: "NumberOfMessagesDeleted",
+            namespace: "AWS/SQS",
+            statistic: "Sum",
+            period,
+            dimensionsMap: {
+                QueueName: this.queueName,
+            },
+        }).createAlarm(this, "MessagesNotBeingDeleted", {
+            alarmDescription: "Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).",
+            comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,
+            evaluationPeriods: evaluationPeriodsMessagesDeleted,
+            threshold: thresholdMessagesDeleted,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        const messagesNotBeingProcessedAlarm = new cloudwatch.CompositeAlarm(this, "MessagesNotBeingProcessedAlarm", {
+            alarmRule: cloudwatch.AlarmRule.allOf(messagesVisibleAlarm, messagesNotBeingDeletedAlarm),
+            actionsEnabled: true,
+            alarmDescription: "Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).",
+        });
+        // Sent to alarm channel by default
+        const action = props?.action ?? this.alarmAction;
+        messagesNotBeingProcessedAlarm.addAlarmAction(action);
+        if (props?.enableOkAlarm ?? true) {
+            messagesNotBeingProcessedAlarm.addOkAction(action);
+        }
+    }
+    /**
+     * Alerts when the ApproximateAgeOfOldestMessage metric is high.
+     */
+    addApproximateAgeOfOldestMessageAlarm(props) {
+        const period = props?.period ?? cdk.Duration.seconds(900);
+        const evaluationPeriods = props?.evaluationPeriods ?? 2;
+        const threshold = props?.thresholdSeconds ?? 900;
+        const ageMetric = new cloudwatch.Metric({
+            metricName: "ApproximateAgeOfOldestMessage",
+            namespace: "AWS/SQS",
+            statistic: "Maximum",
+            period,
+            dimensionsMap: {
+                QueueName: this.queueName,
+            },
+        });
+        const ageAlarm = ageMetric.createAlarm(this, "ApproximateAgeOfOldestMessageAlarm", {
+            alarmDescription: props?.alarmDescription ??
+                `${this.queueName} has an oldest message older than ${threshold} seconds`,
+            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            evaluationPeriods,
+            threshold,
+            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+        });
+        // Sent to warnings channel by default
+        const action = props?.action ?? this.warningAction;
+        ageAlarm.addAlarmAction(action);
+        if (props?.enableOkAlarm ?? true) {
+            ageAlarm.addOkAction(action);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue-alarms.js","sourceRoot":"","sources":["../../src/alarms/queue-alarms.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport type { IAlarmAction } from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as constructs from \"constructs\"\n\nexport interface QueueAlarmsProps {\n  // Action to use for high-severity alarms\n  alarmAction: cloudwatch.IAlarmAction\n  // Action to use for warnings\n  warningAction: cloudwatch.IAlarmAction\n  queueName: string\n}\n\n/**\n * This construct provides a thin wrapper that creates two alarms for\n * SQS queues.\n *\n * Unlike RDS and ECS alarm constructs in this package, `QueueAlarms` is\n * set up manually by consumers (it doesn't auto-wire to resources).\n *\n * Defaults:\n *  - Messages-not-being-processed alarm -> sent to `alarmAction` by default\n *  - Approximate-age alarm -> sent to `warningAction` by default\n */\nexport class QueueAlarms extends constructs.Construct {\n  private readonly alarmAction: cloudwatch.IAlarmAction\n  private readonly warningAction: cloudwatch.IAlarmAction\n  private readonly queueName: string\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: QueueAlarmsProps,\n  ) {\n    super(scope, id)\n\n    this.alarmAction = props.alarmAction\n    this.warningAction = props.warningAction\n    this.queueName = props.queueName\n  }\n  /**\n   * Sets up a CloudWatch Composite Alarm that triggers if messages are not being deleted\n   * from queue, and there are visible messages on the queue.\n   */\n  addMessagesNotBeingProcessedAlarm(props?: {\n    /**\n     * Period for metric evaluation as a CDK Duration\n     * @default cdk.Duration.seconds(300)\n     */\n    period?: cdk.Duration\n    /**\n     * Evaluation periods for MessagesVisible metric\n     * @default 2\n     */\n    evaluationPeriodsMessagesVisible?: number\n    /**\n     * Threshold for MessagesVisible metric (minimum)\n     * @default 1\n     */\n    thresholdMessagesVisible?: number\n    /**\n     * Evaluation periods for NumberOfMessagesDeleted metric\n     * @default 4\n     */\n    evaluationPeriodsMessagesDeleted?: number\n    /**\n     * Threshold for NumberOfMessagesDeleted (sum)\n     * @default 0\n     */\n    thresholdMessagesDeleted?: number\n    /**\n     * @default true\n     */\n    enableOkAlarm?: boolean\n    /** Per-alarm override of the action to use instead of the construct alarmAction */\n    action?: IAlarmAction\n  }): void {\n    const period = props?.period ?? cdk.Duration.seconds(300)\n    const evaluationPeriodsMessagesVisible =\n      props?.evaluationPeriodsMessagesVisible ?? 2\n    const thresholdMessagesVisible = props?.thresholdMessagesVisible ?? 1\n    const evaluationPeriodsMessagesDeleted =\n      props?.evaluationPeriodsMessagesDeleted ?? 4\n    const thresholdMessagesDeleted = props?.thresholdMessagesDeleted ?? 0\n\n    const messagesVisibleAlarm = new cloudwatch.Metric({\n      metricName: \"ApproximateNumberOfMessagesVisible\",\n      namespace: \"AWS/SQS\",\n      statistic: \"Minimum\",\n      period,\n      dimensionsMap: {\n        QueueName: this.queueName,\n      },\n    }).createAlarm(this, \"MessagesVisibleAlarm\", {\n      alarmDescription:\n        \"Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).\",\n      comparisonOperator:\n        cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n      evaluationPeriods: evaluationPeriodsMessagesVisible,\n      threshold: thresholdMessagesVisible,\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n\n    const messagesNotBeingDeletedAlarm = new cloudwatch.Metric({\n      metricName: \"NumberOfMessagesDeleted\",\n      namespace: \"AWS/SQS\",\n      statistic: \"Sum\",\n      period,\n      dimensionsMap: {\n        QueueName: this.queueName,\n      },\n    }).createAlarm(this, \"MessagesNotBeingDeleted\", {\n      alarmDescription:\n        \"Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).\",\n      comparisonOperator:\n        cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,\n      evaluationPeriods: evaluationPeriodsMessagesDeleted,\n      threshold: thresholdMessagesDeleted,\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n\n    const messagesNotBeingProcessedAlarm = new cloudwatch.CompositeAlarm(\n      this,\n      \"MessagesNotBeingProcessedAlarm\",\n      {\n        alarmRule: cloudwatch.AlarmRule.allOf(\n          messagesVisibleAlarm,\n          messagesNotBeingDeletedAlarm,\n        ),\n        actionsEnabled: true,\n        alarmDescription:\n          \"Service might be unavailable! It has available messages on the SQS queue, but these messages are not being deleted (processed).\",\n      },\n    )\n\n    // Sent to alarm channel by default\n    const action = props?.action ?? this.alarmAction\n    messagesNotBeingProcessedAlarm.addAlarmAction(action)\n    if (props?.enableOkAlarm ?? true) {\n      messagesNotBeingProcessedAlarm.addOkAction(action)\n    }\n  }\n\n  /**\n   * Alerts when the ApproximateAgeOfOldestMessage metric is high.\n   */\n  addApproximateAgeOfOldestMessageAlarm(props?: {\n    alarmDescription?: string\n    /**\n     * @default cdk.Duration.seconds(900) (15 minutes)\n     */\n    period?: cdk.Duration\n    /**\n     * @default 2\n     */\n    evaluationPeriods?: number\n    /**\n     * Threshold in seconds for the age of the oldest message\n     * @default 900 seconds (15 minutes)\n     */\n    thresholdSeconds?: number\n    /**\n     * @default true\n     */\n    enableOkAlarm?: boolean\n    /** An action to use for CloudWatch alarm state changes instead of the default warningAction */\n    action?: IAlarmAction\n  }): void {\n    const period = props?.period ?? cdk.Duration.seconds(900)\n    const evaluationPeriods = props?.evaluationPeriods ?? 2\n    const threshold = props?.thresholdSeconds ?? 900\n\n    const ageMetric = new cloudwatch.Metric({\n      metricName: \"ApproximateAgeOfOldestMessage\",\n      namespace: \"AWS/SQS\",\n      statistic: \"Maximum\",\n      period,\n      dimensionsMap: {\n        QueueName: this.queueName,\n      },\n    })\n\n    const ageAlarm = ageMetric.createAlarm(\n      this,\n      \"ApproximateAgeOfOldestMessageAlarm\",\n      {\n        alarmDescription:\n          props?.alarmDescription ??\n          `${this.queueName} has an oldest message older than ${threshold} seconds`,\n        comparisonOperator:\n          cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods,\n        threshold,\n        treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n      },\n    )\n\n    // Sent to warnings channel by default\n    const action = props?.action ?? this.warningAction\n    ageAlarm.addAlarmAction(action)\n    if (props?.enableOkAlarm ?? true) {\n      ageAlarm.addOkAction(action)\n    }\n  }\n}\n"]}

package/lib/alarms/service-alarms.d.ts

@@ -1,16 +1,26 @@
 import * as cdk from "aws-cdk-lib";
 import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import type * as lambda from "aws-cdk-lib/aws-lambda";
 import * as logs from "aws-cdk-lib/aws-logs";
 import * as constructs from "constructs";
 export interface ServiceAlarmsProps extends cdk.StackProps {
     /**
-     * The default action to use for CloudWatch alarm state changes
+     * The CloudWatch Alarm action to use for high-severity alarms.
      */
-    action: cloudwatch.IAlarmAction;
+    alarmAction: cloudwatch.IAlarmAction;
+    /**
+     * The CloudWatch Alarm action to use for warnings.
+     */
+    warningAction: cloudwatch.IAlarmAction;
     /**
      * The name of the ECS service.
      */
     serviceName: string;
+    /**
+     * Optional Lambda function that will receive forwarded log events.
+     * If provided, subscription filters will be created to forward matching logs.
+     */
+    logHandler?: lambda.IFunction;
 }
 /**
  * Various alarms and monitoring.
@@ -21,8 +31,10 @@ export interface ServiceAlarmsProps extends cdk.StackProps {
  * See SlackAlarm construct for SNS Action.
  */
 export declare class ServiceAlarms extends constructs.Construct {
-    private readonly action;
+    private readonly alarmAction;
+    private readonly warningAction;
     private readonly serviceName;
+    private readonly logHandler?;
     constructor(scope: constructs.Construct, id: string, props: ServiceAlarmsProps);
     /**
      * For logs stored as JSON, monitor log entries logged
@@ -35,18 +47,29 @@ export declare class ServiceAlarms extends constructs.Construct {
         /**
          * Set to `false` to stop the alarm from sending OK events.
          * @default true
-         * */
-        enableOkAction?: boolean;
+         */
+        enableOkAlarm?: boolean;
         /**
          * An action to use for CloudWatch alarm state changes instead of the default action
          */
         action?: cloudwatch.IAlarmAction;
     }): void;
+    addUncaughtJavaExceptionAlarm(props: {
+        logGroup: logs.ILogGroup;
+        alarmDescription?: string;
+        /**
+         * @default false
+         */
+        enabled?: boolean;
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
+    }): void;
     /**
-     * Sets up three CloudWatch Alarms for monitoring an ECS service behind a target group:
-     * 1) one that triggers if the target is responding with too many 5xx errors.
+     * Sets up CloudWatch alarms for monitoring an ECS service behind a target group:
+     * 1) one that triggers if the target is responding with too many 5xx errors (aggregate 5xx count).
      * 2) one that triggers if the 95% percentile of response times from the target is too high.
      * 3) one that triggers if there are no healthy targets or if the load balancer fails to connect to targets.
+     * 4) a single5xxResponseAlarm which triggers on a single 5xx response from a target.
      */
     addTargetGroupAlarms(props: {
         /**
@@ -67,6 +90,10 @@ export declare class ServiceAlarms extends constructs.Construct {
              * @default true
              */
             enabled?: boolean;
+            /**
+             * Whether to attach OK actions for this alarm. @default true
+             */
+            enableOkAlarm?: boolean;
             /**
              * An action to use for CloudWatch alarm state changes instead of the default action
              */
@@ -95,6 +122,10 @@ export declare class ServiceAlarms extends constructs.Construct {
              * @default true
              */
             enabled?: boolean;
+            /**
+             * Whether to attach OK actions for this alarm. @default true
+             */
+            enableOkAlarm?: boolean;
             /**
              * An action to use for CloudWatch alarm state changes instead of the default action
              */
@@ -123,6 +154,10 @@ export declare class ServiceAlarms extends constructs.Construct {
              * @default true
              */
             enabled?: boolean;
+            /**
+             * Whether to attach OK actions for this alarm. @default true
+             */
+            enableOkAlarm?: boolean;
             /**
              * An action to use for CloudWatch alarm state changes instead of the default action
              */
@@ -136,10 +171,42 @@ export declare class ServiceAlarms extends constructs.Construct {
              */
             evaluationPeriods?: number;
             /**
-             * @default 500 milliseconds
+             * @default 1s
              */
             threshold?: cdk.Duration;
             description?: string;
         };
+        /**
+         * Configuration for an alarm.
+         *
+         * @default Configured with sane defaults.
+         */
+        single5xxResponseAlarm?: {
+            /**
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * Whether to attach OK actions for this alarm. @default true
+             */
+            enableOkAlarm?: 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;
+        };
     }): void;
 }

package/lib/alarms/service-alarms.js

@@ -1,7 +1,9 @@
 import * as cdk from "aws-cdk-lib";
 import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import * as logs from "aws-cdk-lib/aws-logs";
+import * as logsDestinations from "aws-cdk-lib/aws-logs-destinations";
 import * as constructs from "constructs";
+import { jsonErrorFilterPattern } from "./log-filter-patterns";
 /**
  * Various alarms and monitoring.
  *
@@ -11,12 +13,16 @@ import * as constructs from "constructs";
  * See SlackAlarm construct for SNS Action.
  */
 export class ServiceAlarms extends constructs.Construct {
-    action;
+    alarmAction;
+    warningAction;
     serviceName;
+    logHandler;
     constructor(scope, id, props) {
         super(scope, id);
-        this.action = props.action;
+        this.alarmAction = props.alarmAction;
+        this.warningAction = props.warningAction;
         this.serviceName = props.serviceName;
+        this.logHandler = props.logHandler;
     }
     /**
      * For logs stored as JSON, monitor log entries logged
@@ -24,40 +30,114 @@ export class ServiceAlarms extends constructs.Construct {
      * that causes 500 for logging with liflig-logging.
      */
     addJsonErrorAlarm(props) {
-        const errorMetricFilter = props.logGroup.addMetricFilter("ErrorMetricFilter", {
-            filterPattern: logs.FilterPattern.any(logs.FilterPattern.stringValue("$.level", "=", "ERROR"), 
-            // FATAL covers some applications we run that uses log4j or
-            // other libraries. It is not existent in slf4j.
-            logs.FilterPattern.stringValue("$.level", "=", "FATAL"), logs.FilterPattern.stringValue(
-            // For liflig-logging.
-            "$.requestInfo.status.code", "=", "INTERNAL_SERVER_ERROR")),
-            metricName: "Errors",
-            metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.serviceName}/Errors`,
-        });
-        const errorAlarm = errorMetricFilter
-            .metric()
-            .with({
-            statistic: "Sum",
-            period: cdk.Duration.seconds(60),
-        })
-            .createAlarm(this, "ErrorLogAlarm", {
-            alarmDescription: props.alarmDescription ?? `${this.serviceName} logged an error`,
-            evaluationPeriods: 1,
-            threshold: 1,
-            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
-        });
-        errorAlarm.addAlarmAction(props.action ?? this.action);
-        if (props.enableOkAction ?? true) {
-            errorAlarm.addOkAction(props.action ?? this.action);
+        const groupToUse = props.logGroup;
+        // If no log handler is configured, we create
+        // the simple "ERROR" metric alarm.
+        if (!this.logHandler) {
+            const errorMetricFilter = groupToUse.addMetricFilter("ErrorMetricFilter", {
+                filterPattern: jsonErrorFilterPattern(),
+                metricName: "Errors",
+                metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.serviceName}/Errors`,
+            });
+            const errorAlarm = errorMetricFilter
+                .metric()
+                .with({
+                statistic: "Sum",
+                period: cdk.Duration.seconds(60),
+            })
+                .createAlarm(this, "ErrorLogAlarm", {
+                alarmDescription: props.alarmDescription ?? `${this.serviceName} logged an error`,
+                evaluationPeriods: 1,
+                threshold: 1,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            // Default to the warning action
+            const actionToUse = props.action ?? this.warningAction;
+            errorAlarm.addAlarmAction(actionToUse);
+            if (props.enableOkAlarm ?? true) {
+                errorAlarm.addOkAction(actionToUse);
+            }
+        }
+        if (this.logHandler) {
+            props.logGroup.addSubscriptionFilter("liflig-cdk-log-content-to-slack-error-subscription", {
+                destination: new logsDestinations.LambdaDestination(this.logHandler),
+                filterPattern: jsonErrorFilterPattern(),
+            });
+        }
+    }
+    addUncaughtJavaExceptionAlarm(props) {
+        if (props.enabled) {
+            const filterPattern = logs.FilterPattern.allTerms("Exception in thread");
+            // If no log handler is configured, create a simple metric alarm.
+            if (!this.logHandler) {
+                const errorMetricFilter = props.logGroup.addMetricFilter("UncaughtJavaExceptionFilter", {
+                    filterPattern: filterPattern,
+                    metricName: "UncaughtJavaException",
+                    metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.serviceName}/UncaughtJavaException`,
+                });
+                const errorAlarm = errorMetricFilter
+                    .metric()
+                    .with({
+                    statistic: "Sum",
+                    period: cdk.Duration.seconds(60),
+                })
+                    .createAlarm(this, "UncaughtJavaExceptionLogAlarm", {
+                    alarmDescription: props.alarmDescription ??
+                        `${this.serviceName} logged an uncaught Java exception`,
+                    evaluationPeriods: 1,
+                    threshold: 1,
+                    treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+                });
+                // Default to the warning action
+                const actionToUse = props.action ?? this.warningAction;
+                errorAlarm.addAlarmAction(actionToUse);
+                if (props.enableOkAlarm ?? true) {
+                    errorAlarm.addOkAction(actionToUse);
+                }
+            }
+            // If a log handler is configured, forward matching logs to it.
+            if (this.logHandler) {
+                props.logGroup.addSubscriptionFilter("liflig-cdk-log-content-to-slack-uncaught-exception-subscription", {
+                    destination: new logsDestinations.LambdaDestination(this.logHandler),
+                    filterPattern: filterPattern,
+                });
+            }
         }
     }
     /**
-     * Sets up three CloudWatch Alarms for monitoring an ECS service behind a target group:
-     * 1) one that triggers if the target is responding with too many 5xx errors.
+     * Sets up CloudWatch alarms for monitoring an ECS service behind a target group:
+     * 1) one that triggers if the target is responding with too many 5xx errors (aggregate 5xx count).
      * 2) one that triggers if the 95% percentile of response times from the target is too high.
      * 3) one that triggers if there are no healthy targets or if the load balancer fails to connect to targets.
+     * 4) a single5xxResponseAlarm which triggers on a single 5xx response from a target.
      */
     addTargetGroupAlarms(props) {
+        if (props.single5xxResponseAlarm?.enabled !== false) {
+            const single5xxMetric = new cloudwatch.Metric({
+                metricName: "HTTPCode_Target_5XX_Count",
+                namespace: "AWS/ApplicationELB",
+                statistic: "Sum",
+                period: props.single5xxResponseAlarm?.period ?? cdk.Duration.seconds(60),
+                dimensionsMap: {
+                    TargetGroup: props.targetGroupFullName,
+                    LoadBalancer: props.loadBalancerFullName,
+                },
+            });
+            const single5xxAlarm = single5xxMetric.createAlarm(this, "AlbTargetsSingle5xxAlarm", {
+                actionsEnabled: true,
+                alarmDescription: props.single5xxResponseAlarm?.description ??
+                    `Load balancer received a 5XX response from target(s) in ECS service '${this.serviceName}'.`,
+                evaluationPeriods: props.single5xxResponseAlarm?.evaluationPeriods ?? 1,
+                threshold: props.single5xxResponseAlarm?.threshold ?? 1,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            // Sent to warnings channel by default
+            const single5xxAction = props.single5xxResponseAlarm?.action ?? this.warningAction;
+            single5xxAlarm.addAlarmAction(single5xxAction);
+            if (props.single5xxResponseAlarm?.enableOkAlarm ?? true) {
+                single5xxAlarm.addOkAction(single5xxAction);
+            }
+        }
         const targetConnectionErrorAlarm = new cloudwatch.Metric({
             metricName: "TargetConnectionErrorCount",
             namespace: "AWS/ApplicationELB",
@@ -96,8 +176,12 @@ export class ServiceAlarms extends constructs.Construct {
                 `The load balancer is either receiving bad health checks from or is unable to connect to target(s) in ECS service '${this.serviceName}'`,
         });
         if (props.targetHealthAlarm?.enabled ?? true) {
-            targetHealthAlarm.addAlarmAction(props.targetHealthAlarm?.action ?? this.action);
-            targetHealthAlarm.addOkAction(props.targetHealthAlarm?.action ?? this.action);
+            // Default to the alarm action
+            const thAction = props.targetHealthAlarm?.action ?? this.alarmAction;
+            targetHealthAlarm.addAlarmAction(thAction);
+            if (props.targetHealthAlarm?.enableOkAlarm ?? true) {
+                targetHealthAlarm.addOkAction(thAction);
+            }
         }
         const tooMany5xxResponsesFromTargetsAlarm = new cloudwatch.Metric({
             metricName: "HTTPCode_Target_5XX_Count",
@@ -118,8 +202,12 @@ export class ServiceAlarms extends constructs.Construct {
             treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
         });
         if (props.tooMany5xxResponsesFromTargetsAlarm?.enabled ?? true) {
-            tooMany5xxResponsesFromTargetsAlarm.addAlarmAction(props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.action);
-            tooMany5xxResponsesFromTargetsAlarm.addOkAction(props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.action);
+            // Default to the alarm action
+            const fiveXAction = props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.alarmAction;
+            tooMany5xxResponsesFromTargetsAlarm.addAlarmAction(fiveXAction);
+            if (props.tooMany5xxResponsesFromTargetsAlarm?.enableOkAlarm ?? true) {
+                tooMany5xxResponsesFromTargetsAlarm.addOkAction(fiveXAction);
+            }
         }
         const targetResponseTimeAlarm = new cloudwatch.Metric({
             metricName: "TargetResponseTime",
@@ -132,16 +220,20 @@ export class ServiceAlarms extends constructs.Construct {
             },
         }).createAlarm(this, "TargetResponseTimeAlarm", {
             alarmDescription: props.targetResponseTimeAlarm?.description ??
-                `5% of responses from ECS service '${this.serviceName}' are taking longer than the expected duration of ${(props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.millis(500)).toMilliseconds()} ms.`,
+                `5% of responses from ECS service '${this.serviceName}' are taking longer than the expected duration of ${(props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.seconds(1)).toSeconds({ integral: false })} s.`,
             comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
             evaluationPeriods: props.targetResponseTimeAlarm?.evaluationPeriods ?? 1,
-            threshold: (props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.millis(500)).toSeconds({ integral: false }),
+            threshold: (props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.seconds(1)).toSeconds({ integral: false }),
             treatMissingData: cloudwatch.TreatMissingData.IGNORE,
         });
         if (props.targetResponseTimeAlarm?.enabled ?? true) {
-            targetResponseTimeAlarm.addAlarmAction(props.targetResponseTimeAlarm?.action ?? this.action);
-            targetResponseTimeAlarm.addOkAction(props.targetResponseTimeAlarm?.action ?? this.action);
+            // Default to the warning action
+            const rtAction = props.targetResponseTimeAlarm?.action ?? this.warningAction;
+            targetResponseTimeAlarm.addAlarmAction(rtAction);
+            if (props.targetResponseTimeAlarm?.enableOkAlarm ?? true) {
+                targetResponseTimeAlarm.addOkAction(rtAction);
+            }
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-alarms.js","sourceRoot":"","sources":["../../src/alarms/service-alarms.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as constructs from \"constructs\"\n\nexport interface ServiceAlarmsProps extends cdk.StackProps {\n  /**\n   * The default action to use for CloudWatch alarm state changes\n   */\n  action: cloudwatch.IAlarmAction\n  /**\n   * The name of the ECS service.\n   */\n  serviceName: string\n}\n\n/**\n * Various alarms and monitoring.\n *\n * By itself no alarms is created. Use the methods available\n * to add alarms.\n *\n * See SlackAlarm construct for SNS Action.\n */\nexport class ServiceAlarms extends constructs.Construct {\n  private readonly action: cloudwatch.IAlarmAction\n  private readonly serviceName: string\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: ServiceAlarmsProps,\n  ) {\n    super(scope, id)\n\n    this.action = props.action\n    this.serviceName = props.serviceName\n  }\n\n  /**\n   * For logs stored as JSON, monitor log entries logged\n   * with level ERROR or higher, as well as any requests\n   * that causes 500 for logging with liflig-logging.\n   */\n  addJsonErrorAlarm(props: {\n    logGroup: logs.ILogGroup\n    alarmDescription?: string\n    /**\n     * Set to `false` to stop the alarm from sending OK events.\n     * @default true\n     * */\n    enableOkAction?: boolean\n    /**\n     * An action to use for CloudWatch alarm state changes instead of the default action\n     */\n    action?: cloudwatch.IAlarmAction\n  }): void {\n    const errorMetricFilter = props.logGroup.addMetricFilter(\n      \"ErrorMetricFilter\",\n      {\n        filterPattern: logs.FilterPattern.any(\n          logs.FilterPattern.stringValue(\"$.level\", \"=\", \"ERROR\"),\n          // FATAL covers some applications we run that uses log4j or\n          // other libraries. It is not existent in slf4j.\n          logs.FilterPattern.stringValue(\"$.level\", \"=\", \"FATAL\"),\n          logs.FilterPattern.stringValue(\n            // For liflig-logging.\n            \"$.requestInfo.status.code\",\n            \"=\",\n            \"INTERNAL_SERVER_ERROR\",\n          ),\n        ),\n        metricName: \"Errors\",\n        metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${\n          this.serviceName\n        }/Errors`,\n      },\n    )\n\n    const errorAlarm = errorMetricFilter\n      .metric()\n      .with({\n        statistic: \"Sum\",\n        period: cdk.Duration.seconds(60),\n      })\n      .createAlarm(this, \"ErrorLogAlarm\", {\n        alarmDescription:\n          props.alarmDescription ?? `${this.serviceName} logged an error`,\n        evaluationPeriods: 1,\n        threshold: 1,\n        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n      })\n\n    errorAlarm.addAlarmAction(props.action ?? this.action)\n    if (props.enableOkAction ?? true) {\n      errorAlarm.addOkAction(props.action ?? this.action)\n    }\n  }\n\n  /**\n   * Sets up three CloudWatch Alarms for monitoring an ECS service behind a target group:\n   * 1) one that triggers if the target is responding with too many 5xx errors.\n   * 2) one that triggers if the 95% percentile of response times from the target is too high.\n   * 3) one that triggers if there are no healthy targets or if the load balancer fails to connect to targets.\n   */\n  addTargetGroupAlarms(props: {\n    /**\n     * The full name of the target group.\n     */\n    targetGroupFullName: string\n    /**\n     * The full name of the application load balancer.\n     */\n    loadBalancerFullName: string\n    /**\n     * Configuration for a composite alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    targetHealthAlarm?: {\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     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    tooMany5xxResponsesFromTargetsAlarm?: {\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 3\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 10\n       */\n      threshold?: number\n      description?: string\n    }\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    targetResponseTimeAlarm?: {\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 5 minutes\n       */\n      period?: cdk.Duration\n      /**\n       * @default 1\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 500 milliseconds\n       */\n      threshold?: cdk.Duration\n      description?: string\n    }\n  }): void {\n    const targetConnectionErrorAlarm = new cloudwatch.Metric({\n      metricName: \"TargetConnectionErrorCount\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Sum\",\n      period: props.targetHealthAlarm?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"ConnectionAlarm\", {\n      actionsEnabled: true,\n      alarmDescription: `Load balancer is failing to connect to target(s) in ECS service '${this.serviceName}'.`,\n      evaluationPeriods: props.targetHealthAlarm?.evaluationPeriods ?? 1,\n      threshold: 1,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n\n    const healthAlarm = new cloudwatch.Metric({\n      metricName: \"HealthyHostCount\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Minimum\",\n      period: props.targetHealthAlarm?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"HealthAlarm\", {\n      alarmDescription: `There are no healthy target(s) in ECS service '${this.serviceName}'.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,\n      evaluationPeriods: props.targetHealthAlarm?.evaluationPeriods ?? 1,\n      threshold: 1,\n      treatMissingData: cloudwatch.TreatMissingData.BREACHING,\n    })\n\n    const targetHealthAlarm = new cloudwatch.CompositeAlarm(\n      this,\n      \"TargetHealthAlarm\",\n      {\n        alarmRule: cdk.aws_cloudwatch.AlarmRule.anyOf(\n          cdk.aws_cloudwatch.AlarmRule.fromAlarm(\n            targetConnectionErrorAlarm,\n            cloudwatch.AlarmState.ALARM,\n          ),\n          cdk.aws_cloudwatch.AlarmRule.fromAlarm(\n            healthAlarm,\n            cloudwatch.AlarmState.ALARM,\n          ),\n        ),\n        alarmDescription:\n          props.targetHealthAlarm?.description ??\n          `The load balancer is either receiving bad health checks from or is unable to connect to target(s) in ECS service '${this.serviceName}'`,\n      },\n    )\n    if (props.targetHealthAlarm?.enabled ?? true) {\n      targetHealthAlarm.addAlarmAction(\n        props.targetHealthAlarm?.action ?? this.action,\n      )\n      targetHealthAlarm.addOkAction(\n        props.targetHealthAlarm?.action ?? this.action,\n      )\n    }\n\n    const tooMany5xxResponsesFromTargetsAlarm = new cloudwatch.Metric({\n      metricName: \"HTTPCode_Target_5XX_Count\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Sum\",\n      period:\n        props.tooMany5xxResponsesFromTargetsAlarm?.period ??\n        cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"AlbTargets5xxAlarm\", {\n      actionsEnabled: true,\n      alarmDescription:\n        props.tooMany5xxResponsesFromTargetsAlarm?.description ??\n        `Load balancer received too many 5XX responses from target(s) in ECS service '${this.serviceName}'.`,\n      evaluationPeriods:\n        props.tooMany5xxResponsesFromTargetsAlarm?.evaluationPeriods ?? 3,\n      threshold: props.tooMany5xxResponsesFromTargetsAlarm?.threshold ?? 10,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n    if (props.tooMany5xxResponsesFromTargetsAlarm?.enabled ?? true) {\n      tooMany5xxResponsesFromTargetsAlarm.addAlarmAction(\n        props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.action,\n      )\n      tooMany5xxResponsesFromTargetsAlarm.addOkAction(\n        props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.action,\n      )\n    }\n\n    const targetResponseTimeAlarm = new cloudwatch.Metric({\n      metricName: \"TargetResponseTime\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"p95\",\n      period: props.targetResponseTimeAlarm?.period ?? cdk.Duration.minutes(5),\n      dimensionsMap: {\n        LoadBalancer: props.loadBalancerFullName,\n        TargetGroup: props.targetGroupFullName,\n      },\n    }).createAlarm(this, \"TargetResponseTimeAlarm\", {\n      alarmDescription:\n        props.targetResponseTimeAlarm?.description ??\n        `5% of responses from ECS service '${\n          this.serviceName\n        }' are taking longer than the expected duration of ${(\n          props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.millis(500)\n        ).toMilliseconds()} ms.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      evaluationPeriods: props.targetResponseTimeAlarm?.evaluationPeriods ?? 1,\n      threshold: (\n        props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.millis(500)\n      ).toSeconds({ integral: false }),\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n    if (props.targetResponseTimeAlarm?.enabled ?? true) {\n      targetResponseTimeAlarm.addAlarmAction(\n        props.targetResponseTimeAlarm?.action ?? this.action,\n      )\n      targetResponseTimeAlarm.addOkAction(\n        props.targetResponseTimeAlarm?.action ?? this.action,\n      )\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-alarms.js","sourceRoot":"","sources":["../../src/alarms/service-alarms.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport type * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as logsDestinations from \"aws-cdk-lib/aws-logs-destinations\"\nimport * as constructs from \"constructs\"\nimport { jsonErrorFilterPattern } from \"./log-filter-patterns\"\n\nexport interface ServiceAlarmsProps extends cdk.StackProps {\n  /**\n   * The CloudWatch Alarm action to use for high-severity alarms.\n   */\n  alarmAction: cloudwatch.IAlarmAction\n  /**\n   * The CloudWatch Alarm action to use for warnings.\n   */\n  warningAction: cloudwatch.IAlarmAction\n  /**\n   * The name of the ECS service.\n   */\n  serviceName: string\n  /**\n   * Optional Lambda function that will receive forwarded log events.\n   * If provided, subscription filters will be created to forward matching logs.\n   */\n  logHandler?: lambda.IFunction\n}\n\n/**\n * Various alarms and monitoring.\n *\n * By itself no alarms is created. Use the methods available\n * to add alarms.\n *\n * See SlackAlarm construct for SNS Action.\n */\nexport class ServiceAlarms extends constructs.Construct {\n  private readonly alarmAction: cloudwatch.IAlarmAction\n  private readonly warningAction: cloudwatch.IAlarmAction\n  private readonly serviceName: string\n  private readonly logHandler?: lambda.IFunction\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: ServiceAlarmsProps,\n  ) {\n    super(scope, id)\n\n    this.alarmAction = props.alarmAction\n    this.warningAction = props.warningAction\n    this.serviceName = props.serviceName\n    this.logHandler = props.logHandler\n  }\n\n  /**\n   * For logs stored as JSON, monitor log entries logged\n   * with level ERROR or higher, as well as any requests\n   * that causes 500 for logging with liflig-logging.\n   */\n  addJsonErrorAlarm(props: {\n    logGroup: logs.ILogGroup\n    alarmDescription?: string\n    /**\n     * Set to `false` to stop the alarm from sending OK events.\n     * @default true\n     */\n    enableOkAlarm?: boolean\n    /**\n     * An action to use for CloudWatch alarm state changes instead of the default action\n     */\n    action?: cloudwatch.IAlarmAction\n  }): void {\n    const groupToUse = props.logGroup\n\n    // If no log handler is configured, we create\n    // the simple \"ERROR\" metric alarm.\n    if (!this.logHandler) {\n      const errorMetricFilter = groupToUse.addMetricFilter(\n        \"ErrorMetricFilter\",\n        {\n          filterPattern: jsonErrorFilterPattern(),\n          metricName: \"Errors\",\n          metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.serviceName}/Errors`,\n        },\n      )\n\n      const errorAlarm = errorMetricFilter\n        .metric()\n        .with({\n          statistic: \"Sum\",\n          period: cdk.Duration.seconds(60),\n        })\n        .createAlarm(this, \"ErrorLogAlarm\", {\n          alarmDescription:\n            props.alarmDescription ?? `${this.serviceName} logged an error`,\n          evaluationPeriods: 1,\n          threshold: 1,\n          treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n        })\n\n      // Default to the warning action\n      const actionToUse = props.action ?? this.warningAction\n      errorAlarm.addAlarmAction(actionToUse)\n      if (props.enableOkAlarm ?? true) {\n        errorAlarm.addOkAction(actionToUse)\n      }\n    }\n\n    if (this.logHandler) {\n      props.logGroup.addSubscriptionFilter(\n        \"liflig-cdk-log-content-to-slack-error-subscription\",\n        {\n          destination: new logsDestinations.LambdaDestination(this.logHandler),\n          filterPattern: jsonErrorFilterPattern(),\n        },\n      )\n    }\n  }\n\n  addUncaughtJavaExceptionAlarm(props: {\n    logGroup: logs.ILogGroup\n    alarmDescription?: string\n    /**\n     * @default false\n     */\n    enabled?: boolean\n    enableOkAlarm?: boolean\n    action?: cloudwatch.IAlarmAction\n  }): void {\n    if (props.enabled) {\n      const filterPattern = logs.FilterPattern.allTerms(\"Exception in thread\")\n\n      // If no log handler is configured, create a simple metric alarm.\n      if (!this.logHandler) {\n        const errorMetricFilter = props.logGroup.addMetricFilter(\n          \"UncaughtJavaExceptionFilter\",\n          {\n            filterPattern: filterPattern,\n            metricName: \"UncaughtJavaException\",\n            metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.serviceName}/UncaughtJavaException`,\n          },\n        )\n\n        const errorAlarm = errorMetricFilter\n          .metric()\n          .with({\n            statistic: \"Sum\",\n            period: cdk.Duration.seconds(60),\n          })\n          .createAlarm(this, \"UncaughtJavaExceptionLogAlarm\", {\n            alarmDescription:\n              props.alarmDescription ??\n              `${this.serviceName} logged an uncaught Java exception`,\n            evaluationPeriods: 1,\n            threshold: 1,\n            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n          })\n\n        // Default to the warning action\n        const actionToUse = props.action ?? this.warningAction\n        errorAlarm.addAlarmAction(actionToUse)\n        if (props.enableOkAlarm ?? true) {\n          errorAlarm.addOkAction(actionToUse)\n        }\n      }\n\n      // If a log handler is configured, forward matching logs to it.\n      if (this.logHandler) {\n        props.logGroup.addSubscriptionFilter(\n          \"liflig-cdk-log-content-to-slack-uncaught-exception-subscription\",\n          {\n            destination: new logsDestinations.LambdaDestination(\n              this.logHandler,\n            ),\n            filterPattern: filterPattern,\n          },\n        )\n      }\n    }\n  }\n\n  /**\n   * Sets up CloudWatch alarms for monitoring an ECS service behind a target group:\n   * 1) one that triggers if the target is responding with too many 5xx errors (aggregate 5xx count).\n   * 2) one that triggers if the 95% percentile of response times from the target is too high.\n   * 3) one that triggers if there are no healthy targets or if the load balancer fails to connect to targets.\n   * 4) a single5xxResponseAlarm which triggers on a single 5xx response from a target.\n   */\n  addTargetGroupAlarms(props: {\n    /**\n     * The full name of the target group.\n     */\n    targetGroupFullName: string\n    /**\n     * The full name of the application load balancer.\n     */\n    loadBalancerFullName: string\n    /**\n     * Configuration for a composite alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    targetHealthAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * Whether to attach OK actions for this alarm. @default true\n       */\n      enableOkAlarm?: 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     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    tooMany5xxResponsesFromTargetsAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * Whether to attach OK actions for this alarm. @default true\n       */\n      enableOkAlarm?: 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 3\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 10\n       */\n      threshold?: number\n      description?: string\n    }\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    targetResponseTimeAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * Whether to attach OK actions for this alarm. @default true\n       */\n      enableOkAlarm?: 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 5 minutes\n       */\n      period?: cdk.Duration\n      /**\n       * @default 1\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 1s\n       */\n      threshold?: cdk.Duration\n      description?: string\n    }\n    /**\n     * Configuration for an alarm.\n     *\n     * @default Configured with sane defaults.\n     */\n    single5xxResponseAlarm?: {\n      /**\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * Whether to attach OK actions for this alarm. @default true\n       */\n      enableOkAlarm?: 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  }): void {\n    if (props.single5xxResponseAlarm?.enabled !== false) {\n      const single5xxMetric = new cloudwatch.Metric({\n        metricName: \"HTTPCode_Target_5XX_Count\",\n        namespace: \"AWS/ApplicationELB\",\n        statistic: \"Sum\",\n        period:\n          props.single5xxResponseAlarm?.period ?? cdk.Duration.seconds(60),\n        dimensionsMap: {\n          TargetGroup: props.targetGroupFullName,\n          LoadBalancer: props.loadBalancerFullName,\n        },\n      })\n\n      const single5xxAlarm = single5xxMetric.createAlarm(\n        this,\n        \"AlbTargetsSingle5xxAlarm\",\n        {\n          actionsEnabled: true,\n          alarmDescription:\n            props.single5xxResponseAlarm?.description ??\n            `Load balancer received a 5XX response from target(s) in ECS service '${this.serviceName}'.`,\n          evaluationPeriods:\n            props.single5xxResponseAlarm?.evaluationPeriods ?? 1,\n          threshold: props.single5xxResponseAlarm?.threshold ?? 1,\n          treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n        },\n      )\n\n      // Sent to warnings channel by default\n      const single5xxAction =\n        props.single5xxResponseAlarm?.action ?? this.warningAction\n      single5xxAlarm.addAlarmAction(single5xxAction)\n      if (props.single5xxResponseAlarm?.enableOkAlarm ?? true) {\n        single5xxAlarm.addOkAction(single5xxAction)\n      }\n    }\n\n    const targetConnectionErrorAlarm = new cloudwatch.Metric({\n      metricName: \"TargetConnectionErrorCount\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Sum\",\n      period: props.targetHealthAlarm?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"ConnectionAlarm\", {\n      actionsEnabled: true,\n      alarmDescription: `Load balancer is failing to connect to target(s) in ECS service '${this.serviceName}'.`,\n      evaluationPeriods: props.targetHealthAlarm?.evaluationPeriods ?? 1,\n      threshold: 1,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n\n    const healthAlarm = new cloudwatch.Metric({\n      metricName: \"HealthyHostCount\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Minimum\",\n      period: props.targetHealthAlarm?.period ?? cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"HealthAlarm\", {\n      alarmDescription: `There are no healthy target(s) in ECS service '${this.serviceName}'.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,\n      evaluationPeriods: props.targetHealthAlarm?.evaluationPeriods ?? 1,\n      threshold: 1,\n      treatMissingData: cloudwatch.TreatMissingData.BREACHING,\n    })\n\n    const targetHealthAlarm = new cloudwatch.CompositeAlarm(\n      this,\n      \"TargetHealthAlarm\",\n      {\n        alarmRule: cdk.aws_cloudwatch.AlarmRule.anyOf(\n          cdk.aws_cloudwatch.AlarmRule.fromAlarm(\n            targetConnectionErrorAlarm,\n            cloudwatch.AlarmState.ALARM,\n          ),\n          cdk.aws_cloudwatch.AlarmRule.fromAlarm(\n            healthAlarm,\n            cloudwatch.AlarmState.ALARM,\n          ),\n        ),\n        alarmDescription:\n          props.targetHealthAlarm?.description ??\n          `The load balancer is either receiving bad health checks from or is unable to connect to target(s) in ECS service '${this.serviceName}'`,\n      },\n    )\n    if (props.targetHealthAlarm?.enabled ?? true) {\n      // Default to the alarm action\n      const thAction = props.targetHealthAlarm?.action ?? this.alarmAction\n      targetHealthAlarm.addAlarmAction(thAction)\n      if (props.targetHealthAlarm?.enableOkAlarm ?? true) {\n        targetHealthAlarm.addOkAction(thAction)\n      }\n    }\n\n    const tooMany5xxResponsesFromTargetsAlarm = new cloudwatch.Metric({\n      metricName: \"HTTPCode_Target_5XX_Count\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"Sum\",\n      period:\n        props.tooMany5xxResponsesFromTargetsAlarm?.period ??\n        cdk.Duration.seconds(60),\n      dimensionsMap: {\n        TargetGroup: props.targetGroupFullName,\n        LoadBalancer: props.loadBalancerFullName,\n      },\n    }).createAlarm(this, \"AlbTargets5xxAlarm\", {\n      actionsEnabled: true,\n      alarmDescription:\n        props.tooMany5xxResponsesFromTargetsAlarm?.description ??\n        `Load balancer received too many 5XX responses from target(s) in ECS service '${this.serviceName}'.`,\n      evaluationPeriods:\n        props.tooMany5xxResponsesFromTargetsAlarm?.evaluationPeriods ?? 3,\n      threshold: props.tooMany5xxResponsesFromTargetsAlarm?.threshold ?? 10,\n      treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n    })\n    if (props.tooMany5xxResponsesFromTargetsAlarm?.enabled ?? true) {\n      // Default to the alarm action\n      const fiveXAction =\n        props.tooMany5xxResponsesFromTargetsAlarm?.action ?? this.alarmAction\n      tooMany5xxResponsesFromTargetsAlarm.addAlarmAction(fiveXAction)\n      if (props.tooMany5xxResponsesFromTargetsAlarm?.enableOkAlarm ?? true) {\n        tooMany5xxResponsesFromTargetsAlarm.addOkAction(fiveXAction)\n      }\n    }\n\n    const targetResponseTimeAlarm = new cloudwatch.Metric({\n      metricName: \"TargetResponseTime\",\n      namespace: \"AWS/ApplicationELB\",\n      statistic: \"p95\",\n      period: props.targetResponseTimeAlarm?.period ?? cdk.Duration.minutes(5),\n      dimensionsMap: {\n        LoadBalancer: props.loadBalancerFullName,\n        TargetGroup: props.targetGroupFullName,\n      },\n    }).createAlarm(this, \"TargetResponseTimeAlarm\", {\n      alarmDescription:\n        props.targetResponseTimeAlarm?.description ??\n        `5% of responses from ECS service '${\n          this.serviceName\n        }' are taking longer than the expected duration of ${(\n          props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.seconds(1)\n        ).toSeconds({ integral: false })} s.`,\n      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n      evaluationPeriods: props.targetResponseTimeAlarm?.evaluationPeriods ?? 1,\n      threshold: (\n        props.targetResponseTimeAlarm?.threshold ?? cdk.Duration.seconds(1)\n      ).toSeconds({ integral: false }),\n      treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n    })\n    if (props.targetResponseTimeAlarm?.enabled ?? true) {\n      // Default to the warning action\n      const rtAction =\n        props.targetResponseTimeAlarm?.action ?? this.warningAction\n      targetResponseTimeAlarm.addAlarmAction(rtAction)\n      if (props.targetResponseTimeAlarm?.enableOkAlarm ?? true) {\n        targetResponseTimeAlarm.addOkAction(rtAction)\n      }\n    }\n  }\n}\n"]}