@liflig/cdk 1.50.0 → 1.52.1

package/assets/cloudtrail-slack-integration-lambda/main.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python
+
+"""
+Transform CloudTrail events to payloads formatted for Slack's API, and send them
+directly to Slack or through an SQS FIFO queue for deduplication.
+
+The code below contains entrypoints for two Lambda functions (prefixed with `handler_`).
+"""
+
+import os
+import logging
+import json
+import urllib.request
+import boto3
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+
+def get_slack_payload_for_assume_role_event(event, account_friendly_names):
+    """Parse a CloudTrail event related to the API call sts:AssumeRole,
+    and return a Slack-formatted attachment"""
+    event_account_id = event["account"]
+    event_detail = event["detail"]
+    request_parameters = event_detail.get("requestParameters", {}) or {}
+
+    timestamp = event_detail["eventTime"]
+    user_identity = event_detail["userIdentity"]
+    principal_id = user_identity["principalId"]
+    principal_account_id = user_identity["accountId"]
+    source_identity = request_parameters.get("sourceIdentity", "")
+    source_ip = event_detail.get("sourceIPAddress", "")
+    role_arn = request_parameters.get("roleArn", "")
+
+    fallback = f"Sensitive role accessed in '{event_account_id}'"
+    pretext_messages = [f":warning: Sensitive role in `{event_account_id}` assumed by"]
+    if principal_id.startswith("AIDA"):
+        pretext_messages.append("IAM user")
+    elif principal_id.startswith("AROA"):
+        pretext_messages.append("IAM role")
+    else:
+        pretext_messages.append("principal")
+    pretext_messages.append(f"in `{principal_account_id}`")
+    pretext = " ".join(pretext_messages)
+
+    text = [
+        f"*Role ARN:* `{role_arn}`",
+        f"*Principal Account ID:* `{principal_account_id}`",
+        f"*Principal ID:* `{principal_id}`",
+        f"*Source IP:* `{source_ip}`",
+        f"*Source Identity:* `{source_identity}`" if source_identity else "",
+        f"*Timestamp:* `{timestamp}`",
+    ]
+    text = "\n".join(line for line in text if line)
+    for account_id, friendly_name in account_friendly_names.items():
+        pretext = pretext.replace(account_id, friendly_name)
+        fallback = fallback.replace(account_id, friendly_name)
+    return {
+        "attachments": [
+            {
+                "pretext": pretext,
+                "color": "warning",
+                "text": text,
+                "fallback": fallback,
+                "mrkdwn_in": ["pretext", "text"],
+            }
+        ]
+    }
+
+
+def get_fallback_slack_payload_for_event(
+    event, account_friendly_names, fallback_parse_behavior=""
+):
+    """Parse a generic CloudTrail event related to an API call
+    and return a Slack-formatted attachment"""
+    event_account_id = event["account"]
+    event_detail = event["detail"]
+    event_name = event_detail["eventName"]
+    event_type = event_detail["eventType"]
+    event_time = event_detail["eventTime"]
+    pretext = f":warning: CloudTrail event in account `{event_account_id}`"
+    fallback = f"CloudTrail event in account '{event_account_id}'"
+    if fallback_parse_behavior == "DUMP_EVENT":
+        text = "\n".join(
+            ["*Event:*", "```", json.dumps(event, sort_keys=True, indent=2), "```"]
+        )
+    else:
+        error_message = event_detail.get("errorMessage", "")
+        # This may be None, in which case we force it to an empty dict instead
+        response_element = (event_detail.get("responseElements", {}) or {}).get(
+            event_name, ""
+        )
+        user_identity = event_detail["userIdentity"]
+        principal_id = user_identity.get("principalId", "")
+        principal_type = user_identity.get("type", "")
+        principal_account_id = user_identity.get("accountId", "")
+        principal_arn = user_identity.get("arn", "")
+        source_ip = event_detail.get("sourceIPAddress", "")
+        resources = event_detail.get("resources", []) or []
+        text = [
+            f"*Event Type:* `{event_type}`",
+            f"*Event Name:* `{event_name}`",
+            f"*Event Time:* `{event_time}`",
+            f"*Error Message:* `{error_message}`" if error_message else "",
+            f"*Response Code:* `{response_element}`" if response_element else "",
+            f"*Principal Type:* `{principal_type}`" if principal_type else "",
+            f"*Principal Account ID:* `{principal_account_id}`"
+            if principal_account_id
+            else "",
+            f"*Principal ARN:* `{principal_arn}`" if principal_arn else "",
+            f"*Principal ID:* `{principal_id}`" if principal_id else "",
+            f"*Source IP:* `{source_ip}`" if source_ip else "",
+            f"*Resources:*\n```{json.dumps(resources, indent=2, sort_keys=True)}\n```"
+            if len(resources)
+            else "",
+        ]
+        # Filter out empty strings
+        text = "\n".join(line for line in text if line)
+
+    for account_id, friendly_name in account_friendly_names.items():
+        pretext = pretext.replace(account_id, friendly_name)
+        fallback = fallback.replace(account_id, friendly_name)
+    return {
+        "attachments": [
+            {
+                "pretext": pretext,
+                "color": "warning",
+                "text": text,
+                "fallback": fallback,
+                "mrkdwn_in": ["pretext", "text"],
+            }
+        ]
+    }
+
+
+def get_augmented_account_friendly_names(event, account_friendly_names):
+    """Return an augmented dictionary containing the alias of the current
+    AWS account if relevant"""
+    augmented_account_friendly_names = {**account_friendly_names}
+    try:
+        event_account_id = event["account"]
+        event_detail = event["detail"]
+        recipient_account_id = event_detail["recipientAccountId"]
+        if (
+            not augmented_account_friendly_names.get(event_account_id, "")
+            and event_account_id == recipient_account_id
+        ):
+            logger.info(
+                "No friendly name was supplied for current account '%s', so looking up account alias",
+                event_account_id,
+            )
+            iam = boto3.client("iam")
+            aliases = iam.list_account_aliases()["AccountAliases"]
+            if len(aliases):
+                augmented_account_friendly_names[event_account_id] = aliases[0]
+    except:
+        logger.exception("Failed to look up alias of current AWS account")
+
+    return augmented_account_friendly_names
+
+
+def post_to_slack(slack_payload, slack_webhook_url):
+    """Post a payload to Slack's webhook API"""
+    encoded_slack_payload = json.dumps(slack_payload).encode("utf-8")
+    try:
+        slack_request = urllib.request.Request(
+            slack_webhook_url,
+            data=encoded_slack_payload,
+            headers={"Content-Type": "application/json"},
+        )
+        urllib.request.urlopen(slack_request)
+    except:
+        logger.exception("Failed to post to Slack")
+        raise
+
+
+def handler_event_transformer(event, context):
+    """Lambda handler for the event transformer Lambda"""
+    logger.info("Triggered with event: %s", json.dumps(event, indent=2))
+
+    account_friendly_names = json.loads(os.environ["ACCOUNT_FRIENDLY_NAMES"])
+    slack_webhook_url = os.environ["SLACK_WEBHOOK_URL"]
+    slack_channel = os.environ["SLACK_CHANNEL"]
+    sqs_queue_url = os.environ.get("SQS_QUEUE_URL", "")
+    fallback_parse_behavior = os.environ.get("FALLBACK_PARSE_BEHAVIOR", "")
+    deduplicate_events = os.environ.get("DEDUPLICATE_EVENTS", "false") == "true"
+
+    account_friendly_names = get_augmented_account_friendly_names(
+        event, account_friendly_names
+    )
+
+    if not event["detail-type"].endswith("via CloudTrail"):
+        logger.warn("Invalid event received")
+        return
+
+    slack_payload = {}
+    try:
+        if event["detail"]["eventName"] == "AssumeRole":
+            slack_payload = get_slack_payload_for_assume_role_event(
+                event, account_friendly_names
+            )
+    except:
+        logger.exception("Failed to parse event using predefined schema")
+    if not slack_payload:
+        logger.warn("Using a fallback schema to parse event")
+        slack_payload = get_fallback_slack_payload_for_event(
+            event,
+            account_friendly_names,
+            fallback_parse_behavior=fallback_parse_behavior,
+        )
+    slack_payload = {**slack_payload, "channel": slack_channel}
+
+    if deduplicate_events and sqs_queue_url:
+        logger.info("Sending message to SQS for deduplication")
+        deduplication_id = (
+            event["detail"].get("requestID", "")
+            or event["detail"].get("eventID", "")
+            or event["id"]
+        )
+        body = {
+            "slackWebhookUrl": slack_webhook_url,
+            "slackPayload": slack_payload,
+        }
+
+        sqs = boto3.client("sqs")
+        sqs.send_message(
+            QueueUrl=sqs_queue_url,
+            MessageBody=json.dumps(body),
+            MessageDeduplicationId=deduplication_id,
+            MessageGroupId=deduplication_id,
+        )
+    else:
+        logger.info("Sending message directly to Slack")
+        post_to_slack(slack_payload, slack_webhook_url)
+
+
+def handler_slack_forwarder(event, context):
+    """Lambda handler for the Slack forwarder Lambda"""
+    logger.info("Triggered with event: %s", json.dumps(event, indent=2))
+    records = event["Records"]
+    for record in records:
+        body = json.loads(record["body"])
+        slack_channel = body.get("slackChannel", "")
+        slack_webhook_url = body.get("slackWebhookUrl", "")
+        slack_payload = {
+            **body["slackPayload"],
+            **({"channel": slack_channel} if slack_channel else {}),
+        }
+        post_to_slack(slack_payload, slack_webhook_url)

