[role="xpack"]
[[transform-checkpoints]]
= How {transform} checkpoints work
++++
<titleabbrev>How checkpoints work</titleabbrev>
++++

Each time a {transform} examines the source indices and creates or
updates the destination index, it generates a _checkpoint_.

If your {transform} runs only once, there is logically only one
checkpoint. If your {transform} runs continuously, however, it creates
checkpoints as it ingests and transforms new source data.

To create a checkpoint, the {ctransform}:

. Checks for changes to source indices.
+
Using a simple periodic timer, the {transform} checks for changes to
the source indices. This check is done based on the interval defined in the
transform's `frequency` property.
+
If the source indices remain unchanged or if a checkpoint is already in progress
then it waits for the next timer.

. Identifies which entities have changed.
+
The {transform} searches to see which entities have changed since the
last time it checked. The `sync` configuration object in the {transform}
identifies a time field in the source indices. The {transform} uses the values
in that field to synchronize the source and destination indices.
 
. Updates the destination index (the {dataframe}) with the changed entities.
+
--
The {transform} applies changes related to either new or changed
entities to the destination index. The set of changed entities is paginated. For
each page, the {transform} performs a composite aggregation using a
`terms` query. After all the pages of changes have been applied, the checkpoint
is complete.
--

This checkpoint process involves both search and indexing activity on the
cluster. We have attempted to favor control over performance while developing
{transforms}. We decided it was preferable for the
{transform} to take longer to complete, rather than to finish quickly
and take precedence in resource consumption. That being said, the cluster still
requires enough resources to support both the composite aggregation search and
the indexing of its results. 

TIP: If the cluster experiences unsuitable performance degradation due to the
{transform}, stop the {transform} and refer to <<transform-performance>>.

[discrete]
[[ml-transform-checkpoint-errors]]
== Error handling

Failures in {transforms} tend to be related to searching or indexing.
To increase the resiliency of {transforms}, the cursor positions of
the aggregated search and the changed entities search are tracked in memory and
persisted periodically.

Checkpoint failures can be categorized as follows:

* Temporary failures: The checkpoint is retried. If 10 consecutive failures
occur, the {transform} has a failed status. For example, this
situation might occur when there are shard failures and queries return only
partial results.
* Irrecoverable failures: The {transform} immediately fails. For
example, this situation occurs when the source index is not found.
* Adjustment failures: The {transform} retries with adjusted settings.
For example, if a parent circuit breaker memory errors occur during the
composite aggregation, the {transform} receives partial results. The aggregated
search is retried with a smaller number of buckets. This retry is performed at
the interval defined in the `frequency` property for the {transform}. If the
search is retried to the point where it reaches a minimal number of buckets, an
irrecoverable failure occurs.

If the node running the {transforms} fails, the {transform} restarts
from the most recent persisted cursor position. This recovery process might
repeat some of the work the {transform} had already done, but it ensures data
consistency.