Incorporate batch processing into OptimizelyFactory. (#322)

* Make batch processor default implementation within the OptimizelyFactory.
* Lower the treshhold for default batch processing.
* Close event dispatcher when closing event processor.
* Change default interval to 30 seconds.

Author: Mike Davis

core-api/src/main/java/com/optimizely/ab/Optimizely.java

@@ -41,6 +41,8 @@
 import java.util.List;
 import java.util.Map;
 
+import static com.optimizely.ab.internal.SafetyUtils.tryClose;
+
 /**
  * Top-level container class for Optimizely functionality.
  * Thread-safe, so can be created as a singleton and safely passed around.
@@ -116,20 +118,7 @@ public boolean isValid() {
         return getProjectConfig() != null;
     }
 
-    /**
-     * Helper method which checks if Object is an instance of AutoCloseable and calls close() on it.
-     */
-    private void tryClose(Object obj) {
-        if (!(obj instanceof AutoCloseable)) {
-            return;
-        }
 
-        try {
-            ((AutoCloseable) obj).close();
-        } catch (Exception e) {
-            logger.warn("Unexpected exception on trying to close {}.", obj);
-        }
-    }
 
     /**
      * Checks if eventHandler {@link EventHandler} and projectConfigManager {@link ProjectConfigManager}

core-api/src/main/java/com/optimizely/ab/event/BatchEventProcessor.java

@@ -27,6 +27,8 @@
 import java.util.LinkedList;
 import java.util.concurrent.*;
 
+import static com.optimizely.ab.internal.SafetyUtils.tryClose;
+
 /**
  * BatchEventProcessor is a batched implementation of the {@link EventProcessor}
  *
@@ -44,9 +46,9 @@ public class BatchEventProcessor implements EventProcessor, AutoCloseable {
     public static final String CONFIG_BATCH_INTERVAL = "event.processor.batch.interval";
     public static final String CONFIG_CLOSE_TIMEOUT  = "event.processor.close.timeout";
 
-    public static final int DEFAULT_QUEUE_CAPACITY  = 1000;
-    public static final int DEFAULT_BATCH_SIZE      = 50;
-    public static final long DEFAULT_BATCH_INTERVAL = TimeUnit.MINUTES.toMillis(1);
+    public static final int DEFAULT_QUEUE_CAPACITY    = 1000;
+    public static final int DEFAULT_BATCH_SIZE        = 10;
+    public static final long DEFAULT_BATCH_INTERVAL   = TimeUnit.SECONDS.toMillis(30);
     public static final long DEFAULT_TIMEOUT_INTERVAL = TimeUnit.SECONDS.toMillis(5);
 
     private static final Object SHUTDOWN_SIGNAL = new Object();
@@ -108,6 +110,7 @@ public void close() throws Exception {
             logger.error("Timeout exceeded attempting to close for {} ms", timeoutMillis);
         } finally {
             isStarted = false;
+            tryClose(eventHandler);
         }
     }
 

core-api/src/main/java/com/optimizely/ab/internal/SafetyUtils.java

@@ -0,0 +1,43 @@
+/**
+ *
+ *    Copyright 2019, Optimizely
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package com.optimizely.ab.internal;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Collection of utils used to prevent the Optimizely SDK from throwing or crashing the hosting application.
+ */
+public class SafetyUtils {
+
+    private static final Logger logger = LoggerFactory.getLogger(SafetyUtils.class);
+
+    /**
+     * Helper method which checks if Object is an instance of AutoCloseable and calls close() on it.
+     */
+    public static void tryClose(Object obj) {
+        if (!(obj instanceof AutoCloseable)) {
+            return;
+        }
+
+        try {
+            ((AutoCloseable) obj).close();
+        } catch (Exception e) {
+            logger.warn("Unexpected exception on trying to close {}.", obj);
+        }
+    }
+}

core-api/src/test/java/com/optimizely/ab/OptimizelyTest.java

@@ -168,87 +168,33 @@ public void setUp() throws Exception {
 
     @Test
     public void testClose() throws Exception {
-        // Check for AutoCloseable
-        EventHandler mockAutoCloseableEventHandler = mock(
+        EventHandler mockEventHandler = mock(
             EventHandler.class,
             withSettings().extraInterfaces(AutoCloseable.class)
         );
-        ProjectConfigManager mockAutoCloseableProjectConfigManager = mock(
-            ProjectConfigManager.class,
-            withSettings().extraInterfaces(AutoCloseable.class)
-        );
-
-        Optimizely optimizely = Optimizely.builder()
-            .withEventHandler(mockAutoCloseableEventHandler)
-            .withConfigManager(mockAutoCloseableProjectConfigManager)
-            .build();
-
-        optimizely.close();
 
-        verify((AutoCloseable) mockAutoCloseableEventHandler).close();
-        verify((AutoCloseable) mockAutoCloseableProjectConfigManager).close();
-
-        // Check for Closeable
-        EventHandler mockCloseableEventHandler = mock(
-            EventHandler.class,
-            withSettings().extraInterfaces(Closeable.class)
-        );
-        ProjectConfigManager mockCloseableProjectConfigManager = mock(
+        ProjectConfigManager mockProjectConfigManager = mock(
             ProjectConfigManager.class,
-            withSettings().extraInterfaces(Closeable.class)
-        );
-
-        optimizely = Optimizely.builder()
-            .withEventHandler(mockCloseableEventHandler)
-            .withConfigManager(mockCloseableProjectConfigManager)
-            .build();
-
-        optimizely.close();
-
-        verify((Closeable) mockCloseableEventHandler).close();
-        verify((Closeable) mockCloseableProjectConfigManager).close();
-    }
-
-    @Test
-    public void testCloseConfigManagerThrowsException() throws Exception {
-        EventHandler mockAutoCloseableEventHandler = mock(
-            EventHandler.class,
             withSettings().extraInterfaces(AutoCloseable.class)
         );
-        ProjectConfigManager mockAutoCloseableProjectConfigManager = mock(
-            ProjectConfigManager.class,
+
+        EventProcessor mockEventProcessor = mock(
+            EventProcessor.class,
             withSettings().extraInterfaces(AutoCloseable.class)
         );
 
-        Optimizely optimizely = optimizelyBuilder
-            .withEventHandler(mockAutoCloseableEventHandler)
-            .withConfigManager(mockAutoCloseableProjectConfigManager)
+        Optimizely optimizely = Optimizely.builder()
+            .withEventHandler(mockEventHandler)
+            .withEventProcessor(mockEventProcessor)
+            .withConfigManager(mockProjectConfigManager)
             .build();
 
-        doThrow(new IOException()).when((AutoCloseable) mockAutoCloseableProjectConfigManager).close();
-        logbackVerifier.expectMessage(Level.WARN, "Unexpected exception on trying to close " + mockAutoCloseableProjectConfigManager + ".");
         optimizely.close();
-    }
-
-    @Test
-    public void testCloseEventHandlerThrowsException() throws Exception {
-        EventHandler mockAutoCloseableEventHandler = mock(
-            EventHandler.class,
-            withSettings().extraInterfaces(AutoCloseable.class)
-        );
-        ProjectConfigManager mockAutoCloseableProjectConfigManager = mock(
-            ProjectConfigManager.class,
-            withSettings().extraInterfaces(AutoCloseable.class)
-        );
 
-        Optimizely optimizely = optimizelyBuilder
-            .withEventHandler(mockAutoCloseableEventHandler)
-            .withConfigManager(mockAutoCloseableProjectConfigManager)
-            .build();
+        verify((AutoCloseable) mockEventHandler).close();
+        verify((AutoCloseable) mockProjectConfigManager).close();
+        verify((AutoCloseable) mockEventProcessor).close();
 
-        doThrow(new IOException()).when((AutoCloseable) mockAutoCloseableEventHandler).close();
-        logbackVerifier.expectMessage(Level.WARN, "Unexpected exception on trying to close " + mockAutoCloseableEventHandler + ".");
-        optimizely.close();
     }
 
     //======== activate tests ========//

core-api/src/test/java/com/optimizely/ab/event/BatchEventProcessorTest.java

@@ -32,8 +32,7 @@
 import java.util.concurrent.*;
 
 import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 @RunWith(MockitoJUnitRunner.class)
 public class BatchEventProcessorTest {
@@ -255,6 +254,18 @@ public void testCloseTimeout() throws Exception {
         countDownLatch.countDown();
     }
 
+    @Test
+    public void testCloseEventHandler() throws Exception {
+        EventHandler mockEventHandler = mock(
+            EventHandler.class,
+            withSettings().extraInterfaces(AutoCloseable.class)
+        );
+
+        setEventProcessor(mockEventHandler);
+        eventProcessor.close();
+        verify((AutoCloseable) mockEventHandler).close();
+    }
+
     private void setEventProcessor(EventHandler eventHandler) {
         eventProcessor = BatchEventProcessor.builder()
             .withEventQueue(eventQueue)

core-api/src/test/java/com/optimizely/ab/internal/SafetyUtilsTest.java

@@ -0,0 +1,58 @@
+/**
+ *
+ *    Copyright 2019, Optimizely
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package com.optimizely.ab.internal;
+
+import org.junit.Test;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class SafetyUtilsTest {
+
+    @Test
+    public void tryCloseAutoCloseable() throws Exception {
+        AutoCloseable autocloseable = mock(AutoCloseable.class);
+        SafetyUtils.tryClose(autocloseable);
+
+        verify(autocloseable).close();
+    }
+
+    @Test
+    public void tryCloseCloseable() throws Exception {
+        Closeable closeable = mock(Closeable.class);
+        SafetyUtils.tryClose(closeable);
+
+        verify(closeable).close();
+    }
+
+    @Test
+    public void tryCloseNullDoesNotThrow() throws Exception {
+        SafetyUtils.tryClose(null);
+    }
+
+    @Test
+    public void tryCloseExceptionDoesNotThrow() throws Exception {
+        AutoCloseable autocloseable = mock(AutoCloseable.class);
+        doThrow(new RuntimeException()).when(autocloseable).close();
+        SafetyUtils.tryClose(autocloseable);
+    }
+}

core-httpclient-impl/src/main/java/com/optimizely/ab/OptimizelyFactory.java

@@ -19,6 +19,7 @@
 import com.optimizely.ab.config.HttpProjectConfigManager;
 import com.optimizely.ab.config.ProjectConfigManager;
 import com.optimizely.ab.event.AsyncEventHandler;
+import com.optimizely.ab.event.BatchEventProcessor;
 import com.optimizely.ab.event.EventHandler;
 import com.optimizely.ab.internal.PropertyUtils;
 import com.optimizely.ab.notification.NotificationCenter;
@@ -35,6 +36,8 @@
  *
  * OptimizelyClients also provides setter methods to override the system properties at runtime.
  * <ul>
+ *  <li>{@link OptimizelyFactory#setMaxEventBatchSize}</li>
+ *  <li>{@link OptimizelyFactory#setMaxEventBatchInterval}</li>
  *  <li>{@link OptimizelyFactory#setEventQueueParams}</li>
  *  <li>{@link OptimizelyFactory#setBlockingTimeout}</li>
  *  <li>{@link OptimizelyFactory#setPollingInterval}</li>
@@ -46,7 +49,33 @@ public final class OptimizelyFactory {
     private static final Logger logger = LoggerFactory.getLogger(OptimizelyFactory.class);
 
     /**
-     * Convenience method for setting the required queueing parameters.
+     * Convenience method for setting the maximum number of events contained within a batch.
+     * {@link AsyncEventHandler}
+     */
+    public static void setMaxEventBatchSize(int batchSize) {
+        if (batchSize <= 0) {
+            logger.warn("Batch size cannot be <= 0. Reverting to default configuration.");
+            return;
+        }
+
+        PropertyUtils.set(BatchEventProcessor.CONFIG_BATCH_SIZE, Integer.toString(batchSize));
+    }
+
+    /**
+     * Convenience method for setting the maximum time interval in milliseconds between event dispatches.
+     * {@link AsyncEventHandler}
+     */
+    public static void setMaxEventBatchInterval(long batchInterval) {
+        if (batchInterval <= 0) {
+            logger.warn("Batch interval cannot be <= 0. Reverting to default configuration.");
+            return;
+        }
+
+        PropertyUtils.set(BatchEventProcessor.CONFIG_BATCH_INTERVAL, Long.toString(batchInterval));
+    }
+
+    /**
+     * Convenience method for setting the required queueing parameters for event dispatching.
      * {@link AsyncEventHandler}
      */
     public static void setEventQueueParams(int queueCapacity, int numberWorkers) {
@@ -194,8 +223,13 @@ public static Optimizely newDefaultInstance(ProjectConfigManager configManager,
             notificationCenter = new NotificationCenter();
         }
 
-        return Optimizely.builder()
+        BatchEventProcessor eventProcessor = BatchEventProcessor.builder()
             .withEventHandler(eventHandler)
+            .withNotificationCenter(notificationCenter)
+            .build();
+
+        return Optimizely.builder()
+            .withEventProcessor(eventProcessor)
             .withConfigManager(configManager)
             .withNotificationCenter(notificationCenter)
             .build();