package/lib/cdk-deploy/start-deploy-handler.js

@@ -69,4 +69,4 @@ const startDeployHandler = async (event, context) => {
     };
 };
 exports.startDeployHandler = startDeployHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cloudtrail-slack-integration/cloudtrail-slack-integration.d.ts

@@ -0,0 +1,43 @@
+import * as cdk from "@aws-cdk/core";
+import * as cloudwatch from "@aws-cdk/aws-cloudwatch";
+export interface CloudTrailSlackIntegrationProps extends cdk.StackProps {
+    /**
+     * A key-value pair of AWS account IDs and friendly names of these accounts
+     * to use when sending messages to Slack.
+     */
+    accountFriendlyNames?: {
+        [key: string]: string;
+    };
+    slackWebhookUrl: string;
+    slackChannel: string;
+    /**
+     * A list of ARNs of roles in the current account to monitor usage of.
+     */
+    rolesToMonitor?: string[];
+    /**
+     * Whether to monitor various IAM API calls associated with the current account's root user (e.g., console login, password reset, etc.)
+     *
+     * @default true
+     */
+    monitorRootUserActions?: boolean;
+    /**
+     * Whether to set up additional AWS infrastructure to deduplicate CloudTrail events in order to avoid duplicate Slack messages. May be used to decrease noise.
+     *
+     * @default false
+     */
+    deduplicateEvents?: boolean;
+    /**
+     * If supplied, CloudWatch alarms will be created for the construct's underlying infrastructure (e.g., Lambda functions) and the action will be used to notify on OK and ALARM actions.
+     */
+    infrastructureAlarmAction?: cloudwatch.IAlarmAction;
+}
+/**
+ * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda
+ * and an optional SQS FIFO queue for deduplicating events.
+ * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.
+ *
+ * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.
+ */
+export declare class CloudTrailSlackIntegration extends cdk.Construct {
+    constructor(scope: cdk.Construct, id: string, props: CloudTrailSlackIntegrationProps);
+}

