Skip to content
v2.277.0

Experimental

@aws-cdk/integ-tests-alpha is an experimental (alpha) package: its API may change in any release, without a major version bump.

WaiterStateMachineOptions Struct ​

Options for creating a WaiterStateMachine.

Example ​

ts
#!/usr/bin/env node
import * as path from 'path';
import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
import * as kms from 'aws-cdk-lib/aws-kms';
import * as lambdanodejs from 'aws-cdk-lib/aws-lambda-nodejs';
import * as logs from 'aws-cdk-lib/aws-logs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as cdk from 'aws-cdk-lib';
import { AwsApiCall, ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';

const app = new cdk.App({
  postCliContext: {
    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
  },
});

const stack = new cdk.Stack(app, 'aws-cdk-firehose-delivery-stream-s3-all-properties');

const bucket = new s3.Bucket(stack, 'FirehoseDeliveryStreamS3AllPropertiesBucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  autoDeleteObjects: true,
});

const backupBucket = new s3.Bucket(stack, 'FirehoseDeliveryStreamS3AllPropertiesBackupBucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  autoDeleteObjects: true,
});
const logGroup = new logs.LogGroup(stack, 'LogGroup', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const dataProcessorFunction = new lambdanodejs.NodejsFunction(stack, 'DataProcessorFunction', {
  entry: path.join(__dirname, 'lambda-data-processor.js'),
  timeout: cdk.Duration.minutes(1),
});

const processor = new firehose.LambdaFunctionProcessor(dataProcessorFunction, {
  bufferInterval: cdk.Duration.seconds(60),
  bufferSize: cdk.Size.mebibytes(1),
  retries: 1,
});

const key = new kms.Key(stack, 'Key', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const backupKey = new kms.Key(stack, 'BackupKey', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const deliveryStream = new firehose.DeliveryStream(stack, 'DeliveryStream', {
  destination: new firehose.S3Bucket(bucket, {
    loggingConfig: new firehose.EnableLogging(logGroup),
    processors: [processor],
    compression: firehose.Compression.GZIP,
    dataOutputPrefix: 'regularPrefix',
    errorOutputPrefix: 'errorPrefix',
    fileExtension: '.log.gz',
    timeZone: cdk.TimeZone.ASIA_TOKYO,
    bufferingInterval: cdk.Duration.seconds(60),
    bufferingSize: cdk.Size.mebibytes(1),
    encryptionKey: key,
    s3Backup: {
      mode: firehose.BackupMode.ALL,
      bucket: backupBucket,
      compression: firehose.Compression.ZIP,
      dataOutputPrefix: 'backupPrefix',
      errorOutputPrefix: 'backupErrorPrefix',
      bufferingInterval: cdk.Duration.seconds(60),
      bufferingSize: cdk.Size.mebibytes(1),
      encryptionKey: backupKey,
    },
  }),
});

new firehose.DeliveryStream(stack, 'ZeroBufferingDeliveryStream', {
  destination: new firehose.S3Bucket(bucket, {
    compression: firehose.Compression.GZIP,
    dataOutputPrefix: 'regularPrefix',
    errorOutputPrefix: 'errorPrefix',
    bufferingInterval: cdk.Duration.seconds(0),
  }),
});

const testCase = new IntegTest(app, 'integ-tests', {
  testCases: [stack],
  regions: ['us-east-1'],
});

testCase.assertions.awsApiCall('Firehose', 'putRecord', {
  DeliveryStreamName: deliveryStream.deliveryStreamName,
  Record: {
    Data: 'testData123',
  },
});

const s3ApiCall = testCase.assertions.awsApiCall('S3', 'listObjectsV2', {
  Bucket: bucket.bucketName,
  MaxKeys: 1,
}).expect(ExpectedResult.objectLike({
  KeyCount: 1,
})).waitForAssertions({
  interval: cdk.Duration.seconds(30),
  totalTimeout: cdk.Duration.minutes(10),
});

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.waiterProvider) {
  s3ApiCall.waiterProvider.addToRolePolicy({
    Effect: 'Allow',
    Action: ['s3:GetObject', 's3:ListBucket'],
    Resource: ['*'],
  });
}
python
import path as path
import aws_cdk.aws_kinesisfirehose as firehose
import aws_cdk.aws_kms as kms
import aws_cdk.aws_lambda_nodejs as lambdanodejs
import aws_cdk.aws_logs as logs
import aws_cdk.aws_s3 as s3
import aws_cdk as cdk
from aws_cdk.integ_tests_alpha import AwsApiCall, ExpectedResult, IntegTest

app = cdk.App(
    post_cli_context={
        "@aws-cdk/aws-lambda:useCdkManagedLogGroup": False
    }
)

stack = cdk.Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties")

bucket = s3.Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket",
    removal_policy=cdk.RemovalPolicy.DESTROY,
    auto_delete_objects=True
)

backup_bucket = s3.Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket",
    removal_policy=cdk.RemovalPolicy.DESTROY,
    auto_delete_objects=True
)
log_group = logs.LogGroup(stack, "LogGroup",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

data_processor_function = lambdanodejs.NodejsFunction(stack, "DataProcessorFunction",
    entry=path.join(__dirname, "lambda-data-processor.js"),
    timeout=cdk.Duration.minutes(1)
)

processor = firehose.LambdaFunctionProcessor(data_processor_function,
    buffer_interval=cdk.Duration.seconds(60),
    buffer_size=cdk.Size.mebibytes(1),
    retries=1
)

key = kms.Key(stack, "Key",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

backup_key = kms.Key(stack, "BackupKey",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

delivery_stream = firehose.DeliveryStream(stack, "DeliveryStream",
    destination=firehose.S3Bucket(bucket,
        logging_config=firehose.EnableLogging(log_group),
        processors=[processor],
        compression=firehose.Compression.GZIP,
        data_output_prefix="regularPrefix",
        error_output_prefix="errorPrefix",
        file_extension=".log.gz",
        time_zone=cdk.TimeZone.ASIA_TOKYO,
        buffering_interval=cdk.Duration.seconds(60),
        buffering_size=cdk.Size.mebibytes(1),
        encryption_key=key,
        s3_backup=firehose.DestinationS3BackupProps(
            mode=firehose.BackupMode.ALL,
            bucket=backup_bucket,
            compression=firehose.Compression.ZIP,
            data_output_prefix="backupPrefix",
            error_output_prefix="backupErrorPrefix",
            buffering_interval=cdk.Duration.seconds(60),
            buffering_size=cdk.Size.mebibytes(1),
            encryption_key=backup_key
        )
    )
)

firehose.DeliveryStream(stack, "ZeroBufferingDeliveryStream",
    destination=firehose.S3Bucket(bucket,
        compression=firehose.Compression.GZIP,
        data_output_prefix="regularPrefix",
        error_output_prefix="errorPrefix",
        buffering_interval=cdk.Duration.seconds(0)
    )
)

test_case = IntegTest(app, "integ-tests",
    test_cases=[stack],
    regions=["us-east-1"]
)

test_case.assertions.aws_api_call("Firehose", "putRecord", {
    "DeliveryStreamName": delivery_stream.delivery_stream_name,
    "Record": {
        "Data": "testData123"
    }
})

s3_api_call = test_case.assertions.aws_api_call("S3", "listObjectsV2", {
    "Bucket": bucket.bucket_name,
    "MaxKeys": 1
}).expect(ExpectedResult.object_like({
    "KeyCount": 1
})).wait_for_assertions(
    interval=cdk.Duration.seconds(30),
    total_timeout=cdk.Duration.minutes(10)
)

if s3_api_call instanceof AwsApiCall && s3_api_call.waiter_provider:
    s3_api_call.waiter_provider.add_to_role_policy({
        "Effect": "Allow",
        "Action": ["s3:GetObject", "s3:ListBucket"],
        "Resource": ["*"]
    })
java
import path.*;
import software.amazon.awscdk.services.kinesisfirehose.*;
import software.amazon.awscdk.services.kms.*;
import software.amazon.awscdk.services.lambda.nodejs.*;
import software.amazon.awscdk.services.logs.*;
import software.amazon.awscdk.services.s3.*;
import software.amazon.awscdk.*;
import software.amazon.awscdk.integtests.alpha.AwsApiCall;
import software.amazon.awscdk.integtests.alpha.ExpectedResult;
import software.amazon.awscdk.integtests.alpha.IntegTest;

App app = App.Builder.create()
        .postCliContext(Map.of(
                "@aws-cdk/aws-lambda:useCdkManagedLogGroup", false))
        .build();

Stack stack = new Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties");

Bucket bucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket")
        .removalPolicy(RemovalPolicy.DESTROY)
        .autoDeleteObjects(true)
        .build();

Bucket backupBucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket")
        .removalPolicy(RemovalPolicy.DESTROY)
        .autoDeleteObjects(true)
        .build();
LogGroup logGroup = LogGroup.Builder.create(stack, "LogGroup")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

NodejsFunction dataProcessorFunction = NodejsFunction.Builder.create(stack, "DataProcessorFunction")
        .entry(join(__dirname, "lambda-data-processor.js"))
        .timeout(Duration.minutes(1))
        .build();

LambdaFunctionProcessor processor = LambdaFunctionProcessor.Builder.create(dataProcessorFunction)
        .bufferInterval(Duration.seconds(60))
        .bufferSize(Size.mebibytes(1))
        .retries(1)
        .build();

Key key = Key.Builder.create(stack, "Key")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

Key backupKey = Key.Builder.create(stack, "BackupKey")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

DeliveryStream deliveryStream = DeliveryStream.Builder.create(stack, "DeliveryStream")
        .destination(S3Bucket.Builder.create(bucket)
                .loggingConfig(new EnableLogging(logGroup))
                .processors(List.of(processor))
                .compression(Compression.GZIP)
                .dataOutputPrefix("regularPrefix")
                .errorOutputPrefix("errorPrefix")
                .fileExtension(".log.gz")
                .timeZone(TimeZone.ASIA_TOKYO)
                .bufferingInterval(Duration.seconds(60))
                .bufferingSize(Size.mebibytes(1))
                .encryptionKey(key)
                .s3Backup(DestinationS3BackupProps.builder()
                        .mode(BackupMode.ALL)
                        .bucket(backupBucket)
                        .compression(Compression.ZIP)
                        .dataOutputPrefix("backupPrefix")
                        .errorOutputPrefix("backupErrorPrefix")
                        .bufferingInterval(Duration.seconds(60))
                        .bufferingSize(Size.mebibytes(1))
                        .encryptionKey(backupKey)
                        .build())
                .build())
        .build();

DeliveryStream.Builder.create(stack, "ZeroBufferingDeliveryStream")
        .destination(S3Bucket.Builder.create(bucket)
                .compression(Compression.GZIP)
                .dataOutputPrefix("regularPrefix")
                .errorOutputPrefix("errorPrefix")
                .bufferingInterval(Duration.seconds(0))
                .build())
        .build();

IntegTest testCase = IntegTest.Builder.create(app, "integ-tests")
        .testCases(List.of(stack))
        .regions(List.of("us-east-1"))
        .build();

testCase.assertions.awsApiCall("Firehose", "putRecord", Map.of(
        "DeliveryStreamName", deliveryStream.getDeliveryStreamName(),
        "Record", Map.of(
                "Data", "testData123")));

IApiCall s3ApiCall = testCase.assertions.awsApiCall("S3", "listObjectsV2", Map.of(
        "Bucket", bucket.bucketName,
        "MaxKeys", 1)).expect(ExpectedResult.objectLike(Map.of(
        "KeyCount", 1))).waitForAssertions(WaiterStateMachineOptions.builder()
        .interval(Duration.seconds(30))
        .totalTimeout(Duration.minutes(10))
        .build());

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.getWaiterProvider()) {
    s3ApiCall.waiterProvider.addToRolePolicy(Map.of(
            "Effect", "Allow",
            "Action", List.of("s3:GetObject", "s3:ListBucket"),
            "Resource", List.of("*")));
}
csharp
// Install: dotnet add package Amazon.CDK.IntegTests.Alpha
using Path;
using Amazon.CDK.AWS.KinesisFirehose;
using Amazon.CDK.AWS.KMS;
using Amazon.CDK.AWS.Lambda.Nodejs;
using Amazon.CDK.AWS.Logs;
using Amazon.CDK.AWS.S3;
using Amazon.CDK;
using Amazon.CDK.IntegTests.Alpha;

var app = new App(new AppProps {
    PostCliContext = new Dictionary<string, object> {
        { "@aws-cdk/aws-lambda:useCdkManagedLogGroup", false }
    }
});

var stack = new Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties");

var bucket = new Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket", new BucketProps {
    RemovalPolicy = RemovalPolicy.DESTROY,
    AutoDeleteObjects = true
});

