@liflig/cdk 3.22.19 → 3.23.1

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

@@ -1,41 +1,143 @@
 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 LambdaAlarmsProps {
     /**
-     * The default action to use for CloudWatch alarm state changes.
+     * The CloudWatch alarm action to use for high-severity alarms (ALARM channel).
      */
-    action: cloudwatch.IAlarmAction;
+    alarmAction: cloudwatch.IAlarmAction;
+    /**
+     * The CloudWatch alarm action to use for lower-severity warnings (WARNING channel).
+     */
+    warningAction: cloudwatch.IAlarmAction;
     /**
      * The Lambda to add alarms to.
      */
     lambdaFunction: lambda.IFunction;
+    /**
+     * Optional Lambda function that will receive forwarded log events.
+     * If provided, subscription filters will be created to forward matching logs
+     */
+    logHandler?: lambda.IFunction;
 }
 /**
  * Alarms for Lambda functions.
  *
- * By itself, no alarms are created. Use the methods available
- * to add alarms.
+ * Unlike RDS and ECS alarm constructs in this package, `LambdaAlarms` is
+ * set up manually by consumers.
  *
- * Create multiple instances of {@link LambdaAlarms} with different `action`
- * if you need an alarm to do multiple things.
+ * Defaults:
+ * - single invocation (singleError) -> sent to `warningAction` by default
+ * - multiple invocation (multipleErrors) -> sent to `alarmAction` by default
+ * - error log alarm (ERROR/FATAL JSON logs) -> sent to `warningAction` by default
+ * - uncaught Java exception alarm -> sent to `warningAction` by default (disabled by default)
  */
 export declare class LambdaAlarms extends constructs.Construct {
-    private readonly action;
+    private readonly alarmAction;
+    private readonly warningAction;
     private readonly lambdaFunction;
+    private readonly logHandler?;
     constructor(scope: constructs.Construct, id: string, props: LambdaAlarmsProps);
     /**
-     * Sets up a CloudWatch Alarm that triggers if the Lambda fails invocations.
-     * This usually happens from uncaught exceptions in the lambda.
+     * Creates both the single-invocation warning and the
+     * multiple invocations alarm with reasonable defaults.
+     *
+     * Each created alarm can be overridden via the per-alarm props.
      */
-    addInvocationErrorAlarm(
+    addInvocationErrorAlarm(props?: {
+        singleError?: {
+            appendToAlarmDescription?: string;
+            enabled?: boolean;
+            action?: cloudwatch.IAlarmAction;
+            /**
+             * @default true
+             */
+            enableOkAlarm?: boolean;
+        };
+        multipleErrors?: {
+            appendToAlarmDescription?: string;
+            enabled?: boolean;
+            action?: cloudwatch.IAlarmAction;
+            /**
+             * @default true
+             */
+            enableOkAlarm?: boolean;
+            /**
+             * @default 3
+             */
+            evaluationPeriods?: number;
+            /**
+             * @default 1
+             */
+            threshold?: number;
+            /**
+             * @default 60
+             */
+            periodSeconds?: number;
+        };
+    }): void;
     /**
-     * Configuration for an alarm.
+     * Sets up a CloudWatch Alarm that triggers on a single invocation failure.
      */
-    props?: {
+    addSingleInvocationAlarm(props?: {
+        appendToAlarmDescription?: string;
+        enabled?: boolean;
+        action?: cloudwatch.IAlarmAction;
+        enableOkAlarm?: boolean;
+    }): void;
+    /**
+     * Sets up a CloudWatch Alarm that triggers when there is a short series of
+     * invocation failures.
+     */
+    addMultipleInvocationAlarms(props?: {
+        appendToAlarmDescription?: string;
+        enabled?: boolean;
+        action?: cloudwatch.IAlarmAction;
         /**
-         * Add extra information to the alarm description, like Runbook URL or steps to triage.
+         * @default true
          */
-        appendToAlarmDescription?: string;
+        enableOkAlarm?: boolean;
+        /**
+         * @default 3
+         */
+        evaluationPeriods?: number;
+        /**
+         * @default 1
+         */
+        threshold?: number;
+        /**
+         * @default 60
+         */
+        periodSeconds?: number;
+    }): void;
+    /**
+     * Alerts when ERROR is logged from lambda.
+     */
+    addErrorAlarm(props: {
+        logGroup: logs.ILogGroup;
+        alarmDescription?: string;
+        /**
+         * @default true
+         */
+        enableOkAlarm?: boolean;
+        /**
+         * An action to use for CloudWatch alarm state changes
+         * instead of the default warning action
+         */
+        action?: cloudwatch.IAlarmAction;
+    }): void;
+    /**
+     * Adds an alarm for uncaught Java exceptions in the Lambda function's logs.
+     */
+    addUncaughtJavaExceptionAlarm(props: {
+        logGroup: logs.ILogGroup;
+        alarmDescription?: string;
+        /**
+         * @default false
+         */
+        enabled?: boolean;
+        enableOkAlarm?: boolean;
+        action?: cloudwatch.IAlarmAction;
     }): void;
 }

package/lib/alarms/lambda-alarms.js

@@ -1,49 +1,178 @@
 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";
 /**
  * Alarms for Lambda functions.
  *
- * By itself, no alarms are created. Use the methods available
- * to add alarms.
+ * Unlike RDS and ECS alarm constructs in this package, `LambdaAlarms` is
+ * set up manually by consumers.
  *
- * Create multiple instances of {@link LambdaAlarms} with different `action`
- * if you need an alarm to do multiple things.
+ * Defaults:
+ * - single invocation (singleError) -> sent to `warningAction` by default
+ * - multiple invocation (multipleErrors) -> sent to `alarmAction` by default
+ * - error log alarm (ERROR/FATAL JSON logs) -> sent to `warningAction` by default
+ * - uncaught Java exception alarm -> sent to `warningAction` by default (disabled by default)
  */
 export class LambdaAlarms extends constructs.Construct {
-    action;
+    alarmAction;
+    warningAction;
     lambdaFunction;
+    logHandler;
     constructor(scope, id, props) {
         super(scope, id);
-        this.action = props.action;
+        this.alarmAction = props.alarmAction;
+        this.warningAction = props.warningAction;
         this.lambdaFunction = props.lambdaFunction;
+        this.logHandler = props.logHandler;
     }
     /**
-     * Sets up a CloudWatch Alarm that triggers if the Lambda fails invocations.
-     * This usually happens from uncaught exceptions in the lambda.
+     * Creates both the single-invocation warning and the
+     * multiple invocations alarm with reasonable defaults.
+     *
+     * Each created alarm can be overridden via the per-alarm props.
      */
-    addInvocationErrorAlarm(
+    addInvocationErrorAlarm(props) {
+        this.addSingleInvocationAlarm(props?.singleError);
+        this.addMultipleInvocationAlarms(props?.multipleErrors);
+    }
+    /**
+     * Sets up a CloudWatch Alarm that triggers on a single invocation failure.
+     */
+    addSingleInvocationAlarm(props) {
+        if (props?.enabled !== false) {
+            // Sent to warnings channel by default
+            const action = props?.action ?? this.warningAction;
+            const alarm = new cloudwatch.Metric({
+                metricName: "Errors",
+                namespace: "AWS/Lambda",
+                statistic: "Sum",
+                period: cdk.Duration.seconds(60),
+                dimensionsMap: {
+                    FunctionName: this.lambdaFunction.functionName,
+                },
+            }).createAlarm(this, "SingleInvocationAlarm", {
+                alarmDescription: `Invocation for '${this.lambdaFunction.functionName}' had a single failure. ${props?.appendToAlarmDescription ?? ""}`,
+                comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: 1,
+                threshold: 1,
+                treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+            });
+            alarm.addAlarmAction(action);
+            if (props?.enableOkAlarm ?? true)
+                alarm.addOkAction(action);
+        }
+    }
+    /**
+     * Sets up a CloudWatch Alarm that triggers when there is a short series of
+     * invocation failures.
+     */
+    addMultipleInvocationAlarms(props) {
+        if (props?.enabled !== false) {
+            const alarm = new cloudwatch.Metric({
+                metricName: "Errors",
+                namespace: "AWS/Lambda",
+                statistic: "Sum",
+                period: cdk.Duration.seconds(props?.periodSeconds ?? 60),
+                dimensionsMap: {
+                    FunctionName: this.lambdaFunction.functionName,
+                },
+            }).createAlarm(this, "InvocationSeriesAlarm", {
+                alarmDescription: `Invocation for '${this.lambdaFunction.functionName}' failed repeatedly. ${props?.appendToAlarmDescription ?? ""}`,
+                comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: props?.evaluationPeriods ?? 3,
+                threshold: props?.threshold ?? 1,
+                treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+            });
+            // Sent to alarm channel by default
+            const multipleAction = props?.action ?? this.alarmAction;
+            alarm.addAlarmAction(multipleAction);
+            if (props?.enableOkAlarm ?? true) {
+                alarm.addOkAction(multipleAction);
+            }
+        }
+    }
+    /**
+     * Alerts when ERROR is logged from lambda.
+     */
+    addErrorAlarm(props) {
+        // If no log handler is configured, create simple "ERROR" metric alarm
+        if (!this.logHandler) {
+            const errorMetricFilter = props.logGroup.addMetricFilter("ErrorMetricFilter", {
+                filterPattern: jsonErrorFilterPattern(),
+                metricName: "Errors",
+                metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.lambdaFunction.functionName}/Errors`,
+            });
+            const errorAlarm = errorMetricFilter
+                .metric()
+                .with({
+                statistic: "Sum",
+                period: cdk.Duration.seconds(60),
+            })
+                .createAlarm(this, "ErrorLogAlarm", {
+                alarmDescription: props.alarmDescription ??
+                    `${this.lambdaFunction.functionName} logged an error`,
+                evaluationPeriods: 1,
+                threshold: 1,
+                treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+            });
+            // Sent to warnings channel by default
+            const action = props.action ?? this.warningAction;
+            errorAlarm.addAlarmAction(action);
+            if (props.enableOkAlarm ?? true) {
+                errorAlarm.addOkAction(action);
+            }
+        }
+        if (this.logHandler) {
+            props.logGroup.addSubscriptionFilter("liflig-cdk-log-content-to-slack-error-subscription", {
+                destination: new logsDestinations.LambdaDestination(this.logHandler),
+                filterPattern: jsonErrorFilterPattern(),
+            });
+        }
+    }
     /**
-     * Configuration for an alarm.
+     * Adds an alarm for uncaught Java exceptions in the Lambda function's logs.
      */
-    props) {
-        const alarm = new cloudwatch.Metric({
-            metricName: "Errors",
-            namespace: "AWS/Lambda",
-            statistic: "Sum",
-            period: cdk.Duration.seconds(60),
-            dimensionsMap: {
-                FunctionName: this.lambdaFunction.functionName,
-            },
-        }).createAlarm(this, "FailedInvocationAlarm", {
-            alarmDescription: `Invocation for '${this.lambdaFunction.functionName}' failed. ${props?.appendToAlarmDescription ?? ""}`,
-            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
-            evaluationPeriods: 1,
-            threshold: 1,
-            treatMissingData: cloudwatch.TreatMissingData.IGNORE,
-        });
-        alarm.addAlarmAction(this.action);
-        alarm.addOkAction(this.action);
+    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.lambdaFunction.functionName}/UncaughtJavaException`,
+                });
+                const errorAlarm = errorMetricFilter
+                    .metric()
+                    .with({
+                    statistic: "Sum",
+                    period: cdk.Duration.seconds(60),
+                })
+                    .createAlarm(this, "UncaughtJavaExceptionLogAlarm", {
+                    alarmDescription: props.alarmDescription ??
+                        `${this.lambdaFunction.functionName} 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,
+                });
+            }
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-alarms.js","sourceRoot":"","sources":["../../src/alarms/lambda-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 LambdaAlarmsProps {\n  /**\n   * The CloudWatch alarm action to use for high-severity alarms (ALARM channel).\n   */\n  alarmAction: cloudwatch.IAlarmAction\n  /**\n   * The CloudWatch alarm action to use for lower-severity warnings (WARNING channel).\n   */\n  warningAction: cloudwatch.IAlarmAction\n  /**\n   * The Lambda to add alarms to.\n   */\n  lambdaFunction: lambda.IFunction\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 * Alarms for Lambda functions.\n *\n * Unlike RDS and ECS alarm constructs in this package, `LambdaAlarms` is\n * set up manually by consumers.\n *\n * Defaults:\n * - single invocation (singleError) -> sent to `warningAction` by default\n * - multiple invocation (multipleErrors) -> sent to `alarmAction` by default\n * - error log alarm (ERROR/FATAL JSON logs) -> sent to `warningAction` by default\n * - uncaught Java exception alarm -> sent to `warningAction` by default (disabled by default)\n */\nexport class LambdaAlarms extends constructs.Construct {\n  private readonly alarmAction: cloudwatch.IAlarmAction\n  private readonly warningAction: cloudwatch.IAlarmAction\n  private readonly lambdaFunction: lambda.IFunction\n  private readonly logHandler?: lambda.IFunction\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: LambdaAlarmsProps,\n  ) {\n    super(scope, id)\n\n    this.alarmAction = props.alarmAction\n    this.warningAction = props.warningAction\n    this.lambdaFunction = props.lambdaFunction\n    this.logHandler = props.logHandler\n  }\n\n  /**\n   * Creates both the single-invocation warning and the\n   * multiple invocations alarm with reasonable defaults.\n   *\n   * Each created alarm can be overridden via the per-alarm props.\n   */\n  addInvocationErrorAlarm(props?: {\n    singleError?: {\n      appendToAlarmDescription?: string\n      enabled?: boolean\n      action?: cloudwatch.IAlarmAction\n      /**\n       * @default true\n       */\n      enableOkAlarm?: boolean\n    }\n    multipleErrors?: {\n      appendToAlarmDescription?: string\n      enabled?: boolean\n      action?: cloudwatch.IAlarmAction\n      /**\n       * @default true\n       */\n      enableOkAlarm?: boolean\n      /**\n       * @default 3\n       */\n      evaluationPeriods?: number\n      /**\n       * @default 1\n       */\n      threshold?: number\n      /**\n       * @default 60\n       */\n      periodSeconds?: number\n    }\n  }): void {\n    this.addSingleInvocationAlarm(props?.singleError)\n    this.addMultipleInvocationAlarms(props?.multipleErrors)\n  }\n\n  /**\n   * Sets up a CloudWatch Alarm that triggers on a single invocation failure.\n   */\n  addSingleInvocationAlarm(props?: {\n    appendToAlarmDescription?: string\n    enabled?: boolean\n    action?: cloudwatch.IAlarmAction\n    enableOkAlarm?: boolean\n  }): void {\n    if (props?.enabled !== false) {\n      // Sent to warnings channel by default\n      const action = props?.action ?? this.warningAction\n\n      const alarm = new cloudwatch.Metric({\n        metricName: \"Errors\",\n        namespace: \"AWS/Lambda\",\n        statistic: \"Sum\",\n        period: cdk.Duration.seconds(60),\n        dimensionsMap: {\n          FunctionName: this.lambdaFunction.functionName,\n        },\n      }).createAlarm(this, \"SingleInvocationAlarm\", {\n        alarmDescription: `Invocation for '${this.lambdaFunction.functionName}' had a single failure. ${props?.appendToAlarmDescription ?? \"\"}`,\n        comparisonOperator:\n          cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: 1,\n        threshold: 1,\n        treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n      })\n\n      alarm.addAlarmAction(action)\n      if (props?.enableOkAlarm ?? true) alarm.addOkAction(action)\n    }\n  }\n\n  /**\n   * Sets up a CloudWatch Alarm that triggers when there is a short series of\n   * invocation failures.\n   */\n  addMultipleInvocationAlarms(props?: {\n    appendToAlarmDescription?: string\n    enabled?: boolean\n    action?: cloudwatch.IAlarmAction\n    /**\n     * @default true\n     */\n    enableOkAlarm?: boolean\n    /**\n     * @default 3\n     */\n    evaluationPeriods?: number\n    /**\n     * @default 1\n     */\n    threshold?: number\n    /**\n     * @default 60\n     */\n    periodSeconds?: number\n  }): void {\n    if (props?.enabled !== false) {\n      const alarm = new cloudwatch.Metric({\n        metricName: \"Errors\",\n        namespace: \"AWS/Lambda\",\n        statistic: \"Sum\",\n        period: cdk.Duration.seconds(props?.periodSeconds ?? 60),\n        dimensionsMap: {\n          FunctionName: this.lambdaFunction.functionName,\n        },\n      }).createAlarm(this, \"InvocationSeriesAlarm\", {\n        alarmDescription: `Invocation for '${this.lambdaFunction.functionName}' failed repeatedly. ${props?.appendToAlarmDescription ?? \"\"}`,\n        comparisonOperator:\n          cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n        evaluationPeriods: props?.evaluationPeriods ?? 3,\n        threshold: props?.threshold ?? 1,\n        treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n      })\n\n      // Sent to alarm channel by default\n      const multipleAction = props?.action ?? this.alarmAction\n      alarm.addAlarmAction(multipleAction)\n      if (props?.enableOkAlarm ?? true) {\n        alarm.addOkAction(multipleAction)\n      }\n    }\n  }\n\n  /**\n   * Alerts when ERROR is logged from lambda.\n   */\n  addErrorAlarm(props: {\n    logGroup: logs.ILogGroup\n    alarmDescription?: string\n    /**\n     * @default true\n     */\n    enableOkAlarm?: boolean\n    /**\n     * An action to use for CloudWatch alarm state changes\n     * instead of the default warning action\n     */\n    action?: cloudwatch.IAlarmAction\n  }): void {\n    // If no log handler is configured, create simple \"ERROR\" metric alarm\n    if (!this.logHandler) {\n      const errorMetricFilter = props.logGroup.addMetricFilter(\n        \"ErrorMetricFilter\",\n        {\n          filterPattern: jsonErrorFilterPattern(),\n          metricName: \"Errors\",\n          metricNamespace: `stack/${cdk.Stack.of(this).stackName}/${this.lambdaFunction.functionName}/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 ??\n            `${this.lambdaFunction.functionName} logged an error`,\n          evaluationPeriods: 1,\n          threshold: 1,\n          treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n        })\n\n      // Sent to warnings channel by default\n      const action = props.action ?? this.warningAction\n      errorAlarm.addAlarmAction(action)\n      if (props.enableOkAlarm ?? true) {\n        errorAlarm.addOkAction(action)\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  /**\n   * Adds an alarm for uncaught Java exceptions in the Lambda function's logs.\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.lambdaFunction.functionName}/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.lambdaFunction.functionName} 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"]}

package/lib/alarms/log-filter-patterns.d.ts

@@ -0,0 +1,5 @@
+import * as logs from "aws-cdk-lib/aws-logs";
+/**
+ * Common filter pattern used for JSON log-based error detection.
+ */
+export declare const jsonErrorFilterPattern: () => logs.JsonPattern;

package/lib/alarms/log-filter-patterns.js

@@ -0,0 +1,6 @@
+import * as logs from "aws-cdk-lib/aws-logs";
+/**
+ * Common filter pattern used for JSON log-based error detection.
+ */
+export const jsonErrorFilterPattern = () => logs.FilterPattern.any(logs.FilterPattern.stringValue("$.level", "=", "ERROR"), logs.FilterPattern.stringValue("$.level", "=", "FATAL"), logs.FilterPattern.stringValue("$.requestInfo.status.code", "=", "INTERNAL_SERVER_ERROR"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLWZpbHRlci1wYXR0ZXJucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hbGFybXMvbG9nLWZpbHRlci1wYXR0ZXJucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssSUFBSSxNQUFNLHNCQUFzQixDQUFBO0FBRTVDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsR0FBRyxFQUFFLENBQ3pDLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUNwQixJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUN2RCxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUN2RCxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FDNUIsMkJBQTJCLEVBQzNCLEdBQUcsRUFDSCx1QkFBdUIsQ0FDeEIsQ0FDRixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgbG9ncyBmcm9tIFwiYXdzLWNkay1saWIvYXdzLWxvZ3NcIlxuXG4vKipcbiAqIENvbW1vbiBmaWx0ZXIgcGF0dGVybiB1c2VkIGZvciBKU09OIGxvZy1iYXNlZCBlcnJvciBkZXRlY3Rpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBqc29uRXJyb3JGaWx0ZXJQYXR0ZXJuID0gKCkgPT5cbiAgbG9ncy5GaWx0ZXJQYXR0ZXJuLmFueShcbiAgICBsb2dzLkZpbHRlclBhdHRlcm4uc3RyaW5nVmFsdWUoXCIkLmxldmVsXCIsIFwiPVwiLCBcIkVSUk9SXCIpLFxuICAgIGxvZ3MuRmlsdGVyUGF0dGVybi5zdHJpbmdWYWx1ZShcIiQubGV2ZWxcIiwgXCI9XCIsIFwiRkFUQUxcIiksXG4gICAgbG9ncy5GaWx0ZXJQYXR0ZXJuLnN0cmluZ1ZhbHVlKFxuICAgICAgXCIkLnJlcXVlc3RJbmZvLnN0YXR1cy5jb2RlXCIsXG4gICAgICBcIj1cIixcbiAgICAgIFwiSU5URVJOQUxfU0VSVkVSX0VSUk9SXCIsXG4gICAgKSxcbiAgKVxuIl19

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

@@ -0,0 +1,88 @@
+import * as cdk from "aws-cdk-lib";
+import type { IAlarmAction } from "aws-cdk-lib/aws-cloudwatch";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import * as constructs from "constructs";
+export interface QueueAlarmsProps {
+    alarmAction: cloudwatch.IAlarmAction;
+    warningAction: cloudwatch.IAlarmAction;
+    queueName: string;
+}
+/**
+ * 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 declare class QueueAlarms extends constructs.Construct {
+    private readonly alarmAction;
+    private readonly warningAction;
+    private readonly queueName;
+    constructor(scope: constructs.Construct, id: string, props: QueueAlarmsProps);
+    /**
+     * 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?: {
+        /**
+         * Period for metric evaluation as a CDK Duration
+         * @default cdk.Duration.seconds(300)
+         */
+        period?: cdk.Duration;
+        /**
+         * Evaluation periods for MessagesVisible metric
+         * @default 2
+         */
+        evaluationPeriodsMessagesVisible?: number;
+        /**
+         * Threshold for MessagesVisible metric (minimum)
+         * @default 1
+         */
+        thresholdMessagesVisible?: number;
+        /**
+         * Evaluation periods for NumberOfMessagesDeleted metric
+         * @default 4
+         */
+        evaluationPeriodsMessagesDeleted?: number;
+        /**
+         * Threshold for NumberOfMessagesDeleted (sum)
+         * @default 0
+         */
+        thresholdMessagesDeleted?: number;
+        /**
+         * @default true
+         */
+        enableOkAlarm?: boolean;
+        /** Per-alarm override of the action to use instead of the construct alarmAction */
+        action?: IAlarmAction;
+    }): void;
+    /**
+     * Alerts when the ApproximateAgeOfOldestMessage metric is high.
+     */
+    addApproximateAgeOfOldestMessageAlarm(props?: {
+        alarmDescription?: string;
+        /**
+         * @default cdk.Duration.seconds(900) (15 minutes)
+         */
+        period?: cdk.Duration;
+        /**
+         * @default 2
+         */
+        evaluationPeriods?: number;
+        /**
+         * Threshold in seconds for the age of the oldest message
+         * @default 900 seconds (15 minutes)
+         */
+        thresholdSeconds?: number;
+        /**
+         * @default true
+         */
+        enableOkAlarm?: boolean;
+        /** An action to use for CloudWatch alarm state changes instead of the default warningAction */
+        action?: IAlarmAction;
+    }): void;
+}