package/lib/cloudtrail-slack-integration/cloudtrail-slack-integration.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudTrailSlackIntegration = void 0;
+const cdk = require("@aws-cdk/core");
+const iam = require("@aws-cdk/aws-iam");
+const logs = require("@aws-cdk/aws-logs");
+const cloudwatch = require("@aws-cdk/aws-cloudwatch");
+const lambda = require("@aws-cdk/aws-lambda");
+const events = require("@aws-cdk/aws-events");
+const sources = require("@aws-cdk/aws-lambda-event-sources");
+const sqs = require("@aws-cdk/aws-sqs");
+const targets = require("@aws-cdk/aws-events-targets");
+const path = require("path");
+/**
+ * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda
+ * and an optional SQS FIFO queue for deduplicating events.
+ * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.
+ *
+ * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.
+ */
+class CloudTrailSlackIntegration extends cdk.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const eventTransformer = new lambda.Function(this, "EventTransformerLambda", {
+            code: lambda.Code.fromAsset(path.join(__dirname, "../../assets/cloudtrail-slack-integration-lambda")),
+            description: "Formats CloudTrail API calls sent through EventBridge, and posts them directly to Slack or first to an SQS FIFO queue for deduplication",
+            handler: "main.handler_event_transformer",
+            runtime: lambda.Runtime.PYTHON_3_9,
+            timeout: cdk.Duration.seconds(15),
+            logRetention: logs.RetentionDays.SIX_MONTHS,
+            environment: {
+                SLACK_CHANNEL: props.slackChannel,
+                DEDUPLICATE_EVENTS: JSON.stringify(!!props.deduplicateEvents),
+                ACCOUNT_FRIENDLY_NAMES: JSON.stringify(props.accountFriendlyNames || {}),
+                SLACK_WEBHOOK_URL: props.slackWebhookUrl,
+            },
+        });
+        eventTransformer.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["iam:ListAccountAliases"],
+            resources: ["*"],
+        }));
+        if (props.infrastructureAlarmAction) {
+            const eventTransformerAlarm = eventTransformer
+                .metricErrors({
+                period: cdk.Duration.minutes(5),
+                statistic: cloudwatch.Statistic.SUM,
+            })
+                .createAlarm(this, "EventTransformerErrorAlarm", {
+                threshold: 1,
+                evaluationPeriods: 1,
+                alarmDescription: "Triggers if the Lambda function that transforms CloudTrail API calls received through EventBridge fails (e.g., it fails to process the event)",
+                datapointsToAlarm: 1,
+                treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+            });
+            eventTransformerAlarm.addOkAction(props.infrastructureAlarmAction);
+            eventTransformerAlarm.addAlarmAction(props.infrastructureAlarmAction);
+        }
+        if (props.deduplicateEvents) {
+            const deduplicationQueue = new sqs.Queue(this, "Queue", {
+                // We explicitly give the queue a name due to bug https://github.com/aws/aws-cdk/issues/5860
+                queueName: `${this.node.id.substring(0, 33)}${this.node.addr}`.substring(0, 75) +
+                    ".fifo",
+                fifo: true,
+            });
+            eventTransformer.addEnvironment("SQS_QUEUE_URL", deduplicationQueue.queueUrl);
+            deduplicationQueue.grantSendMessages(eventTransformer);
+            const slackForwarder = new lambda.Function(this, "SlackForwarderLambda", {
+                code: lambda.Code.fromAsset(path.join(__dirname, "../../assets/cloudtrail-slack-integration-lambda")),
+                description: "Polls from an SQS FIFO queue containing formatted CloudTrail API calls and sends them to Slack.",
+                handler: "main.handler_slack_forwarder",
+                runtime: lambda.Runtime.PYTHON_3_9,
+                timeout: cdk.Duration.seconds(15),
+                logRetention: logs.RetentionDays.TWO_WEEKS,
+            });
+            if (props.infrastructureAlarmAction) {
+                const slackForwarderAlarm = slackForwarder
+                    .metricErrors({
+                    period: cdk.Duration.minutes(5),
+                    statistic: cloudwatch.Statistic.SUM,
+                })
+                    .createAlarm(this, "SlackForwarderErrorAlarm", {
+                    threshold: 1,
+                    alarmDescription: "Triggers if the Lambda function that polls from SQS and posts deduplicated CloudTrail API calls received through EventBridge to Slack fails (e.g., invalid Slack webhook URL)",
+                    evaluationPeriods: 1,
+                    datapointsToAlarm: 1,
+                    treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+                });
+                slackForwarderAlarm.addOkAction(props.infrastructureAlarmAction);
+                slackForwarderAlarm.addAlarmAction(props.infrastructureAlarmAction);
+            }
+            slackForwarder.addEventSource(new sources.SqsEventSource(deduplicationQueue));
+        }
+        if (props.rolesToMonitor && props.rolesToMonitor.length > 0) {
+            new events.Rule(this, "RuleForAssumeRole", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        eventName: ["AssumeRole"],
+                        requestParameters: {
+                            roleArn: props.rolesToMonitor,
+                        },
+                    },
+                },
+            });
+        }
+        if (props.monitorRootUserActions !== false) {
+            // Triggers when the root password has been changed
+            new events.Rule(this, "RuleForRootUserPasswordChange", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordUpdated"],
+                        eventType: ["AwsConsoleSignIn"],
+                    },
+                },
+            });
+            // Triggers when MFA for the root user has been set up
+            new events.Rule(this, "RuleForRootUserMfaChange", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["EnableMFADevice"],
+                        requestParameters: {
+                            userName: ["AWS ROOT USER"],
+                        },
+                    },
+                },
+            });
+            // Triggers when a root user succesfully logs in to the console
+            new events.Rule(this, "RuleForRootUserSuccessfulLogin", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["ConsoleLogin"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            ConsoleLogin: ["Success"],
+                        },
+                    },
+                },
+            });
+            // Triggers for bad login attemps for root user (e.g., wrong password)
+            new events.Rule(this, "RuleForRootUserUnsuccessfulLogin", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["ConsoleLogin"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            ConsoleLogin: ["Failure"],
+                        },
+                    },
+                },
+            });
+            // Triggered when password reset has been requested
+            new events.Rule(this, "RuleForRootUserPasswordRecoveryRequest", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordRecoveryRequested"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            PasswordRecoveryRequested: ["Success"],
+                        },
+                    },
+                },
+            });
+            // Triggered when password has been successfully reset
+            new events.Rule(this, "RuleForRootUserPasswordRecoveryComplete", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordRecoveryCompleted"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            PasswordRecoveryCompleted: ["Success"],
+                        },
+                    },
+                },
+            });
+        }
+    }
+}
+exports.CloudTrailSlackIntegration = CloudTrailSlackIntegration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudtrail-slack-integration.js","sourceRoot":"","sources":["../../src/cloudtrail-slack-integration/cloudtrail-slack-integration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"@aws-cdk/core\"\nimport * as iam from \"@aws-cdk/aws-iam\"\nimport * as logs from \"@aws-cdk/aws-logs\"\nimport * as cloudwatch from \"@aws-cdk/aws-cloudwatch\"\nimport * as lambda from \"@aws-cdk/aws-lambda\"\nimport * as events from \"@aws-cdk/aws-events\"\nimport * as sources from \"@aws-cdk/aws-lambda-event-sources\"\nimport * as sqs from \"@aws-cdk/aws-sqs\"\nimport * as targets from \"@aws-cdk/aws-events-targets\"\nimport * as path from \"path\"\n\nexport interface CloudTrailSlackIntegrationProps extends cdk.StackProps {\n  /**\n   * A key-value pair of AWS account IDs and friendly names of these accounts\n   * to use when sending messages to Slack.\n   */\n  accountFriendlyNames?: {\n    [key: string]: string\n  }\n  slackWebhookUrl: string\n  slackChannel: string\n  /**\n   * A list of ARNs of roles in the current account to monitor usage of.\n   */\n  rolesToMonitor?: string[]\n  /**\n   * Whether to monitor various IAM API calls associated with the current account's root user (e.g., console login, password reset, etc.)\n   *\n   * @default true\n   */\n  monitorRootUserActions?: boolean\n  /**\n   * Whether to set up additional AWS infrastructure to deduplicate CloudTrail events in order to avoid duplicate Slack messages. May be used to decrease noise.\n   *\n   * @default false\n   */\n  deduplicateEvents?: boolean\n  /**\n   * If supplied, CloudWatch alarms will be created for the construct's underlying infrastructure (e.g., Lambda functions) and the action will be used to notify on OK and ALARM actions.\n   */\n  infrastructureAlarmAction?: cloudwatch.IAlarmAction\n}\n\n/**\n * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda\n * and an optional SQS FIFO queue for deduplicating events.\n * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.\n *\n * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.\n */\nexport class CloudTrailSlackIntegration extends cdk.Construct {\n  constructor(\n    scope: cdk.Construct,\n    id: string,\n    props: CloudTrailSlackIntegrationProps,\n  ) {\n    super(scope, id)\n\n    const eventTransformer = new lambda.Function(\n      this,\n      \"EventTransformerLambda\",\n      {\n        code: lambda.Code.fromAsset(\n          path.join(\n            __dirname,\n            \"../../assets/cloudtrail-slack-integration-lambda\",\n          ),\n        ),\n        description:\n          \"Formats CloudTrail API calls sent through EventBridge, and posts them directly to Slack or first to an SQS FIFO queue for deduplication\",\n        handler: \"main.handler_event_transformer\",\n        runtime: lambda.Runtime.PYTHON_3_9,\n        timeout: cdk.Duration.seconds(15),\n        logRetention: logs.RetentionDays.SIX_MONTHS,\n        environment: {\n          SLACK_CHANNEL: props.slackChannel,\n          DEDUPLICATE_EVENTS: JSON.stringify(!!props.deduplicateEvents),\n          ACCOUNT_FRIENDLY_NAMES: JSON.stringify(\n            props.accountFriendlyNames || {},\n          ),\n          SLACK_WEBHOOK_URL: props.slackWebhookUrl,\n        },\n      },\n    )\n    eventTransformer.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"iam:ListAccountAliases\"],\n        resources: [\"*\"],\n      }),\n    )\n    if (props.infrastructureAlarmAction) {\n      const eventTransformerAlarm = eventTransformer\n        .metricErrors({\n          period: cdk.Duration.minutes(5),\n          statistic: cloudwatch.Statistic.SUM,\n        })\n        .createAlarm(this, \"EventTransformerErrorAlarm\", {\n          threshold: 1,\n          evaluationPeriods: 1,\n          alarmDescription:\n            \"Triggers if the Lambda function that transforms CloudTrail API calls received through EventBridge fails (e.g., it fails to process the event)\",\n          datapointsToAlarm: 1,\n          treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n        })\n      eventTransformerAlarm.addOkAction(props.infrastructureAlarmAction)\n      eventTransformerAlarm.addAlarmAction(props.infrastructureAlarmAction)\n    }\n    if (props.deduplicateEvents) {\n      const deduplicationQueue = new sqs.Queue(this, \"Queue\", {\n        // We explicitly give the queue a name due to bug https://github.com/aws/aws-cdk/issues/5860\n        queueName:\n          `${this.node.id.substring(0, 33)}${this.node.addr}`.substring(0, 75) +\n          \".fifo\",\n        fifo: true,\n      })\n      eventTransformer.addEnvironment(\n        \"SQS_QUEUE_URL\",\n        deduplicationQueue.queueUrl,\n      )\n      deduplicationQueue.grantSendMessages(eventTransformer)\n      const slackForwarder = new lambda.Function(this, \"SlackForwarderLambda\", {\n        code: lambda.Code.fromAsset(\n          path.join(\n            __dirname,\n            \"../../assets/cloudtrail-slack-integration-lambda\",\n          ),\n        ),\n        description:\n          \"Polls from an SQS FIFO queue containing formatted CloudTrail API calls and sends them to Slack.\",\n        handler: \"main.handler_slack_forwarder\",\n        runtime: lambda.Runtime.PYTHON_3_9,\n        timeout: cdk.Duration.seconds(15),\n        logRetention: logs.RetentionDays.TWO_WEEKS,\n      })\n\n      if (props.infrastructureAlarmAction) {\n        const slackForwarderAlarm = slackForwarder\n          .metricErrors({\n            period: cdk.Duration.minutes(5),\n            statistic: cloudwatch.Statistic.SUM,\n          })\n          .createAlarm(this, \"SlackForwarderErrorAlarm\", {\n            threshold: 1,\n            alarmDescription:\n              \"Triggers if the Lambda function that polls from SQS and posts deduplicated CloudTrail API calls received through EventBridge to Slack fails (e.g., invalid Slack webhook URL)\",\n            evaluationPeriods: 1,\n            datapointsToAlarm: 1,\n            treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n          })\n        slackForwarderAlarm.addOkAction(props.infrastructureAlarmAction)\n        slackForwarderAlarm.addAlarmAction(props.infrastructureAlarmAction)\n      }\n      slackForwarder.addEventSource(\n        new sources.SqsEventSource(deduplicationQueue),\n      )\n    }\n\n    if (props.rolesToMonitor && props.rolesToMonitor.length > 0) {\n      new events.Rule(this, \"RuleForAssumeRole\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            eventName: [\"AssumeRole\"],\n            requestParameters: {\n              roleArn: props.rolesToMonitor,\n            },\n          },\n        },\n      })\n    }\n\n    if (props.monitorRootUserActions !== false) {\n      // Triggers when the root password has been changed\n      new events.Rule(this, \"RuleForRootUserPasswordChange\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordUpdated\"],\n            eventType: [\"AwsConsoleSignIn\"],\n          },\n        },\n      })\n\n      // Triggers when MFA for the root user has been set up\n      new events.Rule(this, \"RuleForRootUserMfaChange\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"EnableMFADevice\"],\n            requestParameters: {\n              userName: [\"AWS ROOT USER\"],\n            },\n          },\n        },\n      })\n\n      // Triggers when a root user succesfully logs in to the console\n      new events.Rule(this, \"RuleForRootUserSuccessfulLogin\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"ConsoleLogin\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              ConsoleLogin: [\"Success\"],\n            },\n          },\n        },\n      })\n\n      // Triggers for bad login attemps for root user (e.g., wrong password)\n      new events.Rule(this, \"RuleForRootUserUnsuccessfulLogin\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"ConsoleLogin\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              ConsoleLogin: [\"Failure\"],\n            },\n          },\n        },\n      })\n\n      // Triggered when password reset has been requested\n      new events.Rule(this, \"RuleForRootUserPasswordRecoveryRequest\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordRecoveryRequested\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              PasswordRecoveryRequested: [\"Success\"],\n            },\n          },\n        },\n      })\n\n      // Triggered when password has been successfully reset\n      new events.Rule(this, \"RuleForRootUserPasswordRecoveryComplete\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordRecoveryCompleted\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              PasswordRecoveryCompleted: [\"Success\"],\n            },\n          },\n        },\n      })\n    }\n  }\n}\n"]}

