...

Real life use cases can be taken from the energy sector. The automatic closed loop balancing of the power grid requires calculations to be published at the start of every 10th second. Today, this is solved by a work-around utilising a "has published this interval"-flag, and a state store to ensure a punctuation is only triggered once per interval: 

class PunctuateProcessor(
    private val hasForwardedStoreName: String,
    private val forwardTime: Duration,
) : ContextualProcessor<String, avro_value, String, avro_value>(),
    ILogging by Logging<PunctuateProcessor>() {
    private lateinit var hasForwardStore: WindowStore<String, Boolean>
    private lateinit var forwardSchedule: Cancellable

    private val hasForwardStoreKey = "hasPublished"

    override fun init(context: ProcessorContext<String, avro_value>) {
        super.init(context)
        this.hasForwardStore = context.getStateStore(hasForwardedStoreName)

        forwardSchedule =
            context().schedule(Duration.ofMillis(500), PunctuationType.WALL_CLOCK_TIME) { forwardRecordsIfTime() }
    }

    override fun process(record: Record<String, avro_value>) {
        // Store incoming records
    }

    private fun forwardRecordsIfTime() {
        val currentTime = Duration.ofMillis(context().currentSystemTimeMs())
        val flooredTime = Duration.ofMillis(floorTo10Second(currentTime.toMillis()))

        if (isTimeToForward(currentTime) && !hasForwardedThisInterval(flooredTime)) {
            forwardRecords()
            hasForwardStore.put(hasForwardStoreKey, true, flooredTime.toMillis())
        }
    }

    private fun isTimeToForward(currentTime: Duration): Boolean = (currentTime.toSecondsPart() % 10) >= (forwardTime.toSecondsPart() % 10)

    private fun hasForwardedThisInterval(intervalStart: Duration): Boolean =
        hasForwardStore.fetch(hasForwardStoreKey, intervalStart.toMillis()) ?: false

Generally, the work-around can be characterised as flag-polling, where the poll frequency is determined by a wall-clock punctuation. Hence, the punctuation trigger time is also only as precise as the wall-clock punctuation trigger interval. A more frequent wall-clock punctuation will give a more precise trigger time at the cost of firing an increased number of flag checks (i.e. punctuations). This is a trade-off that can be removed with the anchored punctuationpunctuations. 

Proposed Changes

The goal is to introduce an anchored wall-clock punctuation that will have similarities with that of triggering a cron job.

Questions

...

The proposed API change is to extend the `schedule()` method in the `ProcessingContext` interface with a parameter to represent the start time for the schedule, without enforcing any changes upon the existing users:

package org.apache.kafka.streams.processor.api;

public interface ProcessingContext {

	/* code */

	Cancellable schedule(final Duration interval, final long startTime, final PunctuationType type, final Punctuator callback);

	// Existing method
 	Cancellable schedule(final Duration interval, final long startTime, final PunctuationType type, final Punctuator callback) {
		schedule(interval, null, type, callback);
	}
}

The `startTime`, together with the `interval` and the wall clock, will determine the next trigger time for the callback. Hence, the anchored punctuation is only supporting wall clock (i.e. stream time) in this first iteration.

...

Compatibility, Deprecation, and Migration Plan

• What impact (if any) will there be on existing users?
• If we are changing behavior how will we phase out the older behavior?
• If we need special migration tools, describe them here.
• When will we remove the existing behavior?

Test Plan

The goal is to not enforce any changes upon the existing users of the schedule method, but instead expand the current schedule options with a new anchored schedule option. This can be achieved by using method overloading.

Test Plan

The plan is to test the new schedule option in the same way that the current schedule options are tested. The anchored wall-clock punctuation is a new feature, and the feature should therefore not affect any current features or users. Describe in few sentences how the KIP will be tested. We are mostly interested in system tests (since unit-tests are specific to implementation details). How will we know that the implementation works as expected? How will we know nothing broke?

Rejected Alternatives

If there are alternative ways of accomplishing the same thing, what were they? The purpose of this section is to motivate why the design is the way it is and not some other way.