terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/vpc-flow-logs.js

@@ -0,0 +1,693 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowLog = exports.LogFormat = exports.FlowLogMaxAggregationInterval = exports.FlowLogDestination = exports.FlowLogFileFormat = exports.FlowLogResourceType = exports.FlowLogDestinationType = exports.FlowLogTrafficType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc-flow-logs.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const logs = require("../cloudwatch");
+const iam = require("../iam");
+const storage = require("../storage");
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * The type of VPC traffic to log
+ */
+var FlowLogTrafficType;
+(function (FlowLogTrafficType) {
+    /**
+     * Only log accepts
+     */
+    FlowLogTrafficType["ACCEPT"] = "ACCEPT";
+    /**
+     * Log all requests
+     */
+    FlowLogTrafficType["ALL"] = "ALL";
+    /**
+     * Only log rejects
+     */
+    FlowLogTrafficType["REJECT"] = "REJECT";
+})(FlowLogTrafficType || (exports.FlowLogTrafficType = FlowLogTrafficType = {}));
+/**
+ * The available destination types for Flow Logs
+ */
+var FlowLogDestinationType;
+(function (FlowLogDestinationType) {
+    /**
+     * Send flow logs to CloudWatch Logs Group
+     */
+    FlowLogDestinationType["CLOUD_WATCH_LOGS"] = "cloud-watch-logs";
+    /**
+     * Send flow logs to S3 Bucket
+     */
+    FlowLogDestinationType["S3"] = "s3";
+    /**
+     * Send flow logs to Kinesis Data Firehose
+     */
+    FlowLogDestinationType["KINESIS_DATA_FIREHOSE"] = "kinesis-data-firehose";
+})(FlowLogDestinationType || (exports.FlowLogDestinationType = FlowLogDestinationType = {}));
+/**
+ * The type of resource to create the flow log for
+ */
+class FlowLogResourceType {
+    /**
+     * The subnet to attach the Flow Log to
+     */
+    static fromSubnet(subnet) {
+        return {
+            resourceType: "Subnet",
+            resourceId: subnet.subnetId,
+        };
+    }
+    /**
+     * The VPC to attach the Flow Log to
+     */
+    static fromVpc(vpc) {
+        return {
+            resourceType: "VPC",
+            resourceId: vpc.vpcId,
+        };
+    }
+    /**
+     * The Network Interface to attach the Flow Log to
+     */
+    static fromNetworkInterfaceId(id) {
+        return {
+            resourceType: "NetworkInterface",
+            resourceId: id,
+        };
+    }
+    /**
+     * The Transit Gateway to attach the Flow Log to
+     */
+    static fromTransitGatewayId(id) {
+        return {
+            resourceType: "TransitGateway",
+            resourceId: id,
+        };
+    }
+    /**
+     * The Transit Gateway Attachment to attach the Flow Log to
+     */
+    static fromTransitGatewayAttachmentId(id) {
+        return {
+            resourceType: "TransitGatewayAttachment",
+            resourceId: id,
+        };
+    }
+}
+exports.FlowLogResourceType = FlowLogResourceType;
+_a = JSII_RTTI_SYMBOL_1;
+FlowLogResourceType[_a] = { fqn: "terraconstructs.aws.compute.FlowLogResourceType", version: "0.0.12" };
+/**
+ * The file format for flow logs written to an S3 bucket destination
+ */
+var FlowLogFileFormat;
+(function (FlowLogFileFormat) {
+    /**
+     * File will be written as plain text
+     *
+     * This is the default value
+     */
+    FlowLogFileFormat["PLAIN_TEXT"] = "plain-text";
+    /**
+     * File will be written in parquet format
+     */
+    FlowLogFileFormat["PARQUET"] = "parquet";
+})(FlowLogFileFormat || (exports.FlowLogFileFormat = FlowLogFileFormat = {}));
+/**
+ * The destination type for the flow log
+ */
+class FlowLogDestination {
+    /**
+     * Use CloudWatch logs as the destination
+     */
+    static toCloudWatchLogs(logGroup, iamRole) {
+        return new CloudWatchLogsDestination({
+            logDestinationType: FlowLogDestinationType.CLOUD_WATCH_LOGS,
+            logGroup,
+            iamRole,
+        });
+    }
+    /**
+     * Use S3 as the destination
+     *
+     * @param bucket optional s3 bucket to publish logs to. If one is not provided
+     * a default bucket will be created
+     * @param keyPrefix optional prefix within the bucket to write logs to
+     * @param options additional s3 destination options
+     */
+    static toS3(bucket, keyPrefix, options) {
+        return new S3Destination({
+            logDestinationType: FlowLogDestinationType.S3,
+            s3Bucket: bucket,
+            keyPrefix,
+            destinationOptions: options,
+        });
+    }
+    /**
+     * Use Kinesis Data Firehose as the destination
+     *
+     * @param deliveryStreamArn the ARN of Kinesis Data Firehose delivery stream to publish logs to
+     */
+    static toKinesisDataFirehoseDestination(deliveryStreamArn) {
+        return new KinesisDataFirehoseDestination({
+            logDestinationType: FlowLogDestinationType.KINESIS_DATA_FIREHOSE,
+            deliveryStreamArn,
+        });
+    }
+}
+exports.FlowLogDestination = FlowLogDestination;
+_b = JSII_RTTI_SYMBOL_1;
+FlowLogDestination[_b] = { fqn: "terraconstructs.aws.compute.FlowLogDestination", version: "0.0.12" };
+/**
+ *
+ */
+class S3Destination extends FlowLogDestination {
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    bind(scope, _flowLog) {
+        let s3Bucket;
+        if (this.props.s3Bucket === undefined) {
+            s3Bucket = new storage.Bucket(scope, "Bucket", {
+            // TODO: Ensure flowlog Bucket is retained on delete?
+            // removalPolicy: RemovalPolicy.RETAIN,
+            });
+        }
+        else {
+            s3Bucket = this.props.s3Bucket;
+        }
+        // https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html#flow-logs-s3-permissions
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        let keyPrefix = this.props.keyPrefix ?? "";
+        if (keyPrefix && !keyPrefix.endsWith("/")) {
+            keyPrefix = keyPrefix + "/";
+        }
+        const prefix = this.props.destinationOptions?.hiveCompatiblePartitions
+            ? s3Bucket.arnForObjects(`${keyPrefix}AWSLogs/aws-account-id=${stack.account}/*`)
+            : s3Bucket.arnForObjects(`${keyPrefix}AWSLogs/${stack.account}/*`);
+        s3Bucket.addToResourcePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            principals: [new iam.ServicePrincipal("delivery.logs.amazonaws.com")],
+            resources: [prefix],
+            actions: ["s3:PutObject"],
+            condition: [
+                {
+                    test: "StringEquals",
+                    variable: "s3:x-amz-acl",
+                    values: ["bucket-owner-full-control"],
+                },
+                {
+                    test: "StringEquals",
+                    variable: "aws:SourceAccount",
+                    values: [stack.account],
+                },
+                {
+                    test: "ArnLike",
+                    variable: "aws:SourceArn",
+                    values: [
+                        stack.formatArn({
+                            service: "logs",
+                            resource: "*",
+                        }),
+                    ],
+                },
+            ],
+        }));
+        s3Bucket.addToResourcePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            principals: [new iam.ServicePrincipal("delivery.logs.amazonaws.com")],
+            resources: [s3Bucket.bucketArn],
+            actions: ["s3:GetBucketAcl", "s3:ListBucket"],
+            condition: [
+                {
+                    test: "StringEquals",
+                    variable: "aws:SourceAccount",
+                    values: [stack.account],
+                },
+                {
+                    test: "ArnLike",
+                    variable: "aws:SourceArn",
+                    values: [
+                        stack.formatArn({
+                            service: "logs",
+                            resource: "*",
+                        }),
+                    ],
+                },
+            ],
+        }));
+        return {
+            logDestinationType: FlowLogDestinationType.S3,
+            s3Bucket,
+            keyPrefix: this.props.keyPrefix,
+            destinationOptions: this.props.destinationOptions?.fileFormat ||
+                this.props.destinationOptions?.perHourPartition ||
+                this.props.destinationOptions?.hiveCompatiblePartitions
+                ? {
+                    fileFormat: this.props.destinationOptions.fileFormat ??
+                        FlowLogFileFormat.PLAIN_TEXT,
+                    perHourPartition: this.props.destinationOptions.perHourPartition ?? false,
+                    hiveCompatiblePartitions: this.props.destinationOptions.hiveCompatiblePartitions ?? false,
+                }
+                : undefined,
+        };
+    }
+}
+/**
+ *
+ */
+class CloudWatchLogsDestination extends FlowLogDestination {
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    bind(scope, _flowLog) {
+        let iamRole;
+        let logGroup;
+        if (this.props.iamRole === undefined) {
+            iamRole = new iam.Role(scope, "IAMRole", {
+                roleName: aws_stack_1.AwsStack.uniqueId(scope), //PhysicalName.GENERATE_IF_NEEDED,
+                assumedBy: new iam.ServicePrincipal("vpc-flow-logs.amazonaws.com"),
+            });
+        }
+        else {
+            iamRole = this.props.iamRole;
+        }
+        if (this.props.logGroup === undefined) {
+            logGroup = new logs.LogGroup(scope, "LogGroup");
+        }
+        else {
+            logGroup = this.props.logGroup;
+        }
+        iamRole.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: [
+                "logs:CreateLogStream",
+                "logs:PutLogEvents",
+                "logs:DescribeLogStreams",
+            ],
+            effect: iam.Effect.ALLOW,
+            resources: [logGroup.logGroupArn],
+        }));
+        iamRole.addToPrincipalPolicy(new iam.PolicyStatement({
+            actions: ["iam:PassRole"],
+            effect: iam.Effect.ALLOW,
+            resources: [iamRole.roleArn],
+        }));
+        return {
+            logDestinationType: FlowLogDestinationType.CLOUD_WATCH_LOGS,
+            logGroup,
+            iamRole,
+        };
+    }
+}
+/**
+ *
+ */
+class KinesisDataFirehoseDestination extends FlowLogDestination {
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    bind(_scope, _flowLog) {
+        if (this.props.deliveryStreamArn === undefined) {
+            throw new Error("deliveryStreamArn is required");
+        }
+        const deliveryStreamArn = this.props.deliveryStreamArn;
+        return {
+            logDestinationType: FlowLogDestinationType.KINESIS_DATA_FIREHOSE,
+            deliveryStreamArn,
+        };
+    }
+}
+/**
+ * The maximum interval of time during which a flow of packets
+ * is captured and aggregated into a flow log record.
+ *
+ */
+var FlowLogMaxAggregationInterval;
+(function (FlowLogMaxAggregationInterval) {
+    /**
+     * 1 minute (60 seconds)
+     */
+    FlowLogMaxAggregationInterval[FlowLogMaxAggregationInterval["ONE_MINUTE"] = 60] = "ONE_MINUTE";
+    /**
+     * 10 minutes (600 seconds)
+     */
+    FlowLogMaxAggregationInterval[FlowLogMaxAggregationInterval["TEN_MINUTES"] = 600] = "TEN_MINUTES";
+})(FlowLogMaxAggregationInterval || (exports.FlowLogMaxAggregationInterval = FlowLogMaxAggregationInterval = {}));
+/**
+ * The following table describes all of the available fields for a flow log record.
+ */
+class LogFormat {
+    /**
+     * A custom format string.
+     *
+     * Gives full control over the format string fragment.
+     */
+    static custom(formatString) {
+        return new LogFormat(formatString);
+    }
+    /**
+     * A custom field name.
+     *
+     * If there is no ready-made constant for a new field yet, you can use this.
+     * The field name will automatically be wrapped in `${ ... }`.
+     */
+    static field(field) {
+        return new LogFormat(`\${${field}}`);
+    }
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.LogFormat = LogFormat;
+_c = JSII_RTTI_SYMBOL_1;
+LogFormat[_c] = { fqn: "terraconstructs.aws.compute.LogFormat", version: "0.0.12" };
+/**
+ * The VPC Flow Logs version.
+ */
+LogFormat.VERSION = LogFormat.field("version");
+/**
+ * The AWS account ID of the owner of the source network interface for which traffic is recorded.
+ */
+LogFormat.ACCOUNT_ID = LogFormat.field("account-id");
+/**
+ * The ID of the network interface for which the traffic is recorded.
+ */
+LogFormat.INTERFACE_ID = LogFormat.field("interface-id");
+/**
+ * The source address for incoming traffic, or the IPv4 or IPv6 address of the network interface
+ * for outgoing traffic on the network interface.
+ */
+LogFormat.SRC_ADDR = LogFormat.field("srcaddr");
+/**
+ * The destination address for outgoing traffic, or the IPv4 or IPv6 address of the network interface
+ * for incoming traffic on the network interface.
+ */
+LogFormat.DST_ADDR = LogFormat.field("dstaddr");
+/**
+ * The source port of the traffic.
+ */
+LogFormat.SRC_PORT = LogFormat.field("srcport");
+/**
+ * The destination port of the traffic.
+ */
+LogFormat.DST_PORT = LogFormat.field("dstport");
+/**
+ * The IANA protocol number of the traffic.
+ */
+LogFormat.PROTOCOL = LogFormat.field("protocol");
+/**
+ * The number of packets transferred during the flow.
+ */
+LogFormat.PACKETS = LogFormat.field("packets");
+/**
+ * The number of bytes transferred during the flow.
+ */
+LogFormat.BYTES = LogFormat.field("bytes");
+/**
+ * The time, in Unix seconds, when the first packet of the flow was received within
+ * the aggregation interval.
+ *
+ * This might be up to 60 seconds after the packet was transmitted or received on
+ * the network interface.
+ */
+LogFormat.START_TIMESTAMP = LogFormat.field("start");
+/**
+ * The time, in Unix seconds, when the last packet of the flow was received within
+ * the aggregation interval.
+ *
+ * This might be up to 60 seconds after the packet was transmitted or received on
+ * the network interface.
+ */
+LogFormat.END_TIMESTAMP = LogFormat.field("end");
+/**
+ * The action that is associated with the traffic.
+ */
+LogFormat.ACTION = LogFormat.field("action");
+/**
+ * The logging status of the flow log.
+ */
+LogFormat.LOG_STATUS = LogFormat.field("log-status");
+/**
+ * The ID of the VPC that contains the network interface for which the traffic is recorded.
+ */
+LogFormat.VPC_ID = LogFormat.field("vpc-id");
+/**
+ * The ID of the subnet that contains the network interface for which the traffic is recorded.
+ */
+LogFormat.SUBNET_ID = LogFormat.field("subnet-id");
+/**
+ * The ID of the instance that's associated with network interface for which the traffic is
+ * recorded, if the instance is owned by you.
+ *
+ * Returns a '-' symbol for a requester-managed network interface; for example, the
+ * network interface for a NAT gateway
+ */
+LogFormat.INSTANCE_ID = LogFormat.field("instance-id");
+/**
+ * The bitmask value for TCP flags.
+ *
+ * - FIN -- 1
+ * - SYN -- 2
+ * - RST -- 4
+ * - SYN-ACK -- 18
+ *
+ * If no supported flags are recorded, the TCP flag value is 0.
+ *
+ * TCP flags can be OR-ed during the aggregation interval. For short connections,
+ * the flags might be set on the same line in the flow log record, for example,
+ * 19 for SYN-ACK and FIN, and 3 for SYN and FIN.
+ */
+LogFormat.TCP_FLAGS = LogFormat.field("tcp-flags");
+/**
+ * The type of traffic.
+ *
+ * The possible values are IPv4, IPv6, or EFA.
+ */
+LogFormat.TRAFFIC_TYPE = LogFormat.field("type");
+/**
+ * The packet-level (original) source IP address of the traffic.
+ */
+LogFormat.PKT_SRC_ADDR = LogFormat.field("pkt-srcaddr");
+/**
+ * The packet-level (original) destination IP address for the traffic.
+ */
+LogFormat.PKT_DST_ADDR = LogFormat.field("pkt-dstaddr");
+/**
+ * The Region that contains the network interface for which traffic is recorded.
+ */
+LogFormat.REGION = LogFormat.field("region");
+/**
+ * The ID of the Availability Zone that contains the network interface for which traffic is recorded.
+ */
+LogFormat.AZ_ID = LogFormat.field("az-id");
+/**
+ * The type of sublocation that's returned in the sublocation-id field.
+ */
+LogFormat.SUBLOCATION_TYPE = LogFormat.field("sublocation-type");
+/**
+ * The ID of the sublocation that contains the network interface for which traffic is recorded.
+ */
+LogFormat.SUBLOCATION_ID = LogFormat.field("sublocation-id");
+/**
+ * The name of the subset of IP address ranges for the pkt-srcaddr field,
+ * if the source IP address is for an AWS service.
+ */
+LogFormat.PKT_SRC_AWS_SERVICE = LogFormat.field("pkt-src-aws-service");
+/**
+ * The name of the subset of IP address ranges for the pkt-dstaddr field,
+ * if the destination IP address is for an AWS service.
+ */
+LogFormat.PKT_DST_AWS_SERVICE = LogFormat.field("pkt-dst-aws-service");
+/**
+ * The direction of the flow with respect to the interface where traffic is captured.
+ */
+LogFormat.FLOW_DIRECTION = LogFormat.field("flow-direction");
+/**
+ * The path that egress traffic takes to the destination.
+ */
+LogFormat.TRAFFIC_PATH = LogFormat.field("traffic-path");
+/**
+ * AWS Resource Name (ARN) of the ECS cluster if the traffic is from a running ECS task.
+ */
+LogFormat.ECS_CLUSTER_ARN = LogFormat.field("ecs-cluster-arn");
+/**
+ * Name of the ECS cluster if the traffic is from a running ECS task.
+ */
+LogFormat.ECS_CLUSTER_NAME = LogFormat.field("ecs-cluster-name");
+/**
+ * ARN of the ECS container instance if the traffic is from a running ECS task on an EC2 instance.
+ */
+LogFormat.ECS_CONTAINER_INSTANCE_ARN = LogFormat.field("ecs-container-instance-arn");
+/**
+ * ID of the ECS container instance if the traffic is from a running ECS task on an EC2 instance.
+ */
+LogFormat.ECS_CONTAINER_INSTANCE_ID = LogFormat.field("ecs-container-instance-id");
+/**
+ * Docker runtime ID of the container if the traffic is from a running ECS task.
+ * If there is one container or more in the ECS task, this will be the docker runtime ID of the first container.
+ */
+LogFormat.ECS_CONTAINER_ID = LogFormat.field("ecs-container-id");
+/**
+ * Docker runtime ID of the container if the traffic is from a running ECS task.
+ * If there is more than one container in the ECS task, this will be the Docker runtime ID of the second container.
+ */
+LogFormat.ECS_SECOND_CONTAINER_ID = LogFormat.field("ecs-second-container-id");
+/**
+ * Name of the ECS service if the traffic is from a running ECS task and the ECS task is started by an ECS service.
+ */
+LogFormat.ECS_SERVICE_NAME = LogFormat.field("ecs-service-name");
+/**
+ * ARN of the ECS task definition if the traffic is from a running ECS task.
+ */
+LogFormat.ECS_TASK_DEFINITION_ARN = LogFormat.field("ecs-task-definition-arn");
+/**
+ * ARN of the ECS task if the traffic is from a running ECS task.
+ */
+LogFormat.ECS_TASK_ARN = LogFormat.field("ecs-task-arn");
+/**
+ * ID of the ECS task if the traffic is from a running ECS task.
+ */
+LogFormat.ECS_TASK_ID = LogFormat.field("ecs-task-id");
+/**
+ * The default format.
+ */
+LogFormat.ALL_DEFAULT_FIELDS = new LogFormat("${version} ${account-id} ${interface-id} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${protocol} ${packets} ${bytes} ${start} ${end} ${action} ${log-status}");
+/**
+ * The base class for a Flow Log
+ */
+class FlowLogBase extends aws_construct_1.AwsConstructBase {
+    get flowLogOutputs() {
+        return {
+            flowLogId: this.flowLogId,
+        };
+    }
+    get outputs() {
+        return this.flowLogOutputs;
+    }
+}
+/**
+ * A VPC flow log.
+ * @resource AWS::EC2::FlowLog
+ */
+class FlowLog extends FlowLogBase {
+    /**
+     * Import a Flow Log by it's Id
+     */
+    static fromFlowLogId(scope, id, flowLogId) {
+        class Import extends FlowLogBase {
+            constructor() {
+                super(...arguments);
+                this.flowLogId = flowLogId;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        const destination = props.destination || FlowLogDestination.toCloudWatchLogs();
+        const destinationConfig = destination.bind(this, this);
+        this.logGroup = destinationConfig.logGroup;
+        this.bucket = destinationConfig.s3Bucket;
+        this.iamRole = destinationConfig.iamRole;
+        this.keyPrefix = destinationConfig.keyPrefix;
+        this.deliveryStreamArn = destinationConfig.deliveryStreamArn;
+        aws_tags_1.Tags.of(this).add(NAME_TAG, props.flowLogName || this.node.path);
+        let logDestination = undefined;
+        if (this.bucket) {
+            logDestination = this.keyPrefix
+                ? this.bucket.arnForObjects(this.keyPrefix)
+                : this.bucket.bucketArn;
+        }
+        if (this.deliveryStreamArn) {
+            logDestination = this.deliveryStreamArn;
+        }
+        let customLogFormat = undefined;
+        if (props.logFormat) {
+            customLogFormat = props.logFormat
+                .map((elm) => {
+                return elm.value;
+            })
+                .join(" ");
+        }
+        let trafficType = props.trafficType ?? FlowLogTrafficType.ALL;
+        if (props.resourceType.resourceType === "TransitGateway" ||
+            props.resourceType.resourceType === "TransitGatewayAttachment") {
+            if (props.trafficType) {
+                throw new Error("trafficType is not supported for Transit Gateway and Transit Gateway Attachment");
+            }
+            if (props.maxAggregationInterval &&
+                props.maxAggregationInterval !==
+                    FlowLogMaxAggregationInterval.ONE_MINUTE) {
+                throw new Error("maxAggregationInterval must be set to ONE_MINUTE for Transit Gateway and Transit Gateway Attachment");
+            }
+            trafficType = undefined;
+        }
+        // convert AWSCC -> AWS resourceIdProps
+        // TODO: Adopt AWSCC
+        let resourceIdProps;
+        switch (props.resourceType.resourceType) {
+            case "NetworkInterface":
+                resourceIdProps = { eniId: props.resourceType.resourceId };
+                break;
+            case "Subnet":
+                resourceIdProps = { subnetId: props.resourceType.resourceId };
+                break;
+            case "TransitGateway":
+                resourceIdProps = { transitGatewayId: props.resourceType.resourceId };
+                break;
+            case "TransitGatewayAttachment":
+                resourceIdProps = {
+                    transitGatewayAttachmentId: props.resourceType.resourceId,
+                };
+                break;
+            case "VPC":
+                resourceIdProps = { vpcId: props.resourceType.resourceId };
+                break;
+            default:
+                throw new Error("Invalid resource type: " + props.resourceType);
+        }
+        this.resource = new provider_aws_1.flowLog.FlowLog(this, "Resource", {
+            destinationOptions: destinationConfig.destinationOptions,
+            iamRoleArn: this.iamRole ? this.iamRole.roleArn : undefined,
+            logDestinationType: destinationConfig.logDestinationType,
+            logGroupName: this.logGroup ? this.logGroup.logGroupName : undefined,
+            maxAggregationInterval: props.maxAggregationInterval,
+            id: props.resourceType.resourceId,
+            trafficType,
+            logFormat: customLogFormat,
+            logDestination,
+            ...resourceIdProps,
+        });
+        // VPC service implicitly tries to create a bucket policy when adding a vpc flow log.
+        // To avoid the race condition, we add an explicit dependency here.
+        if (this.bucket?.policy?.node.defaultChild instanceof cdktf_1.TerraformResource) {
+            this.resource.node.addDependency(this.bucket?.policy.node.defaultChild);
+        }
+        // TODO: we must remove a flow log configuration first before deleting objects.
+        // TODO: S3 Bucket object removal custom resource?
+        // const deleteObjects = this.bucket?.node.tryFindChild(
+        //   "AutoDeleteObjectsCustomResource",
+        // )?.node.defaultChild;
+        // if (deleteObjects instanceof TerraformResource) {
+        //   resource.node.addDependency(deleteObjects);
+        // }
+        this.flowLogId = this.resource.id;
+    }
+}
+exports.FlowLog = FlowLog;
+_d = JSII_RTTI_SYMBOL_1;
+FlowLog[_d] = { fqn: "terraconstructs.aws.compute.FlowLog", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-flow-logs.js","sourceRoot":"","sources":["../../../src/aws/compute/vpc-flow-logs.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc-flow-logs.ts\n\nimport { flowLog } from \"@cdktf/provider-aws\";\nimport { TerraformResource } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ISubnet, IVpc } from \"./vpc\";\nimport { IAwsConstruct, AwsConstructBase } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\nimport * as logs from \"../cloudwatch\";\nimport * as iam from \"../iam\";\nimport * as storage from \"../storage\";\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface FlowLogOutputs {\n  /**\n   * The Id of the VPC Flow Log\n   *\n   * @attribute\n   */\n  readonly flowLogId: string;\n}\n\n/**\n * A FlowLog\n */\nexport interface IFlowLog extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly flowLogOutputs: FlowLogOutputs;\n\n  /**\n   * The Id of the VPC Flow Log\n   *\n   * @attribute\n   */\n  readonly flowLogId: string;\n}\n\n/**\n * The type of VPC traffic to log\n */\nexport enum FlowLogTrafficType {\n  /**\n   * Only log accepts\n   */\n  ACCEPT = \"ACCEPT\",\n\n  /**\n   * Log all requests\n   */\n  ALL = \"ALL\",\n\n  /**\n   * Only log rejects\n   */\n  REJECT = \"REJECT\",\n}\n\n/**\n * The available destination types for Flow Logs\n */\nexport enum FlowLogDestinationType {\n  /**\n   * Send flow logs to CloudWatch Logs Group\n   */\n  CLOUD_WATCH_LOGS = \"cloud-watch-logs\",\n\n  /**\n   * Send flow logs to S3 Bucket\n   */\n  S3 = \"s3\",\n\n  /**\n   * Send flow logs to Kinesis Data Firehose\n   */\n  KINESIS_DATA_FIREHOSE = \"kinesis-data-firehose\",\n}\n\n/**\n * The type of resource to create the flow log for\n */\nexport abstract class FlowLogResourceType {\n  /**\n   * The subnet to attach the Flow Log to\n   */\n  public static fromSubnet(subnet: ISubnet): FlowLogResourceType {\n    return {\n      resourceType: \"Subnet\",\n      resourceId: subnet.subnetId,\n    };\n  }\n\n  /**\n   * The VPC to attach the Flow Log to\n   */\n  public static fromVpc(vpc: IVpc): FlowLogResourceType {\n    return {\n      resourceType: \"VPC\",\n      resourceId: vpc.vpcId,\n    };\n  }\n\n  /**\n   * The Network Interface to attach the Flow Log to\n   */\n  public static fromNetworkInterfaceId(id: string): FlowLogResourceType {\n    return {\n      resourceType: \"NetworkInterface\",\n      resourceId: id,\n    };\n  }\n\n  /**\n   * The Transit Gateway to attach the Flow Log to\n   */\n  public static fromTransitGatewayId(id: string): FlowLogResourceType {\n    return {\n      resourceType: \"TransitGateway\",\n      resourceId: id,\n    };\n  }\n\n  /**\n   * The Transit Gateway Attachment to attach the Flow Log to\n   */\n  public static fromTransitGatewayAttachmentId(\n    id: string,\n  ): FlowLogResourceType {\n    return {\n      resourceType: \"TransitGatewayAttachment\",\n      resourceId: id,\n    };\n  }\n\n  /**\n   * The type of resource to attach a flow log to.\n   */\n  public abstract resourceType: string;\n\n  /**\n   * The Id of the resource that the flow log should be attached to.\n   */\n  public abstract resourceId: string;\n}\n\n/**\n * The file format for flow logs written to an S3 bucket destination\n */\nexport enum FlowLogFileFormat {\n  /**\n   * File will be written as plain text\n   *\n   * This is the default value\n   */\n  PLAIN_TEXT = \"plain-text\",\n\n  /**\n   * File will be written in parquet format\n   */\n  PARQUET = \"parquet\",\n}\n\n/**\n * Options for writing logs to a S3 destination\n */\nexport interface S3DestinationOptions {\n  /**\n   * Use Hive-compatible prefixes for flow logs\n   * stored in Amazon S3\n   *\n   * @default false\n   */\n  readonly hiveCompatiblePartitions?: boolean;\n\n  /**\n   * The format for the flow log\n   *\n   * @default FlowLogFileFormat.PLAIN_TEXT\n   */\n  readonly fileFormat?: FlowLogFileFormat;\n\n  /**\n   * Partition the flow log per hour\n   *\n   * @default false\n   */\n  readonly perHourPartition?: boolean;\n}\n\n/**\n * The destination type for the flow log\n */\nexport abstract class FlowLogDestination {\n  /**\n   * Use CloudWatch logs as the destination\n   */\n  public static toCloudWatchLogs(\n    logGroup?: logs.ILogGroup,\n    iamRole?: iam.IRole,\n  ): FlowLogDestination {\n    return new CloudWatchLogsDestination({\n      logDestinationType: FlowLogDestinationType.CLOUD_WATCH_LOGS,\n      logGroup,\n      iamRole,\n    });\n  }\n\n  /**\n   * Use S3 as the destination\n   *\n   * @param bucket optional s3 bucket to publish logs to. If one is not provided\n   * a default bucket will be created\n   * @param keyPrefix optional prefix within the bucket to write logs to\n   * @param options additional s3 destination options\n   */\n  public static toS3(\n    bucket?: storage.IBucket,\n    keyPrefix?: string,\n    options?: S3DestinationOptions,\n  ): FlowLogDestination {\n    return new S3Destination({\n      logDestinationType: FlowLogDestinationType.S3,\n      s3Bucket: bucket,\n      keyPrefix,\n      destinationOptions: options,\n    });\n  }\n\n  /**\n   * Use Kinesis Data Firehose as the destination\n   *\n   * @param deliveryStreamArn the ARN of Kinesis Data Firehose delivery stream to publish logs to\n   */\n  public static toKinesisDataFirehoseDestination(\n    deliveryStreamArn: string,\n  ): FlowLogDestination {\n    return new KinesisDataFirehoseDestination({\n      logDestinationType: FlowLogDestinationType.KINESIS_DATA_FIREHOSE,\n      deliveryStreamArn,\n    });\n  }\n\n  /**\n   * Generates a flow log destination configuration\n   */\n  public abstract bind(scope: Construct, f: FlowLog): FlowLogDestinationConfig;\n}\n\n/**\n * Flow Log Destination configuration\n */\nexport interface FlowLogDestinationConfig {\n  /**\n   * The type of destination to publish the flow logs to.\n   *\n   * @default - CLOUD_WATCH_LOGS\n   */\n  readonly logDestinationType: FlowLogDestinationType;\n\n  /**\n   * The IAM Role that has access to publish to CloudWatch logs\n   *\n   * @default - default IAM role is created for you\n   */\n  readonly iamRole?: iam.IRole;\n\n  /**\n   * The CloudWatch Logs Log Group to publish the flow logs to\n   *\n   * @default - default log group is created for you\n   */\n  readonly logGroup?: logs.ILogGroup;\n\n  /**\n   * S3 bucket to publish the flow logs to\n   *\n   * @default - undefined\n   */\n  readonly s3Bucket?: storage.IBucket;\n\n  /**\n   * S3 bucket key prefix to publish the flow logs to\n   *\n   * @default - undefined\n   */\n  readonly keyPrefix?: string;\n\n  /**\n   * The ARN of Kinesis Data Firehose delivery stream to publish the flow logs to\n   *\n   * @default - undefined\n   */\n  readonly deliveryStreamArn?: string;\n\n  /**\n   * Options for writing flow logs to a supported destination\n   *\n   * @default - undefined\n   */\n  readonly destinationOptions?: S3DestinationOptions;\n}\n\n/**\n *\n */\nclass S3Destination extends FlowLogDestination {\n  constructor(private readonly props: FlowLogDestinationConfig) {\n    super();\n  }\n\n  public bind(scope: Construct, _flowLog: FlowLog): FlowLogDestinationConfig {\n    let s3Bucket: storage.IBucket;\n    if (this.props.s3Bucket === undefined) {\n      s3Bucket = new storage.Bucket(scope, \"Bucket\", {\n        // TODO: Ensure flowlog Bucket is retained on delete?\n        // removalPolicy: RemovalPolicy.RETAIN,\n      });\n    } else {\n      s3Bucket = this.props.s3Bucket;\n    }\n\n    // https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html#flow-logs-s3-permissions\n\n    const stack = AwsStack.ofAwsConstruct(scope);\n    let keyPrefix = this.props.keyPrefix ?? \"\";\n    if (keyPrefix && !keyPrefix.endsWith(\"/\")) {\n      keyPrefix = keyPrefix + \"/\";\n    }\n    const prefix = this.props.destinationOptions?.hiveCompatiblePartitions\n      ? s3Bucket.arnForObjects(\n          `${keyPrefix}AWSLogs/aws-account-id=${stack.account}/*`,\n        )\n      : s3Bucket.arnForObjects(`${keyPrefix}AWSLogs/${stack.account}/*`);\n\n    s3Bucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        principals: [new iam.ServicePrincipal(\"delivery.logs.amazonaws.com\")],\n        resources: [prefix],\n        actions: [\"s3:PutObject\"],\n        condition: [\n          {\n            test: \"StringEquals\",\n\n            variable: \"s3:x-amz-acl\",\n            values: [\"bucket-owner-full-control\"],\n          },\n          {\n            test: \"StringEquals\",\n            variable: \"aws:SourceAccount\",\n            values: [stack.account],\n          },\n          {\n            test: \"ArnLike\",\n            variable: \"aws:SourceArn\",\n            values: [\n              stack.formatArn({\n                service: \"logs\",\n                resource: \"*\",\n              }),\n            ],\n          },\n        ],\n      }),\n    );\n\n    s3Bucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        principals: [new iam.ServicePrincipal(\"delivery.logs.amazonaws.com\")],\n        resources: [s3Bucket.bucketArn],\n        actions: [\"s3:GetBucketAcl\", \"s3:ListBucket\"],\n        condition: [\n          {\n            test: \"StringEquals\",\n            variable: \"aws:SourceAccount\",\n            values: [stack.account],\n          },\n          {\n            test: \"ArnLike\",\n            variable: \"aws:SourceArn\",\n            values: [\n              stack.formatArn({\n                service: \"logs\",\n                resource: \"*\",\n              }),\n            ],\n          },\n        ],\n      }),\n    );\n    return {\n      logDestinationType: FlowLogDestinationType.S3,\n      s3Bucket,\n      keyPrefix: this.props.keyPrefix,\n      destinationOptions:\n        this.props.destinationOptions?.fileFormat ||\n        this.props.destinationOptions?.perHourPartition ||\n        this.props.destinationOptions?.hiveCompatiblePartitions\n          ? {\n              fileFormat:\n                this.props.destinationOptions.fileFormat ??\n                FlowLogFileFormat.PLAIN_TEXT,\n              perHourPartition:\n                this.props.destinationOptions.perHourPartition ?? false,\n              hiveCompatiblePartitions:\n                this.props.destinationOptions.hiveCompatiblePartitions ?? false,\n            }\n          : undefined,\n    };\n  }\n}\n\n/**\n *\n */\nclass CloudWatchLogsDestination extends FlowLogDestination {\n  constructor(private readonly props: FlowLogDestinationConfig) {\n    super();\n  }\n\n  public bind(scope: Construct, _flowLog: FlowLog): FlowLogDestinationConfig {\n    let iamRole: iam.IRole;\n    let logGroup: logs.ILogGroup;\n    if (this.props.iamRole === undefined) {\n      iamRole = new iam.Role(scope, \"IAMRole\", {\n        roleName: AwsStack.uniqueId(scope), //PhysicalName.GENERATE_IF_NEEDED,\n        assumedBy: new iam.ServicePrincipal(\"vpc-flow-logs.amazonaws.com\"),\n      });\n    } else {\n      iamRole = this.props.iamRole;\n    }\n\n    if (this.props.logGroup === undefined) {\n      logGroup = new logs.LogGroup(scope, \"LogGroup\");\n    } else {\n      logGroup = this.props.logGroup;\n    }\n\n    iamRole.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: [\n          \"logs:CreateLogStream\",\n          \"logs:PutLogEvents\",\n          \"logs:DescribeLogStreams\",\n        ],\n        effect: iam.Effect.ALLOW,\n        resources: [logGroup.logGroupArn],\n      }),\n    );\n\n    iamRole.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        actions: [\"iam:PassRole\"],\n        effect: iam.Effect.ALLOW,\n        resources: [iamRole.roleArn],\n      }),\n    );\n\n    return {\n      logDestinationType: FlowLogDestinationType.CLOUD_WATCH_LOGS,\n      logGroup,\n      iamRole,\n    };\n  }\n}\n\n/**\n *\n */\nclass KinesisDataFirehoseDestination extends FlowLogDestination {\n  constructor(private readonly props: FlowLogDestinationConfig) {\n    super();\n  }\n\n  public bind(_scope: Construct, _flowLog: FlowLog): FlowLogDestinationConfig {\n    if (this.props.deliveryStreamArn === undefined) {\n      throw new Error(\"deliveryStreamArn is required\");\n    }\n    const deliveryStreamArn = this.props.deliveryStreamArn;\n\n    return {\n      logDestinationType: FlowLogDestinationType.KINESIS_DATA_FIREHOSE,\n      deliveryStreamArn,\n    };\n  }\n}\n\n/**\n * The maximum interval of time during which a flow of packets\n * is captured and aggregated into a flow log record.\n *\n */\nexport enum FlowLogMaxAggregationInterval {\n  /**\n   * 1 minute (60 seconds)\n   */\n  ONE_MINUTE = 60,\n\n  /**\n   * 10 minutes (600 seconds)\n   */\n  TEN_MINUTES = 600,\n}\n\n/**\n * The following table describes all of the available fields for a flow log record.\n */\nexport class LogFormat {\n  /**\n   * The VPC Flow Logs version.\n   */\n  public static readonly VERSION = LogFormat.field(\"version\");\n\n  /**\n   * The AWS account ID of the owner of the source network interface for which traffic is recorded.\n   */\n  public static readonly ACCOUNT_ID = LogFormat.field(\"account-id\");\n\n  /**\n   * The ID of the network interface for which the traffic is recorded.\n   */\n  public static readonly INTERFACE_ID = LogFormat.field(\"interface-id\");\n\n  /**\n   * The source address for incoming traffic, or the IPv4 or IPv6 address of the network interface\n   * for outgoing traffic on the network interface.\n   */\n  public static readonly SRC_ADDR = LogFormat.field(\"srcaddr\");\n\n  /**\n   * The destination address for outgoing traffic, or the IPv4 or IPv6 address of the network interface\n   * for incoming traffic on the network interface.\n   */\n  public static readonly DST_ADDR = LogFormat.field(\"dstaddr\");\n\n  /**\n   * The source port of the traffic.\n   */\n  public static readonly SRC_PORT = LogFormat.field(\"srcport\");\n\n  /**\n   * The destination port of the traffic.\n   */\n  public static readonly DST_PORT = LogFormat.field(\"dstport\");\n\n  /**\n   * The IANA protocol number of the traffic.\n   */\n  public static readonly PROTOCOL = LogFormat.field(\"protocol\");\n\n  /**\n   * The number of packets transferred during the flow.\n   */\n  public static readonly PACKETS = LogFormat.field(\"packets\");\n\n  /**\n   * The number of bytes transferred during the flow.\n   */\n  public static readonly BYTES = LogFormat.field(\"bytes\");\n\n  /**\n   * The time, in Unix seconds, when the first packet of the flow was received within\n   * the aggregation interval.\n   *\n   * This might be up to 60 seconds after the packet was transmitted or received on\n   * the network interface.\n   */\n  public static readonly START_TIMESTAMP = LogFormat.field(\"start\");\n\n  /**\n   * The time, in Unix seconds, when the last packet of the flow was received within\n   * the aggregation interval.\n   *\n   * This might be up to 60 seconds after the packet was transmitted or received on\n   * the network interface.\n   */\n  public static readonly END_TIMESTAMP = LogFormat.field(\"end\");\n\n  /**\n   * The action that is associated with the traffic.\n   */\n  public static readonly ACTION = LogFormat.field(\"action\");\n\n  /**\n   * The logging status of the flow log.\n   */\n  public static readonly LOG_STATUS = LogFormat.field(\"log-status\");\n\n  /**\n   * The ID of the VPC that contains the network interface for which the traffic is recorded.\n   */\n  public static readonly VPC_ID = LogFormat.field(\"vpc-id\");\n\n  /**\n   * The ID of the subnet that contains the network interface for which the traffic is recorded.\n   */\n  public static readonly SUBNET_ID = LogFormat.field(\"subnet-id\");\n\n  /**\n   * The ID of the instance that's associated with network interface for which the traffic is\n   * recorded, if the instance is owned by you.\n   *\n   * Returns a '-' symbol for a requester-managed network interface; for example, the\n   * network interface for a NAT gateway\n   */\n  public static readonly INSTANCE_ID = LogFormat.field(\"instance-id\");\n\n  /**\n   * The bitmask value for TCP flags.\n   *\n   * - FIN -- 1\n   * - SYN -- 2\n   * - RST -- 4\n   * - SYN-ACK -- 18\n   *\n   * If no supported flags are recorded, the TCP flag value is 0.\n   *\n   * TCP flags can be OR-ed during the aggregation interval. For short connections,\n   * the flags might be set on the same line in the flow log record, for example,\n   * 19 for SYN-ACK and FIN, and 3 for SYN and FIN.\n   */\n  public static readonly TCP_FLAGS = LogFormat.field(\"tcp-flags\");\n\n  /**\n   * The type of traffic.\n   *\n   * The possible values are IPv4, IPv6, or EFA.\n   */\n  public static readonly TRAFFIC_TYPE = LogFormat.field(\"type\");\n\n  /**\n   * The packet-level (original) source IP address of the traffic.\n   */\n  public static readonly PKT_SRC_ADDR = LogFormat.field(\"pkt-srcaddr\");\n\n  /**\n   * The packet-level (original) destination IP address for the traffic.\n   */\n  public static readonly PKT_DST_ADDR = LogFormat.field(\"pkt-dstaddr\");\n\n  /**\n   * The Region that contains the network interface for which traffic is recorded.\n   */\n  public static readonly REGION = LogFormat.field(\"region\");\n\n  /**\n   * The ID of the Availability Zone that contains the network interface for which traffic is recorded.\n   */\n  public static readonly AZ_ID = LogFormat.field(\"az-id\");\n\n  /**\n   * The type of sublocation that's returned in the sublocation-id field.\n   */\n  public static readonly SUBLOCATION_TYPE = LogFormat.field(\"sublocation-type\");\n\n  /**\n   * The ID of the sublocation that contains the network interface for which traffic is recorded.\n   */\n  public static readonly SUBLOCATION_ID = LogFormat.field(\"sublocation-id\");\n\n  /**\n   * The name of the subset of IP address ranges for the pkt-srcaddr field,\n   * if the source IP address is for an AWS service.\n   */\n  public static readonly PKT_SRC_AWS_SERVICE = LogFormat.field(\n    \"pkt-src-aws-service\",\n  );\n\n  /**\n   * The name of the subset of IP address ranges for the pkt-dstaddr field,\n   * if the destination IP address is for an AWS service.\n   */\n  public static readonly PKT_DST_AWS_SERVICE = LogFormat.field(\n    \"pkt-dst-aws-service\",\n  );\n\n  /**\n   * The direction of the flow with respect to the interface where traffic is captured.\n   */\n  public static readonly FLOW_DIRECTION = LogFormat.field(\"flow-direction\");\n\n  /**\n   * The path that egress traffic takes to the destination.\n   */\n  public static readonly TRAFFIC_PATH = LogFormat.field(\"traffic-path\");\n\n  /**\n   * AWS Resource Name (ARN) of the ECS cluster if the traffic is from a running ECS task.\n   */\n  public static readonly ECS_CLUSTER_ARN = LogFormat.field(\"ecs-cluster-arn\");\n\n  /**\n   * Name of the ECS cluster if the traffic is from a running ECS task.\n   */\n  public static readonly ECS_CLUSTER_NAME = LogFormat.field(\"ecs-cluster-name\");\n\n  /**\n   * ARN of the ECS container instance if the traffic is from a running ECS task on an EC2 instance.\n   */\n  public static readonly ECS_CONTAINER_INSTANCE_ARN = LogFormat.field(\n    \"ecs-container-instance-arn\",\n  );\n\n  /**\n   * ID of the ECS container instance if the traffic is from a running ECS task on an EC2 instance.\n   */\n  public static readonly ECS_CONTAINER_INSTANCE_ID = LogFormat.field(\n    \"ecs-container-instance-id\",\n  );\n\n  /**\n   * Docker runtime ID of the container if the traffic is from a running ECS task.\n   * If there is one container or more in the ECS task, this will be the docker runtime ID of the first container.\n   */\n  public static readonly ECS_CONTAINER_ID = LogFormat.field(\"ecs-container-id\");\n\n  /**\n   * Docker runtime ID of the container if the traffic is from a running ECS task.\n   * If there is more than one container in the ECS task, this will be the Docker runtime ID of the second container.\n   */\n  public static readonly ECS_SECOND_CONTAINER_ID = LogFormat.field(\n    \"ecs-second-container-id\",\n  );\n\n  /**\n   * Name of the ECS service if the traffic is from a running ECS task and the ECS task is started by an ECS service.\n   */\n  public static readonly ECS_SERVICE_NAME = LogFormat.field(\"ecs-service-name\");\n\n  /**\n   * ARN of the ECS task definition if the traffic is from a running ECS task.\n   */\n  public static readonly ECS_TASK_DEFINITION_ARN = LogFormat.field(\n    \"ecs-task-definition-arn\",\n  );\n\n  /**\n   * ARN of the ECS task if the traffic is from a running ECS task.\n   */\n  public static readonly ECS_TASK_ARN = LogFormat.field(\"ecs-task-arn\");\n\n  /**\n   * ID of the ECS task if the traffic is from a running ECS task.\n   */\n  public static readonly ECS_TASK_ID = LogFormat.field(\"ecs-task-id\");\n\n  /**\n   * The default format.\n   */\n  public static readonly ALL_DEFAULT_FIELDS = new LogFormat(\n    \"${version} ${account-id} ${interface-id} ${srcaddr} ${dstaddr} ${srcport} ${dstport} ${protocol} ${packets} ${bytes} ${start} ${end} ${action} ${log-status}\",\n  );\n\n  /**\n   * A custom format string.\n   *\n   * Gives full control over the format string fragment.\n   */\n  public static custom(formatString: string): LogFormat {\n    return new LogFormat(formatString);\n  }\n\n  /**\n   * A custom field name.\n   *\n   * If there is no ready-made constant for a new field yet, you can use this.\n   * The field name will automatically be wrapped in `${ ... }`.\n   */\n  public static field(field: string): LogFormat {\n    return new LogFormat(`\\${${field}}`);\n  }\n\n  protected constructor(public readonly value: string) {}\n}\n\n/**\n * Options to add a flow log to a VPC\n */\nexport interface FlowLogOptions {\n  /**\n   * The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic.\n   * When the target is either `TransitGateway` or `TransitGatewayAttachment`, setting the traffic type is not possible.\n   *\n   * @see https://docs.aws.amazon.com/vpc/latest/tgw/working-with-flow-logs.html\n   *\n   * @default ALL\n   */\n  readonly trafficType?: FlowLogTrafficType;\n\n  /**\n   * Specifies the type of destination to which the flow log data is to be published.\n   * Flow log data can be published to CloudWatch Logs or Amazon S3\n   *\n   * @default FlowLogDestinationType.toCloudWatchLogs()\n   */\n  readonly destination?: FlowLogDestination;\n\n  /**\n   * The fields to include in the flow log record, in the order in which they should appear.\n   *\n   * If multiple fields are specified, they will be separated by spaces. For full control over the literal log format\n   * string, pass a single field constructed with `LogFormat.custom()`.\n   *\n   * See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records\n   *\n   * @default - default log format is used.\n   */\n  readonly logFormat?: LogFormat[];\n\n  /**\n   * The maximum interval of time during which a flow of packets is captured\n   * and aggregated into a flow log record.\n   *\n   * When creating flow logs for a Transit Gateway or Transit Gateway Attachment,\n   * this property must be ONE_MINUTES.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-maxaggregationinterval\n   *\n   * @default - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.\n   */\n  readonly maxAggregationInterval?: FlowLogMaxAggregationInterval;\n}\n\n/**\n * Properties of a VPC Flow Log\n */\nexport interface FlowLogProps extends FlowLogOptions {\n  /**\n   * The name of the FlowLog\n   *\n   * Since the FlowLog resource doesn't support providing a physical name, the value provided here will be recorded in the `Name` tag.\n   *\n   * @default CDK generated name\n   */\n  readonly flowLogName?: string;\n\n  /**\n   * The type of resource for which to create the flow log\n   */\n  readonly resourceType: FlowLogResourceType;\n}\n\n/**\n * The base class for a Flow Log\n */\nabstract class FlowLogBase extends AwsConstructBase implements IFlowLog {\n  /**\n   * The Id of the VPC Flow Log\n   *\n   * @attribute\n   */\n  public abstract readonly flowLogId: string;\n  public get flowLogOutputs(): FlowLogOutputs {\n    return {\n      flowLogId: this.flowLogId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.flowLogOutputs;\n  }\n}\n\n/**\n * A VPC flow log.\n * @resource AWS::EC2::FlowLog\n */\nexport class FlowLog extends FlowLogBase {\n  /**\n   * Import a Flow Log by it's Id\n   */\n  public static fromFlowLogId(\n    scope: Construct,\n    id: string,\n    flowLogId: string,\n  ): IFlowLog {\n    class Import extends FlowLogBase {\n      public flowLogId = flowLogId;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The Id of the VPC Flow Log\n   *\n   * @attribute\n   */\n  public readonly flowLogId: string;\n\n  /**\n   * The S3 bucket to publish flow logs to\n   */\n  public readonly bucket?: storage.IBucket;\n\n  /**\n   * S3 bucket key prefix to publish the flow logs under\n   */\n  readonly keyPrefix?: string;\n\n  /**\n   * The iam role used to publish logs to CloudWatch\n   */\n  public readonly iamRole?: iam.IRole;\n\n  /**\n   * The CloudWatch Logs LogGroup to publish flow logs to\n   */\n  public readonly logGroup?: logs.ILogGroup;\n\n  /**\n   * The ARN of the Kinesis Data Firehose delivery stream to publish flow logs to\n   */\n  public readonly deliveryStreamArn?: string;\n  public readonly resource: flowLog.FlowLog;\n\n  constructor(scope: Construct, id: string, props: FlowLogProps) {\n    super(scope, id);\n\n    const destination =\n      props.destination || FlowLogDestination.toCloudWatchLogs();\n\n    const destinationConfig = destination.bind(this, this);\n    this.logGroup = destinationConfig.logGroup;\n    this.bucket = destinationConfig.s3Bucket;\n    this.iamRole = destinationConfig.iamRole;\n    this.keyPrefix = destinationConfig.keyPrefix;\n    this.deliveryStreamArn = destinationConfig.deliveryStreamArn;\n\n    Tags.of(this).add(NAME_TAG, props.flowLogName || this.node.path);\n\n    let logDestination: string | undefined = undefined;\n    if (this.bucket) {\n      logDestination = this.keyPrefix\n        ? this.bucket.arnForObjects(this.keyPrefix)\n        : this.bucket.bucketArn;\n    }\n    if (this.deliveryStreamArn) {\n      logDestination = this.deliveryStreamArn;\n    }\n    let customLogFormat: string | undefined = undefined;\n    if (props.logFormat) {\n      customLogFormat = props.logFormat\n        .map((elm) => {\n          return elm.value;\n        })\n        .join(\" \");\n    }\n\n    let trafficType: FlowLogTrafficType | undefined =\n      props.trafficType ?? FlowLogTrafficType.ALL;\n    if (\n      props.resourceType.resourceType === \"TransitGateway\" ||\n      props.resourceType.resourceType === \"TransitGatewayAttachment\"\n    ) {\n      if (props.trafficType) {\n        throw new Error(\n          \"trafficType is not supported for Transit Gateway and Transit Gateway Attachment\",\n        );\n      }\n      if (\n        props.maxAggregationInterval &&\n        props.maxAggregationInterval !==\n          FlowLogMaxAggregationInterval.ONE_MINUTE\n      ) {\n        throw new Error(\n          \"maxAggregationInterval must be set to ONE_MINUTE for Transit Gateway and Transit Gateway Attachment\",\n        );\n      }\n      trafficType = undefined;\n    }\n\n    // convert AWSCC -> AWS resourceIdProps\n    // TODO: Adopt AWSCC\n    let resourceIdProps: {\n      eniId?: string;\n      subnetId?: string;\n      transitGatewayId?: string;\n      transitGatewayAttachmentId?: string;\n      vpcId?: string;\n    };\n    switch (props.resourceType.resourceType) {\n      case \"NetworkInterface\":\n        resourceIdProps = { eniId: props.resourceType.resourceId };\n        break;\n      case \"Subnet\":\n        resourceIdProps = { subnetId: props.resourceType.resourceId };\n        break;\n      case \"TransitGateway\":\n        resourceIdProps = { transitGatewayId: props.resourceType.resourceId };\n        break;\n      case \"TransitGatewayAttachment\":\n        resourceIdProps = {\n          transitGatewayAttachmentId: props.resourceType.resourceId,\n        };\n        break;\n      case \"VPC\":\n        resourceIdProps = { vpcId: props.resourceType.resourceId };\n        break;\n      default:\n        throw new Error(\"Invalid resource type: \" + props.resourceType);\n    }\n\n    this.resource = new flowLog.FlowLog(this, \"Resource\", {\n      destinationOptions: destinationConfig.destinationOptions,\n      iamRoleArn: this.iamRole ? this.iamRole.roleArn : undefined,\n      logDestinationType: destinationConfig.logDestinationType,\n      logGroupName: this.logGroup ? this.logGroup.logGroupName : undefined,\n      maxAggregationInterval: props.maxAggregationInterval,\n      id: props.resourceType.resourceId,\n      trafficType,\n      logFormat: customLogFormat,\n      logDestination,\n      ...resourceIdProps,\n    });\n\n    // VPC service implicitly tries to create a bucket policy when adding a vpc flow log.\n    // To avoid the race condition, we add an explicit dependency here.\n    if (this.bucket?.policy?.node.defaultChild instanceof TerraformResource) {\n      this.resource.node.addDependency(this.bucket?.policy.node.defaultChild);\n    }\n\n    // TODO: we must remove a flow log configuration first before deleting objects.\n    // TODO: S3 Bucket object removal custom resource?\n    // const deleteObjects = this.bucket?.node.tryFindChild(\n    //   \"AutoDeleteObjectsCustomResource\",\n    // )?.node.defaultChild;\n    // if (deleteObjects instanceof TerraformResource) {\n    //   resource.node.addDependency(deleteObjects);\n    // }\n\n    this.flowLogId = this.resource.id;\n  }\n}\n"]}