package/lib/cloudtrail-slack-integration/index.d.ts

@@ -0,0 +1 @@
+export { CloudTrailSlackIntegration, CloudTrailSlackIntegrationProps, } from "./cloudtrail-slack-integration";

package/lib/cloudtrail-slack-integration/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudTrailSlackIntegration = void 0;
+var cloudtrail_slack_integration_1 = require("./cloudtrail-slack-integration");
+Object.defineProperty(exports, "CloudTrailSlackIntegration", { enumerable: true, get: function () { return cloudtrail_slack_integration_1.CloudTrailSlackIntegration; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xvdWR0cmFpbC1zbGFjay1pbnRlZ3JhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrRUFHdUM7QUFGckMsMElBQUEsMEJBQTBCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBDbG91ZFRyYWlsU2xhY2tJbnRlZ3JhdGlvbixcbiAgQ2xvdWRUcmFpbFNsYWNrSW50ZWdyYXRpb25Qcm9wcyxcbn0gZnJvbSBcIi4vY2xvdWR0cmFpbC1zbGFjay1pbnRlZ3JhdGlvblwiXG4iXX0=

package/lib/index.d.ts

@@ -7,6 +7,7 @@ import * as webapp from "./webapp";
 import * as configureParameters from "./configure-parameters";
 import * as ecs from "./ecs";
 import * as loadBalancer from "./load-balancer";
+import * as cloudTrailSlackIntegration from "./cloudtrail-slack-integration";
 import * as rds from "./rds";
 import * as platform from "./platform";
 export { BastionHost } from "./bastion-host";
@@ -20,7 +21,7 @@ export { SsmParameterBackedResource } from "./ssm-parameter-backed-resource";
 export { SsmParameterReader } from "./ssm-parameter-reader";
 export { tagResources } from "./tags";
 export { WebappDeployViaRole } from "./webapp-deploy-via-role";
-export { alarms, cdkPipelines, griid, pipelines, ses, webapp, configureParameters, ecs, loadBalancer, rds, platform, };
+export { alarms, cdkPipelines, griid, pipelines, ses, webapp, configureParameters, ecs, loadBalancer, rds, platform, cloudTrailSlackIntegration, };
 /**
  * Check if we are synthesizing a snapshot by setting IS_SNAPSHOT
  * environment variable to true.

package/lib/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSnapshot = exports.platform = exports.rds = exports.loadBalancer = exports.ecs = exports.configureParameters = exports.webapp = exports.ses = exports.pipelines = exports.griid = exports.cdkPipelines = exports.alarms = exports.WebappDeployViaRole = exports.tagResources = exports.SsmParameterReader = exports.SsmParameterBackedResource = exports.createCloudAssemblySnapshot = exports.HostedZoneWithParam = exports.CrossRegionSsmParameter = exports.BastionHost = void 0;
+exports.isSnapshot = exports.cloudTrailSlackIntegration = exports.platform = exports.rds = exports.loadBalancer = exports.ecs = exports.configureParameters = exports.webapp = exports.ses = exports.pipelines = exports.griid = exports.cdkPipelines = exports.alarms = exports.WebappDeployViaRole = exports.tagResources = exports.SsmParameterReader = exports.SsmParameterBackedResource = exports.createCloudAssemblySnapshot = exports.HostedZoneWithParam = exports.CrossRegionSsmParameter = exports.BastionHost = void 0;
 const alarms = require("./alarms");
 exports.alarms = alarms;
 const cdkPipelines = require("./cdk-pipelines");
@@ -29,6 +29,8 @@ const ecs = require("./ecs");
 exports.ecs = ecs;
 const loadBalancer = require("./load-balancer");
 exports.loadBalancer = loadBalancer;
+const cloudTrailSlackIntegration = require("./cloudtrail-slack-integration");
+exports.cloudTrailSlackIntegration = cloudTrailSlackIntegration;
 const rds = require("./rds");
 exports.rds = rds;
 const platform = require("./platform");
@@ -62,4 +64,4 @@ Object.defineProperty(exports, "WebappDeployViaRole", { enumerable: true, get: f
  * happen during snapshot creation.
  */
 exports.isSnapshot = process.env.IS_SNAPSHOT === "true";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/kinesis/kinesis-to-datadog-stream.d.ts

@@ -14,13 +14,14 @@ export interface KinesisToDatadogStreamProps {
      * The CloudWatch log groups from you are streaming to Datadog
      *
      */
-    logGroups: logs.LogGroup[];
+    logGroups: logs.ILogGroup[];
 }
 /**
  *
  * Forwards logs from log-groups in CloudWatch to a Datadog account.
  * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.
  *
+ * @author Stein-Aage
  */
 export declare class KinesisToDatadogStream extends cdk.Construct {
     constructor(scope: cdk.Construct, id: string, props: KinesisToDatadogStreamProps);

package/lib/kinesis/kinesis-to-datadog-stream.js

@@ -13,6 +13,7 @@ const cdk = require("@aws-cdk/core");
  * Forwards logs from log-groups in CloudWatch to a Datadog account.
  * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.
  *
+ * @author Stein-Aage
  */
 class KinesisToDatadogStream extends cdk.Construct {
     constructor(scope, id, props) {
@@ -121,4 +122,4 @@ class KinesisToDatadogStream extends cdk.Construct {
     }
 }
 exports.KinesisToDatadogStream = KinesisToDatadogStream;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kinesis-to-datadog-stream.js","sourceRoot":"","sources":["../../src/kinesis/kinesis-to-datadog-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from \"@aws-cdk/aws-iam\"\nimport * as firehose from \"@aws-cdk/aws-kinesisfirehose\"\nimport * as logs from \"@aws-cdk/aws-logs\"\nimport * as s3 from \"@aws-cdk/aws-s3\"\nimport { BlockPublicAccess } from \"@aws-cdk/aws-s3\"\nimport * as secretsmanager from \"@aws-cdk/aws-secretsmanager\"\nimport * as cdk from \"@aws-cdk/core\"\n\nexport interface KinesisToDatadogStreamProps {\n  /**\n   *\n   * The name of the SecretsManager secret where your Datadog API key is saved.\n   *\n   * The secret must be a JSON object on the format { \"value\": \"SECRET\" }\n   *\n   */\n  datadogApiKeySecretName: string\n  /**\n   *\n   * The CloudWatch log groups from you are streaming to Datadog\n   *\n   */\n  logGroups: logs.LogGroup[]\n}\n\n/**\n *\n * Forwards logs from log-groups in CloudWatch to a Datadog account.\n * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.\n *\n */\nexport class KinesisToDatadogStream extends cdk.Construct {\n  constructor(\n    scope: cdk.Construct,\n    id: string,\n    props: KinesisToDatadogStreamProps,\n  ) {\n    super(scope, id)\n\n    const deliveryStreamLogGroup = new logs.LogGroup(\n      this,\n      \"DeliveryStreamLogGroup\",\n    )\n\n    const deliveryStreamLogStream = new logs.LogStream(\n      this,\n      \"DeliveryStreamLogStream\",\n      {\n        logGroup: deliveryStreamLogGroup,\n      },\n    )\n\n    const failedDataBucket = new s3.Bucket(this, \"FailedDataBucket\", {\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n    })\n\n    const cloudWatchLogsRole = new iam.Role(this, \"CloudWatchLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\n        `logs.${cdk.Stack.of(this).region}.amazonaws.com`,\n      ),\n    })\n\n    const firehoseLogsRole = new iam.Role(this, \"FirehoseLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\"firehose.amazonaws.com\"),\n    })\n\n    const datadogDeliveryStream = new firehose.CfnDeliveryStream(\n      this,\n      \"DeliveryStream\",\n      {\n        deliveryStreamType: \"DirectPut\",\n        httpEndpointDestinationConfiguration: {\n          roleArn: firehoseLogsRole.roleArn,\n          endpointConfiguration: {\n            url: \"https://aws-kinesis-http-intake.logs.datadoghq.eu/v1/input\",\n            accessKey: secretsmanager.Secret.fromSecretNameV2(\n              scope,\n              \"DatadogApiKey\",\n              props.datadogApiKeySecretName,\n            )\n              .secretValueFromJson(\"value\")\n              .toString(),\n            name: \"datadog-logs-endpoint\",\n          },\n          requestConfiguration: {\n            contentEncoding: \"GZIP\",\n          },\n          cloudWatchLoggingOptions: {\n            enabled: true,\n            logGroupName: deliveryStreamLogGroup.logGroupName,\n            logStreamName: deliveryStreamLogStream.logStreamName,\n          },\n          bufferingHints: {\n            intervalInSeconds: 60,\n            sizeInMBs: 4,\n          },\n          retryOptions: {\n            durationInSeconds: 60,\n          },\n          s3BackupMode: \"FailedDataOnly\",\n          s3Configuration: {\n            bucketArn: failedDataBucket.bucketArn,\n            compressionFormat: \"UNCOMPRESSED\",\n            roleArn: firehoseLogsRole.roleArn,\n          },\n        },\n      },\n    )\n\n    new iam.Policy(this, \"CloudWatchLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\"firehose:PutRecord\", \"firehose:PutRecordBatch\"],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [cloudWatchLogsRole],\n    })\n\n    new iam.Policy(this, \"FirehoseLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\n              \"s3:AbortMultipartUpload\",\n              \"s3:GetBucketLocation\",\n              \"s3:GetObject\",\n              \"s3:ListBucket\",\n              \"s3:ListBucketMultipartUploads\",\n              \"s3:PutObject\",\n            ],\n            resources: [\n              failedDataBucket.bucketArn,\n              `${failedDataBucket.bucketArn}/*`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\"logs:PutLogEvents\"],\n            resources: [\n              `arn:aws:logs:${cdk.Stack.of(this).region}:${\n                cdk.Stack.of(this).account\n              }:log-group:${deliveryStreamLogGroup.logGroupName}:log-stream:${\n                deliveryStreamLogStream.logStreamName\n              }`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\n              \"kinesis:DescribeStream\",\n              \"kinesis:GetShardIterator\",\n              \"kinesis:GetRecords\",\n            ],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [firehoseLogsRole],\n    })\n\n    props.logGroups.forEach((logGroup, index) => {\n      new logs.CfnSubscriptionFilter(this, `SubscriptionFilter${index}`, {\n        logGroupName: logGroup.logGroupName,\n        destinationArn: datadogDeliveryStream.attrArn,\n        filterPattern: logs.FilterPattern.allEvents().logPatternString,\n        roleArn: cloudWatchLogsRole.roleArn,\n      })\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kinesis-to-datadog-stream.js","sourceRoot":"","sources":["../../src/kinesis/kinesis-to-datadog-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import * as iam from \"@aws-cdk/aws-iam\"\nimport * as firehose from \"@aws-cdk/aws-kinesisfirehose\"\nimport * as logs from \"@aws-cdk/aws-logs\"\nimport * as s3 from \"@aws-cdk/aws-s3\"\nimport { BlockPublicAccess } from \"@aws-cdk/aws-s3\"\nimport * as secretsmanager from \"@aws-cdk/aws-secretsmanager\"\nimport * as cdk from \"@aws-cdk/core\"\n\nexport interface KinesisToDatadogStreamProps {\n  /**\n   *\n   * The name of the SecretsManager secret where your Datadog API key is saved.\n   *\n   * The secret must be a JSON object on the format { \"value\": \"SECRET\" }\n   *\n   */\n  datadogApiKeySecretName: string\n  /**\n   *\n   * The CloudWatch log groups from you are streaming to Datadog\n   *\n   */\n  logGroups: logs.ILogGroup[]\n}\n\n/**\n *\n * Forwards logs from log-groups in CloudWatch to a Datadog account.\n * The logs are delivered through a Firehose delivery stream, which is being subscribed to the log-groups in CloudWatch.\n *\n * @author Stein-Aage\n */\nexport class KinesisToDatadogStream extends cdk.Construct {\n  constructor(\n    scope: cdk.Construct,\n    id: string,\n    props: KinesisToDatadogStreamProps,\n  ) {\n    super(scope, id)\n\n    const deliveryStreamLogGroup = new logs.LogGroup(\n      this,\n      \"DeliveryStreamLogGroup\",\n    )\n\n    const deliveryStreamLogStream = new logs.LogStream(\n      this,\n      \"DeliveryStreamLogStream\",\n      {\n        logGroup: deliveryStreamLogGroup,\n      },\n    )\n\n    const failedDataBucket = new s3.Bucket(this, \"FailedDataBucket\", {\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n    })\n\n    const cloudWatchLogsRole = new iam.Role(this, \"CloudWatchLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\n        `logs.${cdk.Stack.of(this).region}.amazonaws.com`,\n      ),\n    })\n\n    const firehoseLogsRole = new iam.Role(this, \"FirehoseLogsRole\", {\n      assumedBy: new iam.ServicePrincipal(\"firehose.amazonaws.com\"),\n    })\n\n    const datadogDeliveryStream = new firehose.CfnDeliveryStream(\n      this,\n      \"DeliveryStream\",\n      {\n        deliveryStreamType: \"DirectPut\",\n        httpEndpointDestinationConfiguration: {\n          roleArn: firehoseLogsRole.roleArn,\n          endpointConfiguration: {\n            url: \"https://aws-kinesis-http-intake.logs.datadoghq.eu/v1/input\",\n            accessKey: secretsmanager.Secret.fromSecretNameV2(\n              scope,\n              \"DatadogApiKey\",\n              props.datadogApiKeySecretName,\n            )\n              .secretValueFromJson(\"value\")\n              .toString(),\n            name: \"datadog-logs-endpoint\",\n          },\n          requestConfiguration: {\n            contentEncoding: \"GZIP\",\n          },\n          cloudWatchLoggingOptions: {\n            enabled: true,\n            logGroupName: deliveryStreamLogGroup.logGroupName,\n            logStreamName: deliveryStreamLogStream.logStreamName,\n          },\n          bufferingHints: {\n            intervalInSeconds: 60,\n            sizeInMBs: 4,\n          },\n          retryOptions: {\n            durationInSeconds: 60,\n          },\n          s3BackupMode: \"FailedDataOnly\",\n          s3Configuration: {\n            bucketArn: failedDataBucket.bucketArn,\n            compressionFormat: \"UNCOMPRESSED\",\n            roleArn: firehoseLogsRole.roleArn,\n          },\n        },\n      },\n    )\n\n    new iam.Policy(this, \"CloudWatchLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\"firehose:PutRecord\", \"firehose:PutRecordBatch\"],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [cloudWatchLogsRole],\n    })\n\n    new iam.Policy(this, \"FirehoseLogsPolicy\", {\n      document: new iam.PolicyDocument({\n        statements: [\n          new iam.PolicyStatement({\n            actions: [\n              \"s3:AbortMultipartUpload\",\n              \"s3:GetBucketLocation\",\n              \"s3:GetObject\",\n              \"s3:ListBucket\",\n              \"s3:ListBucketMultipartUploads\",\n              \"s3:PutObject\",\n            ],\n            resources: [\n              failedDataBucket.bucketArn,\n              `${failedDataBucket.bucketArn}/*`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\"logs:PutLogEvents\"],\n            resources: [\n              `arn:aws:logs:${cdk.Stack.of(this).region}:${\n                cdk.Stack.of(this).account\n              }:log-group:${deliveryStreamLogGroup.logGroupName}:log-stream:${\n                deliveryStreamLogStream.logStreamName\n              }`,\n            ],\n          }),\n          new iam.PolicyStatement({\n            actions: [\n              \"kinesis:DescribeStream\",\n              \"kinesis:GetShardIterator\",\n              \"kinesis:GetRecords\",\n            ],\n            resources: [datadogDeliveryStream.attrArn],\n          }),\n        ],\n      }),\n      roles: [firehoseLogsRole],\n    })\n\n    props.logGroups.forEach((logGroup, index) => {\n      new logs.CfnSubscriptionFilter(this, `SubscriptionFilter${index}`, {\n        logGroupName: logGroup.logGroupName,\n        destinationArn: datadogDeliveryStream.attrArn,\n        filterPattern: logs.FilterPattern.allEvents().logPatternString,\n        roleArn: cloudWatchLogsRole.roleArn,\n      })\n    })\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "1.50.0",
+  "version": "1.52.1",
   "description": "Experimental CDK library for Liflig",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
-    "test": "jest",
+    "test": "jest --runInBand",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "prepare": "npm run build && husky install",
@@ -34,50 +34,51 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aws-cdk/assert": "1.128.0",
-    "@aws-cdk/aws-certificatemanager": "1.128.0",
-    "@aws-cdk/aws-cloudfront": "1.128.0",
-    "@aws-cdk/aws-cloudfront-origins": "1.128.0",
-    "@aws-cdk/aws-cloudwatch": "1.128.0",
-    "@aws-cdk/aws-cloudwatch-actions": "1.128.0",
-    "@aws-cdk/aws-codebuild": "1.128.0",
-    "@aws-cdk/aws-codepipeline": "1.128.0",
-    "@aws-cdk/aws-codepipeline-actions": "1.128.0",
-    "@aws-cdk/aws-ecs": "1.128.0",
-    "@aws-cdk/aws-events-targets": "1.128.0",
-    "@aws-cdk/aws-iam": "1.128.0",
-    "@aws-cdk/aws-lambda": "1.128.0",
-    "@aws-cdk/aws-logs": "1.128.0",
-    "@aws-cdk/aws-rds": "1.128.0",
-    "@aws-cdk/aws-route53": "1.128.0",
-    "@aws-cdk/aws-route53-targets": "1.128.0",
-    "@aws-cdk/aws-s3": "1.128.0",
-    "@aws-cdk/aws-ses": "1.128.0",
-    "@aws-cdk/aws-sns": "1.128.0",
-    "@aws-cdk/aws-stepfunctions": "1.128.0",
-    "@aws-cdk/aws-stepfunctions-tasks": "1.128.0",
-    "@aws-cdk/core": "1.128.0",
-    "@aws-cdk/custom-resources": "1.128.0",
-    "@aws-cdk/pipelines": "1.128.0",
-    "@commitlint/cli": "13.2.1",
-    "@commitlint/config-conventional": "13.2.0",
-    "@types/aws-lambda": "8.10.85",
-    "@types/jest": "27.0.3",
-    "@types/node": "16.11.11",
-    "@typescript-eslint/eslint-plugin": "5.6.0",
-    "@typescript-eslint/parser": "5.6.0",
-    "aws-cdk": "1.128.0",
-    "eslint": "8.4.1",
+    "@aws-cdk/assert": "1.135.0",
+    "@aws-cdk/aws-certificatemanager": "1.135.0",
+    "@aws-cdk/aws-cloudfront": "1.135.0",
+    "@aws-cdk/aws-cloudfront-origins": "1.135.0",
+    "@aws-cdk/aws-cloudwatch": "1.135.0",
+    "@aws-cdk/aws-cloudwatch-actions": "1.135.0",
+    "@aws-cdk/aws-codebuild": "1.135.0",
+    "@aws-cdk/aws-codepipeline": "1.135.0",
+    "@aws-cdk/aws-codepipeline-actions": "1.135.0",
+    "@aws-cdk/aws-ecs": "1.135.0",
+    "@aws-cdk/aws-events-targets": "1.135.0",
+    "@aws-cdk/aws-iam": "1.135.0",
+    "@aws-cdk/aws-lambda": "1.135.0",
+    "@aws-cdk/aws-lambda-event-sources": "1.135.0",
+    "@aws-cdk/aws-logs": "1.135.0",
+    "@aws-cdk/aws-rds": "1.135.0",
+    "@aws-cdk/aws-route53": "1.135.0",
+    "@aws-cdk/aws-route53-targets": "1.135.0",
+    "@aws-cdk/aws-s3": "1.135.0",
+    "@aws-cdk/aws-ses": "1.135.0",
+    "@aws-cdk/aws-sns": "1.135.0",
+    "@aws-cdk/aws-stepfunctions": "1.135.0",
+    "@aws-cdk/aws-stepfunctions-tasks": "1.135.0",
+    "@aws-cdk/core": "1.135.0",
+    "@aws-cdk/custom-resources": "1.135.0",
+    "@aws-cdk/pipelines": "1.135.0",
+    "@commitlint/cli": "15.0.0",
+    "@commitlint/config-conventional": "15.0.0",
+    "@types/aws-lambda": "8.10.89",
+    "@types/jest": "27.4.0",
+    "@types/node": "16.11.17",
+    "@typescript-eslint/eslint-plugin": "5.8.1",
+    "@typescript-eslint/parser": "5.8.1",
+    "aws-cdk": "1.135.0",
+    "eslint": "8.6.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-prettier": "4.0.0",
     "husky": "7.0.4",
-    "jest": "27.3.1",
+    "jest": "27.4.5",
     "jest-cdk-snapshot": "1.4.2",
-    "prettier": "2.4.1",
+    "prettier": "2.5.1",
     "semantic-release": "18.0.1",
-    "ts-jest": "27.0.7",
+    "ts-jest": "27.1.2",
     "ts-node": "10.4.0",
-    "typescript": "4.5.2"
+    "typescript": "4.5.4"
   },
   "dependencies": {
     "@capraconsulting/webapp-deploy-lambda": "^1.2.1",
@@ -104,6 +105,7 @@
     "@aws-cdk/aws-events-targets": "^1.108.1",
     "@aws-cdk/aws-iam": "^1.108.1",
     "@aws-cdk/aws-lambda": "^1.108.1",
+    "@aws-cdk/aws-lambda-event-sources": "^1.108.1",
     "@aws-cdk/aws-logs": "^1.108.1",
     "@aws-cdk/aws-rds": "^1.108.1",
     "@aws-cdk/aws-route53": "^1.108.1",