Added async methods

Author: pc9795

src/main/java/com/exceptionless/exceptionlessclient/ExceptionlessClient.java

@@ -19,32 +19,39 @@
 import java.time.LocalDate;
 import java.util.Timer;
 import java.util.TimerTask;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 public class ExceptionlessClient {
   private static final Logger LOG = LoggerFactory.getLogger(ExceptionlessClient.class);
   private static final String UPDATE_SETTINGS_TIMER_NAME = "update-settings-timer";
   private static final int UPDATE_SETTINGS_TIMER_INITIAL_DELAY = 5000;
+  private static final Integer DEFAULT_NTHREADS = 10;
 
   @Getter private final ConfigurationManager configurationManager;
   private final EventPluginRunner eventPluginRunner;
   private final Timer updateSettingsTimer;
+  private final ExecutorService executorService;
 
   @Builder
-  public ExceptionlessClient(ConfigurationManager configurationManager) {
-    this.configurationManager = configurationManager;
-    this.eventPluginRunner =
-        EventPluginRunner.builder().configurationManager(this.configurationManager).build();
-    this.updateSettingsTimer = new Timer(UPDATE_SETTINGS_TIMER_NAME);
-    init(UPDATE_SETTINGS_TIMER_INITIAL_DELAY);
+  public ExceptionlessClient(ConfigurationManager configurationManager, Integer nThreads) {
+    this(
+        configurationManager,
+        UPDATE_SETTINGS_TIMER_INITIAL_DELAY,
+        nThreads == null ? DEFAULT_NTHREADS : nThreads);
   }
 
   @VisibleForTesting
   ExceptionlessClient(
-      ConfigurationManager configurationManager, long updateSettingsTimerInitialDelay) {
+      ConfigurationManager configurationManager,
+      long updateSettingsTimerInitialDelay,
+      Integer nThreads) {
     this.configurationManager = configurationManager;
     this.eventPluginRunner =
         EventPluginRunner.builder().configurationManager(this.configurationManager).build();
     this.updateSettingsTimer = new Timer(UPDATE_SETTINGS_TIMER_NAME);
+    this.executorService = Executors.newFixedThreadPool(nThreads);
     init(updateSettingsTimerInitialDelay);
   }
 
@@ -80,6 +87,10 @@ public static ExceptionlessClient from(String apiKey, String serverUrl) {
         .build();
   }
 
+  public CompletableFuture<Void> submitExceptionAsync(Exception exception) {
+    return CompletableFuture.runAsync(() -> submitException(exception), executorService);
+  }
+
   public void submitException(Exception exception) {
     Event event = createException().build();
     PluginContext pluginContext = PluginContext.builder().exception(exception).build();
@@ -90,6 +101,12 @@ public Event.EventBuilder createException() {
     return createEvent().type(EventType.ERROR.value());
   }
 
+  public CompletableFuture<Void> submitUnhandledExceptionAsync(
+      Exception exception, String submissionMethod) {
+    return CompletableFuture.runAsync(
+        () -> submitUnhandledException(exception, submissionMethod), executorService);
+  }
+
   public void submitUnhandledException(Exception exception, String submissionMethod) {
     Event event = createException().build();
     PluginContext pluginContext =
@@ -101,6 +118,10 @@ public void submitUnhandledException(Exception exception, String submissionMetho
     submitEvent(EventPluginContext.builder().event(event).context(pluginContext).build());
   }
 
+  public CompletableFuture<Void> submitFeatureUsageAsync(String feature) {
+    return CompletableFuture.runAsync(() -> submitFeatureUsage(feature), executorService);
+  }
+
   public void submitFeatureUsage(String feature) {
     Event event = createFeatureUsage(feature).build();
     submitEvent(EventPluginContext.from(event));
@@ -110,14 +131,26 @@ public Event.EventBuilder createFeatureUsage(String feature) {
     return createEvent().type(EventType.USAGE.value()).source(feature);
   }
 
+  public CompletableFuture<Void> submitLogAsync(String message) {
+    return CompletableFuture.runAsync(() -> submitLog(message), executorService);
+  }
+
   public void submitLog(String message) {
     submitLog(message, null, null);
   }
 
+  public CompletableFuture<Void> submitLogAsync(String message, String source) {
+    return CompletableFuture.runAsync(() -> submitLog(message, source), executorService);
+  }
+
   public void submitLog(String message, String source) {
     submitLog(message, source, null);
   }
 
+  public CompletableFuture<Void> submitLogAsync(String message, String source, String level) {
+    return CompletableFuture.runAsync(() -> submitLog(message, source, level), executorService);
+  }
+
   public void submitLog(String message, String source, String level) {
     Event event = createLog(message, source, level).build();
     submitEvent(EventPluginContext.from(event));
@@ -151,6 +184,10 @@ public Event.EventBuilder createLog(String message, String source, String level)
     return builder.property(EventPropertyKey.LOG_LEVEL.value(), level);
   }
 
+  public CompletableFuture<Void> submitNotFoundAsync(String resource) {
+    return CompletableFuture.runAsync(() -> submitNotFound(resource), executorService);
+  }
+
   public void submitNotFound(String resource) {
     Event event = createNotFound(resource).build();
     submitEvent(EventPluginContext.from(event));
@@ -160,6 +197,10 @@ public Event.EventBuilder createNotFound(String resource) {
     return createEvent().type(EventType.NOT_FOUND.value()).source(resource);
   }
 
+  public CompletableFuture<Void> submitSessionStartAsync() {
+    return CompletableFuture.runAsync(this::submitSessionStart, executorService);
+  }
+
   public void submitSessionStart() {
     Event event = createSessionStart().build();
     submitEvent(EventPluginContext.from(event));
@@ -175,16 +216,29 @@ public Event.EventBuilder createEvent() {
         .date(LocalDate.now());
   }
 
-  // todo this should be async
+  public CompletableFuture<Void> submitEventAsync(EventPluginContext eventPluginContext) {
+    return CompletableFuture.runAsync(() -> submitEvent(eventPluginContext), executorService);
+  }
+
   public void submitEvent(EventPluginContext eventPluginContext) {
     eventPluginRunner.run(eventPluginContext);
   }
 
+  public CompletableFuture<Void> submitSessionEndAsync(String sessionOrUserId) {
+    return CompletableFuture.runAsync(() -> submitSessionEnd(sessionOrUserId), executorService);
+  }
+
   public void submitSessionEnd(String sessionOrUserId) {
     LOG.info(String.format("Submitting session end: %s", sessionOrUserId));
     configurationManager.getSubmissionClient().sendHeartBeat(sessionOrUserId, true);
   }
 
+  public CompletableFuture<SubmissionResponse> updateEmailAndDescriptionAsync(
+      String referenceId, String email, String description) {
+    return CompletableFuture.supplyAsync(
+        () -> updateEmailAndDescription(referenceId, email, description), executorService);
+  }
+
   public SubmissionResponse updateEmailAndDescription(
       String referenceId, String email, String description) {
     SubmissionResponse response =

src/test/java/com/exceptionless/exceptionlessclient/ExceptionlessClientTest.java

@@ -5,11 +5,11 @@
 import com.exceptionless.exceptionlessclient.models.UserDescription;
 import com.exceptionless.exceptionlessclient.models.enums.EventPropertyKey;
 import com.exceptionless.exceptionlessclient.models.enums.EventType;
-import com.exceptionless.exceptionlessclient.settings.ServerSettings;
 import com.exceptionless.exceptionlessclient.models.submission.SettingsResponse;
 import com.exceptionless.exceptionlessclient.models.submission.SubmissionResponse;
 import com.exceptionless.exceptionlessclient.queue.DefaultEventQueue;
 import com.exceptionless.exceptionlessclient.settings.DefaultSettingsClient;
+import com.exceptionless.exceptionlessclient.settings.ServerSettings;
 import com.exceptionless.exceptionlessclient.storage.InMemoryStorage;
 import com.exceptionless.exceptionlessclient.storage.InMemoryStorageProvider;
 import com.exceptionless.exceptionlessclient.submission.DefaultSubmissionClient;
@@ -48,7 +48,7 @@ public void setup() {
             .submissionClient(submissionClient)
             .queue(eventQueue)
             .build();
-    client = new ExceptionlessClient(configurationManager, 1000);
+    client = new ExceptionlessClient(configurationManager, 1000, 10);
   }
 
   @Test