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

.gitignore

@@ -1,5 +1,5 @@
 .gradle
-/local.properties
+local.properties
 .DS_Store
 build
 /captures

example/build.gradle

@@ -2,8 +2,6 @@ import java.util.Properties
 
 plugins {
     id("com.android.application")
-    // make sure this line comes *after* you apply the Android plugin
-    id("com.getkeepsafe.dexcount")
 }
 
 // local.properties is not checked in, so it is where machine-specific settings such as your mobile

example/src/main/java/com/launchdarkly/example/MainActivity.java

@@ -26,10 +26,6 @@
 
 import java.util.Date;
 import java.util.Locale;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import timber.log.Timber;
@@ -45,6 +41,9 @@ public class MainActivity extends AppCompatActivity {
 
     private static final String DEFAULT_USER_KEY = "user key";
 
+    /** How long startup blocks waiting for the first flags to arrive. */
+    private static final int INIT_WAIT_SECONDS = 10;
+
     private LDClient ldClient;
     private LDStatusListener ldStatusListener;
     private LDAllFlagsListener allFlagsListener;
@@ -142,15 +141,12 @@ public void onCreate(Bundle savedInstanceState) {
                 .set("email", "fake@example.com")
                 .build();
 
-        Future<LDClient> initFuture = LDClient.init(this.getApplication(), ldConfig, context);
-        try {
-            ldClient = initFuture.get(10, TimeUnit.SECONDS);
-            updateStatusString(ldClient.getConnectionInformation());
-            ldClient.registerStatusListener(ldStatusListener);
-            ldClient.registerAllFlagsListener(allFlagsListener);
-        } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            Timber.e(e, "Exception when awaiting LaunchDarkly Client initialization");
-        }
+        // Returns the client either way: if the flags have not arrived within the wait, it is usable
+        // with whatever it has cached.
+        ldClient = LDClient.init(this.getApplication(), ldConfig, context, INIT_WAIT_SECONDS);
+        updateStatusString(ldClient.getConnectionInformation());
+        ldClient.registerStatusListener(ldStatusListener);
+        ldClient.registerAllFlagsListener(allFlagsListener);
     }
 
     private void setupListeners() {

launchdarkly-android-client-sdk/build.gradle

@@ -79,7 +79,7 @@ ext.versions = [
     "jacksonDatabind": "2.10.5.1",
     "junit": "4.13",
     "launchdarklyJavaSdkCommon": "2.4.0",
-    "launchdarklyJavaSdkInternal": "1.9.0",
+    "launchdarklyJavaSdkInternal": "1.12.0",
     "launchdarklyLogging": "1.1.1",
     "okhttp": "4.12.0",
     "testHelpers": "2.1.0",

launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java

@@ -20,12 +20,9 @@
 import com.launchdarkly.sdk.android.subsystems.HookConfiguration;
 import com.launchdarkly.sdk.android.subsystems.HttpConfiguration;
 import com.launchdarkly.sdk.android.subsystems.PluginsConfiguration;
-import com.launchdarkly.sdk.internal.events.DefaultEventProcessor;
 import com.launchdarkly.sdk.internal.events.DefaultEventSender;
-import com.launchdarkly.sdk.internal.events.Event;
-import com.launchdarkly.sdk.internal.events.EventsConfiguration;
+import com.launchdarkly.sdk.internal.events.EventSender;
 
-import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -101,33 +98,33 @@ static final class EventProcessorBuilderImpl extends EventProcessorBuilder
         @Override
         public EventProcessor build(ClientContext clientContext) {
             ClientContextImpl clientContextImpl = ClientContextImpl.get(clientContext);
-            EventsConfiguration eventsConfig = new EventsConfiguration(
-                    allAttributesPrivate,
-                    capacity,
-                    null, // contextDeduplicator - not needed for client-side use
-                    diagnosticRecordingIntervalMillis,
-                    clientContextImpl.getDiagnosticStore(),
-                    new DefaultEventSender(
-                            LDUtil.makeHttpProperties(clientContext),
-                            StandardEndpoints.ANALYTICS_EVENTS_REQUEST_PATH,
-                            StandardEndpoints.DIAGNOSTIC_EVENTS_REQUEST_PATH,
-                            0L, // use default retry delay
-                            false, // disable gzip compression for Android
+            EventSender eventSender = new DefaultEventSender(
+                    LDUtil.makeHttpProperties(clientContext),
+                    StandardEndpoints.ANALYTICS_EVENTS_REQUEST_PATH,
+                    StandardEndpoints.DIAGNOSTIC_EVENTS_REQUEST_PATH,
+                    0L, // use default retry delay
+                    false, // disable gzip compression for Android
+                    clientContext.getBaseLogger());
+            return new DirectEventProcessor(
+                    new OutboundEventBuffer(
+                            allAttributesPrivate,
+                            privateAttributes,
+                            true, // perContextSummarization - enable for client SDK
+                            capacity,
                             clientContext.getBaseLogger()),
-                    1, // eventSendingThreadPoolSize
+                    eventSender,
                     clientContext.getServiceEndpoints().getEventsBaseUri(),
+                    clientContextImpl.getDiagnosticStore(),
+                    capacity,
                     flushIntervalMillis,
+                    diagnosticRecordingIntervalMillis,
+                    DirectEventProcessor.DEFAULT_CLOSE_BUDGET_MILLIS,
                     clientContext.isInBackground(),
                     true, // initiallyOffline
-                    privateAttributes,
-                    true // perContextSummarization - enable for client SDK
-            );
-            return new DefaultEventProcessorWrapper(new DefaultEventProcessor(
-                    eventsConfig,
                     EventUtil.makeEventsTaskExecutor(),
-                    Thread.NORM_PRIORITY, // note, we may want to make this configurable as it is in java-server-sdk
+                    EventUtil.makeDiagnosticsTaskExecutor(),
                     clientContext.getBaseLogger()
-            ));
+            );
         }
 
         @Override
@@ -140,72 +137,6 @@ public LDValue describeConfiguration(ClientContext clientContext) {
                     .put("eventsFlushIntervalMillis", flushIntervalMillis)
                     .build();
         }
-
-        /**
-         * Adapter from the public component interface of EventProcessor to the internal
-         * implementation class from java-sdk-internal.
-         */
-        private final class DefaultEventProcessorWrapper implements EventProcessor {
-            private final DefaultEventProcessor eventProcessor;
-
-            DefaultEventProcessorWrapper(DefaultEventProcessor eventProcessor) {
-                this.eventProcessor = eventProcessor;
-            }
-
-            @Override
-            public void recordEvaluationEvent(
-                    LDContext context,
-                    String flagKey,
-                    int flagVersion,
-                    int variation,
-                    LDValue value,
-                    EvaluationReason reason,
-                    LDValue defaultValue,
-                    boolean requireFullEvent,
-                    Long debugEventsUntilDate
-            ) {
-                eventProcessor.sendEvent(new Event.FeatureRequest(
-                        System.currentTimeMillis(), flagKey, context, flagVersion, variation,
-                        value, defaultValue, reason, null, requireFullEvent,
-                        debugEventsUntilDate, false));
-            }
-
-            @Override
-            public void recordIdentifyEvent(LDContext context) {
-                eventProcessor.sendEvent(new Event.Identify(System.currentTimeMillis(), context));
-            }
-
-            @Override
-            public void recordCustomEvent(LDContext context, String eventKey, LDValue data, Double metricValue) {
-                eventProcessor.sendEvent(new Event.Custom(System.currentTimeMillis(), eventKey,
-                        context, data, metricValue));
-            }
-
-            @Override
-            public void setInBackground(boolean inBackground) {
-                eventProcessor.setInBackground(inBackground);
-            }
-
-            @Override
-            public void setOffline(boolean offline) {
-                eventProcessor.setOffline(offline);
-            }
-
-            @Override
-            public void flush() {
-                eventProcessor.flushAsync();
-            }
-
-            @Override
-            public void blockingFlush() {
-                eventProcessor.flushBlocking();
-            }
-
-            @Override
-            public void close() throws IOException {
-                eventProcessor.close();
-            }
-        }
     }
 
     static final class HttpConfigurationBuilderImpl extends HttpConfigurationBuilder