feat(events): make event serialization usable from another package (#214)

## What

Widens five declarations in `com.launchdarkly.sdk.internal.events` from
package-private to public. **Visibility only — no behavior change.**

| Declaration | What becomes public |
| --- | --- |
| `EventOutputFormatter` | class, constructor, `writeOutputEvents` |
| `EventSummarizerInterface` | interface |
| `AggregatedEventSummarizer` | class, constructor |
| `PerContextEventSummarizer` | class, constructor |
| `EventSummarizer` | class only — so that `EventSummary` can be named |
| `EventSummarizer.EventSummary` | class only |

Everything else stays package-private. `EventSummarizer` and
`EventSummary` gain no callable surface: `EventSummarizer`'s
constructors and methods are untouched, and `EventSummary` cannot be
constructed from outside the package. They are public so the type
`List<EventSummarizer.EventSummary>` can be *named* by a caller passing
it from a summarizer to the formatter.

## Why

The Android SDK's event durability work summarizes and serializes each
event on the thread that recorded it, ahead of the bounded queue that
`DefaultEventProcessor` keeps between the caller and the summarizer.
That means it needs the summarizers and the output formatter directly:
`DefaultEventProcessor` only accepts individual events and summarizes
them itself, so there is no public way to hand java-sdk-internal a
summary that has already been aggregated.

Today the Android SDK gets at them by declaring `AndroidEventBuffer` in
this package — a split package across two artifacts, with a javadoc
workaround to keep it out of the published docs. That works, but it is
not something to keep: it is fragile under any build that takes package
ownership seriously, and it puts a class the Android team maintains
inside a package this repo owns.

With these declarations public, that class moves into
`com.launchdarkly.sdk.android` where it belongs, and the split package
and its build workaround go away. The important part is that the Android
SDK keeps using *this* implementation of the wire format rather than
growing a second copy that could drift from it.

## Notes for review

- The diff is modifiers only, apart from one added line of javadoc on
`EventSummary`, which `JavadocType` requires because it is a newly
public type. No existing comment was edited.
- `javadoc` reports three new `no comment` warnings, on the two
constructors and `writeOutputEvents`. That is the same warning roughly
eighty existing members in this module already produce, and it does not
fail the build.
- `Event`, `EventsConfiguration` and `Sampler` were already public and
needed no change.
- `compileJava`, `checkstyleMain`, `javadoc` and the
`com.launchdarkly.sdk.internal.events.*` tests all pass.

🤖 Generated with [Cursor](https://cursor.com)

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: abelonogov-ld

lib/shared/internal/src/main/java/com/launchdarkly/sdk/internal/events/AggregatedEventSummarizer.java

@@ -16,10 +16,10 @@
  * Note that the methods of this class are deliberately not thread-safe, because they should
  * always be called from EventProcessor's single message-processing thread.
  */
-final class AggregatedEventSummarizer implements EventSummarizerInterface {
+public final class AggregatedEventSummarizer implements EventSummarizerInterface {
   private final EventSummarizer summarizer;
 
-  AggregatedEventSummarizer() {
+  public AggregatedEventSummarizer() {
     this.summarizer = new EventSummarizer();
   }
 

lib/shared/internal/src/main/java/com/launchdarkly/sdk/internal/events/EventOutputFormatter.java

@@ -25,18 +25,28 @@
  * handling of context data and private attribute redaction is implemented in EventContextFormatter
  * and tested in more detail in EventContextFormatterTest.
  */
-final class EventOutputFormatter {
+public final class EventOutputFormatter {
   private final EventContextFormatter contextFormatter;
   private final boolean redactAnonymousAllEvents;
 
-  EventOutputFormatter(EventsConfiguration config) {
+  public EventOutputFormatter(EventsConfiguration config) {
     this.contextFormatter = new EventContextFormatter(
         config.allAttributesPrivate,
         config.privateAttributes.toArray(new AttributeRef[config.privateAttributes.size()]));
     this.redactAnonymousAllEvents = config.redactAnonymousAllEvents;
   }
 
-  int writeOutputEvents(Event[] events, List<EventSummarizer.EventSummary> summaries, Writer writer) throws IOException {
+  /**
+   * Writes events and summaries as the JSON array that makes up a request body.
+   *
+   * @param events the individual events to write
+   * @param summaries the summaries to write; empty ones are skipped
+   * @param writer where to write the JSON
+   * @return how many output events were written, counting each summary as one
+   * @throws IOException if the writer failed
+   */
+  public int writeOutputEvents(Event[] events, List<EventSummarizer.EventSummary> summaries, Writer writer)
+      throws IOException {
     int count = 0;
     JsonWriter jsonWriter = new JsonWriter(writer);
     jsonWriter.beginArray();

lib/shared/internal/src/main/java/com/launchdarkly/sdk/internal/events/EventSummarizer.java

@@ -14,7 +14,7 @@
  * methods of this class are deliberately not thread-safe, because they should always
  * be called from EventProcessor's single message-processing thread.
  */
-final class EventSummarizer {
+public final class EventSummarizer {
   private EventSummary eventsState;
   private final LDContext context; // nullable - only set for per-context summarization
 
@@ -85,7 +85,10 @@ void clear() {
     eventsState = new EventSummary(context);
   }
 
-  static final class EventSummary {
+  /**
+   * A snapshot of the evaluations counted since the last reset.
+   */
+  public static final class EventSummary {
     final Map<String, FlagInfo> counters;
     long startDate;
     long endDate;

lib/shared/internal/src/main/java/com/launchdarkly/sdk/internal/events/EventSummarizerInterface.java

@@ -13,7 +13,7 @@
  * Note that implementations are deliberately not thread-safe, as they should always
  * be called from EventProcessor's single message-processing thread.
  */
-interface EventSummarizerInterface {
+public interface EventSummarizerInterface {
   /**
    * Adds information about an evaluation to the summary.
    *

lib/shared/internal/src/main/java/com/launchdarkly/sdk/internal/events/PerContextEventSummarizer.java

@@ -19,10 +19,10 @@
  * Note that the methods of this class are deliberately not thread-safe, because they should
  * always be called from EventProcessor's single message-processing thread.
  */
-final class PerContextEventSummarizer implements EventSummarizerInterface {
+public final class PerContextEventSummarizer implements EventSummarizerInterface {
   private final Map<LDContext, EventSummarizer> summarizersByContext;
 
-  PerContextEventSummarizer() {
+  public PerContextEventSummarizer() {
     this.summarizersByContext = new HashMap<>();
   }