feat(events): summarize and buffer events on the recording thread (tier 1)

[abelonogov-ld]

Requirements

• I have added test coverage for new or changed functionality
• I have followed the repository's pull request submission guidelines
• I have validated my changes against all supported platform versions

Related issues

Tier 1 of the Event Durability spec, "Tier 1 — the buffer". Tiers 2 and 3 are stacked on this branch and will follow as separate pull requests.

Describe the solution you've provided

DirectEventProcessor takes over from java-sdk-internal's DefaultEventProcessor in ComponentsImpl, and OutboundEventBuffer replaces the bounded queue that used to sit between the calling thread and the summarizer.

That queue is the problem this tier removes. An evaluation handed its event to an ArrayBlockingQueue and a dispatcher thread summarized it on the far side, so a burst of evaluations of untracked flags could fill the queue and displace the track and identify events an application actually asked to send. Summarizing on the recording thread means an evaluation of an untracked flag costs a counter increment and can never displace anything, because it never occupies a slot in the first place.

OutboundEventBuffer holds in full only the events that have to be sent one by one. It reuses java-sdk-internal's EventOutputFormatter and summarizer implementations rather than reimplementing them, so there stays exactly one definition of what an event looks like on the wire.

Two smaller changes ride along, both prerequisites rather than additions:

• java-sdk-internal moves to 1.12.0, which makes the summarizer and formatter types public so the buffer can use them from its own package.
• Diagnostic events are no longer sent while the SDK is offline or the application is backgrounded.

Describe alternatives you've considered

Reuse DefaultEventProcessor and raise its queue capacity. This moves the threshold without removing it. The displacement is a property of having a bounded handoff between the caller and the summarizer at all, and a render loop re-evaluating a tracked flag will reach any capacity you pick.

Keep the buffer inside java-sdk-internal's package to reach its package-private types. This worked, but it relied on a split package, which breaks Java modules and needed a Javadoc exclusion to build at all. Making the types public upstream was the durable fix, and is why the dependency bump is here.

Additional context

Naming. DirectEventProcessor and OutboundEventBuffer rather than an Android prefix: that prefix in this package is reserved for adapters over Android OS APIs, such as AndroidPlatformState and AndroidTaskExecutor, and neither of these classes touches one. "Direct" names the contrast with DefaultEventProcessor — nothing sits between the caller and the summarizer. DefaultEventProcessor was unavailable as a name because java-sdk-internal already exports it and this package imports from it.

Tests. DirectEventProcessorTest, EventProcessorBufferingTest and EventProcessorPrivacyTest share an EventProcessorTestBase, adding 22 tests across buffering, capacity, private-attribute redaction and diagnostics. The full unit suite is 752 tests, all passing locally.

Platform validation. The requirements box above is left unchecked deliberately. Behaviour is covered by the unit suite, but performance was measured on one physical device rather than across the supported API range.

Example app. Gains an "Eval+track+kill" button that evaluates a flag, tracks an event, flushes, and then kills the process five seconds later. That is the reproduction for the loss this work addresses, and it still loses the events on this tier — tier 3 is what makes them survive. Its LDClient.init call also moves off the deprecated three-argument overload.

---

Note

Overview
Replaces the Android SDK’s DefaultEventProcessor wrapper with DirectEventProcessor and OutboundEventBuffer, so flag evaluations are summarized on the recording thread and only full-fidelity events (track, identify, tracked flags, debug) use the capacity-limited buffer. That removes the old bounded inbox queue where evaluation bursts could silently drop unrelated custom events.

ComponentsImpl now builds DirectEventProcessor + OutboundEventBuffer, reusing java-sdk-internal’s wire format via launchdarkly-java-sdk-internal 1.12.0 (summarizer/formatter types made public). Diagnostics are not sent while offline or backgrounded; coming back online triggers an immediate delivery flush.

The example app switches to LDClient.init(..., INIT_WAIT_SECONDS) and adds an Eval+track+kill button to reproduce in-memory event loss before later durability tiers. New unit tests cover buffering under burst load, close/offline behavior, privacy redaction, and diagnostics.

^{Reviewed by Cursor Bugbot for commit 6d77bde. Bugbot is set up for automated code reviews on this repo. Configure here.}

[cursor]

Cursor Bugbot has reviewed your changes using default effort and found 2 potential issues.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 9569078. Configure here.}