feat: OpenFeature track and event delivery reliability

[fabriziodemaria]

Summary

• Align OpenFeature track() with Confidence event conventions (details → data, context merge, "value" / "context" overrides).
• Improve event delivery reliability: optional interval flush, startup flush, stop/shutdown flush, provider shutdown() → flush().

Test plan

• Provider track tests
• EventSenderEngineReliabilityTest
• Full CI on combined branch

Supersedes #253 (reliability) — both changes are on openfeature-track-context.

[vahidlazio]

sendChannel is still a rendezvous channel (capacity 0). When minBatchSizeFlushPolicy triggers a flush and an upload is already in flight, the writer blocks on sendChannel.send(SEND_SIG) and stops draining writeReqChannel. If stop() is called during that window, the 2s timeout fires before the writer can consume the remaining buffered events, and coroutineScope.cancel() drops them.

Consider making sendChannel buffered (e.g. Channel(Channel.UNLIMITED)) or switching to trySend — the sender already processes all ready files per invocation, so duplicate signals are harmless.

The stopDrainsQueuedEventsBeforeUploading test doesn't catch this because the engine is created without minBatchSizeFlushPolicy, so the writer never hits sendChannel.send().

[vahidlazio]

Here's a failing test that reproduces the issue under production conditions (batch flush policy + slow upload). It currently fails with expected:<12> but was:<10> — the writer blocks on the rendezvous sendChannel.send() while an upload is in flight, so 2 events never reach disk before the 2s stop timeout.

The fix should make this pass (e.g. buffering sendChannel or switching to trySend):

@Test
fun stopDrainsAllEventsWhenFlushPolicyBlocksWriter() {
    val slowUploader = SlowEventUploader(uploadDelayMillis = 3_000)
    val batchFlush = object : FlushPolicy {
        private var count = 0
        override fun reset() { count = 0 }
        override fun hit(event: EngineEvent) { count++ }
        override fun shouldFlush(): Boolean = count > 4
    }

    val engine = EventSenderEngineImpl(
        eventStorage = storage,
        clientSecret = "secret",
        uploader = slowUploader,
        flushPolicies = mutableListOf(batchFlush),
        dispatcher = Dispatchers.IO,
        sdkMetadata = SdkMetadata("id", "1.0"),
        debugLogger = null
    )

    repeat(12) { engine.emit("event-$it", mapOf(), mapOf()) }
    Thread.sleep(100)
    engine.stop()

    assertEquals(
        "All 12 events should be written to storage before stop() returns",
        12,
        storage.storedEventCount()
    )
}

private class SlowEventUploader(
    private val uploadDelayMillis: Long
) : EventSenderUploader {
    val uploadedEventNames = mutableListOf<String>()

    override suspend fun upload(events: EventBatchRequest): Boolean {
        kotlinx.coroutines.delay(uploadDelayMillis)
        synchronized(uploadedEventNames) {
            uploadedEventNames.addAll(
                events.events.map { it.eventDefinition.removePrefix("eventDefinitions/") }
            )
        }
        return true
    }
}

RecordingEventStorage also needs a helper:

fun storedEventCount(): Int = synchronized(this) {
    currentEvents.size + readyEvents.values.sumOf { it.size }
}

[fabriziodemaria]

Addressed the sendChannel blocking issue in b6048ed:

• sendChannel is now Channel(CONFLATED) with trySend(SEND_SIG) so the writer loop never suspends on flush signaling while upload holds uploadMutex
• Added stopDrainsAllEventsWhenFlushPolicyBlocksWriter (your repro with batch flush policy + slow uploader) — asserts all 12 events reach storage before stop() returns

The earlier writeReqChannel UNLIMITED change only helps when the writer keeps consuming; blocking on rendezvous sendChannel.send() was the remaining gap.

[fabriziodemaria]

Bugbot follow-up review: three reliability issues to address before merge.