Temporal configuration
[temporal]
[temporal.query]
[temporal.query]
default_last_n = 100
max_last_n = 1000
max_edge_group = 100000
max_aggregation_instances = 1000000
Instances per attribute a temporal read without lastN returns before it is paged forwards.
The largest lastN answered in one response. A larger lastN is narrowed to this many instances per attribute and paged backwards with a 206 whose Content-Range still reports the requested lastN. It is also the most whole periods per attribute on one page of an aggregated read.
The most instances of one attribute sharing one instant that a temporal page carries. A page never splits the instances sharing the instant at its edge, since a client resumes from a timestamp that cannot point inside an instant, so it carries them whole however far past its size that takes it. A larger group is refused with 403 TooManyResults.
The most raw instances per attribute one page of an aggregated temporal read folds, beside its temporal.query.max_last_n periods. A page that would fold more ends at the start of the period the first instance beyond the bound falls in; a first period holding more than the bound is read whole, since a period is never split.
[temporal.history]
[temporal.history]
core_writes = "recorded"
batch_size = 256
stuck_after_attempts = 10
Whether Core API writes add to the history of the entities they change. With "not-recorded" only the Temporal API writes history, for a producer that publishes its history there alone; Core writes change current state, and Core queries see them, either way.
The most history writes one pass claims. The pass applies them in one transaction, so a larger batch spreads each statement's cost over more writes.
Failed attempts from which a history write that keeps failing is reported stuck, logged and counted on each further failure. It is never discarded, since it is history the broker has already accepted, and it keeps being retried, never waiting longer than temporal.history.queue.max_retry_interval.
[temporal.history.queue]
respond-async batches. A failed write is retried on a delay that doubles from temporal.history.queue.retry_interval up to temporal.history.queue.max_retry_interval.[temporal.history.queue]
poll_interval = "1s"
max_poll_interval = "30s"
lease_timeout = "30s"
retry_interval = "2s"
max_retry_interval = "5m"
How soon an idle worker polls again once a commit's wake has been handled: the floor of its idle backoff. A commit in the same broker process wakes the worker at once.
The longest the idle backoff grows to while no commit wakes the worker. Also how soon a job committed by another broker process is picked up.
How long a claim keeps a job from every other worker. A worker that dies leaves its jobs unclaimable for the rest of the term. It is applied in whole seconds, rounded down.
The delay before a failed job's first retry. Each later retry waits twice as long as the one before, up to the longest retry delay.
The longest a retry delay grows to.
[temporal.storage]
[temporal.storage]
# chunk_interval = "7days"
The span of time one history partition covers. Left out, the broker leaves each history table's partitioning as it stands, which is 7 days on a table it created. A change is reconciled against the stored partitioning when the broker next opens the tenant; shorten it if the largest partition still in the rowstore keeps passing 4 GB.
[temporal.storage.columnstore]
[temporal.storage.columnstore]
convert_after = "30days"
sweep_interval = "1h"
The age past which a history partition is converted to the columnstore. Only the TimescaleDB TSL edition has a columnstore; on the Apache-2.0 edition the key has no effect.
How often partitions past temporal.storage.columnstore.convert_after are converted. The first sweep runs when a tenant opens.
[temporal.storage.retention]
[temporal.storage.retention]
mode = "disabled"
# delete_after = "365days"
sweep_interval = "1h"
Whether history older than temporal.storage.retention.delete_after is deleted. A broker never deletes history it was not told to.
How much history to keep. History partitions recorded entirely before this age are dropped, together with the Scope history no remaining instance needs. Left out, no age is set and no history is deleted.
How often history past temporal.storage.retention.delete_after is deleted while retention is enabled. The first sweep runs when a tenant opens.