var backupBucket = new Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket", new BucketProps {
    RemovalPolicy = RemovalPolicy.DESTROY,
    AutoDeleteObjects = true
});
var logGroup = new LogGroup(stack, "LogGroup", new LogGroupProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var dataProcessorFunction = new NodejsFunction(stack, "DataProcessorFunction", new NodejsFunctionProps {
    Entry = Join(__dirname, "lambda-data-processor.js"),
    Timeout = Duration.Minutes(1)
});

var processor = new LambdaFunctionProcessor(dataProcessorFunction, new DataProcessorProps {
    BufferInterval = Duration.Seconds(60),
    BufferSize = Size.Mebibytes(1),
    Retries = 1
});

var key = new Key(stack, "Key", new KeyProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var backupKey = new Key(stack, "BackupKey", new KeyProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var deliveryStream = new DeliveryStream(stack, "DeliveryStream", new DeliveryStreamProps {
    Destination = new S3Bucket(bucket, new S3BucketProps {
        LoggingConfig = new EnableLogging(logGroup),
        Processors = new [] { processor },
        Compression = Compression.GZIP,
        DataOutputPrefix = "regularPrefix",
        ErrorOutputPrefix = "errorPrefix",
        FileExtension = ".log.gz",
        TimeZone = TimeZone.ASIA_TOKYO,
        BufferingInterval = Duration.Seconds(60),
        BufferingSize = Size.Mebibytes(1),
        EncryptionKey = key,
        S3Backup = new DestinationS3BackupProps {
            Mode = BackupMode.ALL,
            Bucket = backupBucket,
            Compression = Compression.ZIP,
            DataOutputPrefix = "backupPrefix",
            ErrorOutputPrefix = "backupErrorPrefix",
            BufferingInterval = Duration.Seconds(60),
            BufferingSize = Size.Mebibytes(1),
            EncryptionKey = backupKey
        }
    })
});

new DeliveryStream(stack, "ZeroBufferingDeliveryStream", new DeliveryStreamProps {
    Destination = new S3Bucket(bucket, new S3BucketProps {
        Compression = Compression.GZIP,
        DataOutputPrefix = "regularPrefix",
        ErrorOutputPrefix = "errorPrefix",
        BufferingInterval = Duration.Seconds(0)
    })
});

var testCase = new IntegTest(app, "integ-tests", new IntegTestProps {
    TestCases = new [] { stack },
    Regions = new [] { "us-east-1" }
});

testCase.Assertions.AwsApiCall("Firehose", "putRecord", new Dictionary<string, object> {
    { "DeliveryStreamName", deliveryStream.DeliveryStreamName },
    { "Record", new Struct {
        Data = "testData123"
    } }
});

var s3ApiCall = testCase.Assertions.AwsApiCall("S3", "listObjectsV2", new Dictionary<string, object> {
    { "Bucket", bucket.BucketName },
    { "MaxKeys", 1 }
}).Expect(ExpectedResult.ObjectLike(new Dictionary<string, object> {
    { "KeyCount", 1 }
})).WaitForAssertions(new WaiterStateMachineOptions {
    Interval = Duration.Seconds(30),
    TotalTimeout = Duration.Minutes(10)
});

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.WaiterProvider)
{
    s3ApiCall.WaiterProvider.AddToRolePolicy(new Dictionary<string, object> {
        { "Effect", "Allow" },
        { "Action", new [] { "s3:GetObject", "s3:ListBucket" } },
        { "Resource", new [] { "*" } }
    });
}
go
// Install: go get github.com/aws/aws-cdk-go/awscdkintegtestsalpha/v2
import path "github.com/aws-samples/dummy/path"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import lambdanodejs "github.com/aws/aws-cdk-go/awscdk"
import logs "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdkintegtestsalpha"

app := cdk.NewApp(&AppProps{
	PostCliContext: map[string]interface{}{
		"@aws-cdk/aws-lambda:useCdkManagedLogGroup": jsii.Boolean(false),
	},
})

stack := cdk.NewStack(app, jsii.String("aws-cdk-firehose-delivery-stream-s3-all-properties"))

bucket := s3.NewBucket(stack, jsii.String("FirehoseDeliveryStreamS3AllPropertiesBucket"), &BucketProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	AutoDeleteObjects: jsii.Boolean(true),
})

backupBucket := s3.NewBucket(stack, jsii.String("FirehoseDeliveryStreamS3AllPropertiesBackupBucket"), &BucketProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	AutoDeleteObjects: jsii.Boolean(true),
})
logGroup := logs.NewLogGroup(stack, jsii.String("LogGroup"), &LogGroupProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

dataProcessorFunction := lambdanodejs.NewNodejsFunction(stack, jsii.String("DataProcessorFunction"), &NodejsFunctionProps{
	Entry: path.join(__dirname, jsii.String("lambda-data-processor.js")),
	Timeout: cdk.Duration_Minutes(jsii.Number(1)),
})

processor := firehose.NewLambdaFunctionProcessor(dataProcessorFunction, &DataProcessorProps{
	BufferInterval: cdk.Duration_Seconds(jsii.Number(60)),
	BufferSize: cdk.Size_Mebibytes(jsii.Number(1)),
	Retries: jsii.Number(1),
})

key := kms.NewKey(stack, jsii.String("Key"), &KeyProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

backupKey := kms.NewKey(stack, jsii.String("BackupKey"), &KeyProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

deliveryStream := firehose.NewDeliveryStream(stack, jsii.String("DeliveryStream"), &DeliveryStreamProps{
	Destination: firehose.NewS3Bucket(bucket, &S3BucketProps{
		LoggingConfig: firehose.NewEnableLogging(logGroup),
		Processors: []IDataProcessor{
			processor,
		},
		Compression: firehose.Compression_GZIP(),
		DataOutputPrefix: jsii.String("regularPrefix"),
		ErrorOutputPrefix: jsii.String("errorPrefix"),
		FileExtension: jsii.String(".log.gz"),
		TimeZone: cdk.TimeZone_ASIA_TOKYO(),
		BufferingInterval: cdk.Duration_*Seconds(jsii.Number(60)),
		BufferingSize: cdk.Size_*Mebibytes(jsii.Number(1)),
		EncryptionKey: key,
		S3Backup: &DestinationS3BackupProps{
			Mode: firehose.BackupMode_ALL,
			Bucket: backupBucket,
			Compression: firehose.Compression_ZIP(),
			DataOutputPrefix: jsii.String("backupPrefix"),
			ErrorOutputPrefix: jsii.String("backupErrorPrefix"),
			BufferingInterval: cdk.Duration_*Seconds(jsii.Number(60)),
			BufferingSize: cdk.Size_*Mebibytes(jsii.Number(1)),
			EncryptionKey: backupKey,
		},
	}),
})

firehose.NewDeliveryStream(stack, jsii.String("ZeroBufferingDeliveryStream"), &DeliveryStreamProps{
	Destination: firehose.NewS3Bucket(bucket, &S3BucketProps{
		Compression: firehose.Compression_GZIP(),
		DataOutputPrefix: jsii.String("regularPrefix"),
		ErrorOutputPrefix: jsii.String("errorPrefix"),
		BufferingInterval: cdk.Duration_*Seconds(jsii.Number(0)),
	}),
})

testCase := awscdkintegtestsalpha.NewIntegTest(app, jsii.String("integ-tests"), &IntegTestProps{
	TestCases: []Stack{
		stack,
	},
	Regions: []*string{
		jsii.String("us-east-1"),
	},
})

testCase.Assertions.AwsApiCall(jsii.String("Firehose"), jsii.String("putRecord"), map[string]interface{}{
	"DeliveryStreamName": deliveryStream.deliveryStreamName,
	"Record": map[string]*string{
		"Data": jsii.String("testData123"),
	},
})

s3ApiCall := testCase.Assertions.AwsApiCall(jsii.String("S3"), jsii.String("listObjectsV2"), map[string]interface{}{
	"Bucket": bucket.bucketName,
	"MaxKeys": jsii.Number(1),
}).Expect(awscdkintegtestsalpha.ExpectedResult_ObjectLike(map[string]interface{}{
	"KeyCount": jsii.Number(1),
})).WaitForAssertions(&WaiterStateMachineOptions{
	Interval: cdk.Duration_*Seconds(jsii.Number(30)),
	TotalTimeout: cdk.Duration_*Minutes(jsii.Number(10)),
})

if s3ApiCall instanceof awscdkintegtestsalpha.AwsApiCall && s3ApiCall.WaiterProvider {
	s3ApiCall.WaiterProvider.AddToRolePolicy(map[string]interface{}{
		"Effect": jsii.String("Allow"),
		"Action": []*string{
			jsii.String("s3:GetObject"),
			jsii.String("s3:ListBucket"),
		},
		"Resource": []*string{
			jsii.String("*"),
		},
	})
}

Properties ​

backoffRateoptionalnumberbackoff_rateoptionalint | floatbackoffRateoptionalNumberBackoffRateoptionaldoubleBackoffRateoptional*float64 #
Backoff between attempts.

Default: 1 (no backoff)

This is the multiplier by which the retry interval increases after each retry attempt.

By default there is no backoff. Each retry will wait the amount of time specified by interval.

intervaloptionalDurationintervaloptionalDurationintervaloptionalDurationIntervaloptionalDurationIntervaloptionalDuration = Duration.seconds(5) #
The interval (number of seconds) to wait between attempts.
providerLogLeveloptionalApplicationLogLevelprovider_log_leveloptionalApplicationLogLevelproviderLogLeveloptionalApplicationLogLevelProviderLogLeveloptionalApplicationLogLevelProviderLogLeveloptionalApplicationLogLevel = ApplicationLogLevel.FATAL #
The log level of the provider lambda function.
totalTimeoutoptionalDurationtotal_timeoutoptionalDurationtotalTimeoutoptionalDurationTotalTimeoutoptionalDurationTotalTimeoutoptionalDuration = Duration.minutes(30) #
The total time that the state machine will wait for a successful response.