Below is a table containing all the details for the property group: Metadata
| Property Name | Description | Default Value | Run CdkDeploy When Changed |
|---|---|---|---|
| sleeper.table.statestore.classname | The name of the class used for the state store. The default is DynamoDBTransactionLogStateStore. Options are: sleeper.statestore.transactionlog.DynamoDBTransactionLogStateStore sleeper.statestore.transactionlog.DynamoDBTransactionLogStateStoreNoSnapshots |
sleeper.statestore.transactionlog.DynamoDBTransactionLogStateStore | false |
| sleeper.table.statestore.commit.async.enabled | Overrides whether or not to apply state store updates asynchronously via the state store committer. Usually this is decided based on the state store implementation used by the Sleeper table, but other default behaviour can be set for the Sleeper instance. This is separate from the properties that determine which state store updates will be done as asynchronous commits. Those properties will only be applied when asynchronous commits are enabled. |
false | |
| sleeper.table.statestore.committer.update.every.commit | When using the transaction log state store, this sets whether to update from the transaction log before adding a transaction in the asynchronous state store committer. If asynchronous commits are used for all or almost all state store updates, this can be false to avoid the extra queries. If the state store is commonly updated directly outside of the asynchronous committer, this can be true to avoid conflicts and retries. |
false | false |
| sleeper.table.statestore.committer.update.every.batch | When using the transaction log state store, this sets whether to update from the transaction log before adding a batch of transactions in the asynchronous state store committer. | true | false |
| sleeper.table.statestore.transactionlog.add.transaction.max.attempts | The number of attempts to make when applying a transaction to the state store. | 10 | false |
| sleeper.table.statestore.transactionlog.add.transaction.first.retry.wait.ceiling.ms | The maximum amount of time to wait before the first retry when applying a transaction to the state store. Full jitter will be applied so that the actual wait time will be a random period between 0 and this value. This ceiling will increase exponentially on further retries. See the below article. https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/ |
200 | false |
| sleeper.table.statestore.transactionlog.add.transaction.max.retry.wait.ceiling.ms | The maximum amount of time to wait before any retry when applying a transaction to the state store. Full jitter will be applied so that the actual wait time will be a random period between 0 and this value. This restricts the exponential increase of the wait ceiling while retrying the transaction. See the below article. https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/ |
30000 | false |
| sleeper.table.statestore.transactionlog.files.snapshot.batch.size | The number of elements to include per Arrow record batch in a snapshot derived from the transaction log, of the state of files in a Sleeper table. Each file includes some number of references on different partitions. Each reference will count for one element in a record batch, but a file cannot currently be split between record batches. A record batch may contain more file references than this if a single file overflows the batch. A file with no references counts as one element. | 1000 | false |
| sleeper.table.statestore.transactionlog.partitions.snapshot.batch.size | The number of partitions to include per Arrow record batch in a snapshot derived from the transaction log, of the state of partitions in a Sleeper table. | 1000 | false |
| sleeper.table.statestore.transactionlog.time.between.snapshot.checks.seconds | The number of seconds to wait after we've loaded a snapshot before looking for a new snapshot. This should relate to the rate at which new snapshots are created, configured in the instance property sleeper.statestore.transactionlog.snapshot.creation.lambda.period.seconds. |
60 | false |
| sleeper.table.statestore.transactionlog.time.between.transaction.checks.ms | The number of milliseconds to wait after we've updated from the transaction log before checking for new transactions. The state visible to an instance of the state store can be out of date by this amount. This can avoid excessive queries by the same process, but can result in unwanted behaviour when using multiple state store objects. When adding a new transaction to update the state, this will be ignored and the state will be brought completely up to date. | 0 | false |
| sleeper.table.statestore.transactionlog.snapshot.load.min.transactions.ahead | The minimum number of transactions that a snapshot must be ahead of the local state, before we load the snapshot instead of updating from the transaction log. | 10 | false |
| sleeper.table.statestore.transactionlog.snapshot.expiry.days | The number of days that transaction log snapshots remain in the snapshot store before being deleted. | 2 | false |
| sleeper.table.statestore.transactionlog.delete.behind.snapshot.min.age.minutes | The minimum age in minutes of a snapshot in order to allow deletion of transactions leading up to it. When deleting old transactions, there's a chance that processes may still read transactions starting from an older snapshot. We need to avoid deletion of any transactions associated with a snapshot that may still be used as the starting point for reading the log. | 2 | false |
| sleeper.table.statestore.transactionlog.delete.number.behind.latest.snapshot | The minimum number of transactions that a transaction must be behind the latest snapshot before being deleted. This is the number of transactions that will be kept and protected from deletion, whenever old transactions are deleted. This includes the transaction that the latest snapshot was created against. Any transactions after the snapshot will never be deleted as they are still in active use. This should be configured in relation to the property which determines whether a process will load the latest snapshot or instead seek through the transaction log, since we need to preserve transactions that may still be read: sleeper.table.statestore.snapshot.load.min.transactions.ahead The snapshot that will be considered the latest snapshot is configured by a property to set the minimum age for it to count for this: sleeper.table.statestore.transactionlog.delete.behind.snapshot.min.age |
200 | false |
| sleeper.table.statestore.dynamo.consistent.reads | This specifies whether queries and scans against DynamoDB tables used in the state stores are strongly consistent. | false | false |