prepare 5.0.0-rc2 release (#194)

Author: eli-darkly

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to the LaunchDarkly Java SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.0.0-rc2] - 2020-05-13
+The primary purpose of this second beta release is to introduce the new `DataSourceStatusProvider` API, which is the server-side equivalent to the "connection status" API that exists in LaunchDarkly's mobile SDKs. Other additions and changes since the previous beta release (5.0.0-rc1) are described below. See the [5.0.0-rc1 release notes](https://github.com/launchdarkly/java-server-sdk/releases/tag/5.0.0-rc1) for other changes since 4.13.0.
+
+### Added:
+- `LDClient.getDataSourceStatusProvider()` is a status monitoring mechanism similar to `getDataStoreStatusProvider()`, but for the data source (streaming, polling, or file data). You can not only check the current connection status, but also choose to receive notifications when the status changes.
+- `LDConfig.Builder.logging()` is a new configuration category for options related to logging. Currently the only such option is `escalateDataSourceOutageLoggingAfter`, which controls the new connection failure logging behavior described below.
+- `LDConfig.Builder.threadPriority()` allows you to set the priority for worker threads created by the SDK.
+
+### Changed:
+- Network failures and server errors for streaming or polling requests were previously logged at `ERROR` level in most cases but sometimes at `WARN` level. They are now all at `WARN` level, but with a new behavior: if connection failures continue without a successful retry for a certain amount of time, the SDK will log a special `ERROR`-level message to warn you that this is not just a brief outage. The amount of time is one minute by default, but can be changed with the new `logDataSourceOutageAsErrorAfter` option in `LoggingConfigurationBuilder`.
+- The number of worker threads maintained by the SDK has been reduced so that most intermittent background tasks, such as listener notifications, event flush timers, and polling requests, are now dispatched on a single thread. The delivery of analytics events to LaunchDarkly still has its own thread pool because it is a heavier-weight task with greater need for concurrency.
+- In polling mode, the poll requests previously ran on a dedicated worker thread that inherited its priority from the application thread that created the SDK. They are now on the SDK's main worker thread, which has `Thread.MIN_PRIORITY` by default (as all the other SDK threads already did) but the priority can be changed as described above.
+- Only relevant for implementing custom components: The `DataStore` and `DataSource` interfaces, and their factories, have been changed to provide a more general mechanism for status reporting. This does not affect the part of a persistent data store implementation that is database-specific, so new beta releases of the Consul/DynamoDB/Redis libraries were not necessary.
+
 ## [5.0.0-rc1] - 2020-04-29
 This beta release is being made available for testing and user feedback, due to the large number of changes from Java SDK 4.x. Features are still subject to change in the final 5.0.0 release. Until the final release, the beta source code will be on the [5.x branch](https://github.com/launchdarkly/java-server-sdk/tree/5.x). Javadocs can be found on [javadoc.io](https://javadoc.io/doc/com.launchdarkly/launchdarkly-server-sdk/5.0.0-rc1/index.html).
 
@@ -34,6 +48,13 @@ This is a major rewrite that introduces a cleaner API design, adds new features,
 
 If you want to test this release and you are using Consul, DynamoDB, or Redis as a persistent data store, you will also need to update to version 2.0.0-rc1 of the [Consul integration](https://github.com/launchdarkly/java-server-sdk-consul/tree/2.x), 3.0.0-rc1 of the [DynamoDB integration](https://github.com/launchdarkly/java-server-sdk-dynamodb/tree/3.x), or 1.0.0-rc1 of the [Redis integration](http://github.com/launchdarkly/java-server-sdk-redis) (previously the Redis integration was built in; now it is a separate module).
 
+## [4.14.0] - 2020-05-13
+### Added:
+- `EventSender` interface and `EventsConfigurationBuilder.eventSender()` allow you to specify a custom implementation of how event data is sent. This is mainly to facilitate testing, but could also be used to store and forward event data.
+
+### Fixed:
+- Changed the Javadoc comments for the `LDClient` constructors to provide a better explanation of the client's initialization behavior.
+
 ## [4.13.0] - 2020-04-21
 ### Added:
 - The new methods `Components.httpConfiguration()` and `LDConfig.Builder.http()`, and the new class `HttpConfigurationBuilder`, provide a subcomponent configuration model that groups together HTTP-related options such as `connectTimeoutMillis` and `proxyHost` - similar to how `Components.streamingDataSource()` works for streaming-related options or `Components.sendEvents()` for event-related options. The individual `LDConfig.Builder` methods for those options will still work, but are deprecated and will be removed in version 5.0.

build.gradle

@@ -72,7 +72,7 @@ ext.versions = [
     "guava": "28.2-jre",
     "jackson": "2.10.0", 
     "launchdarklyJavaSdkCommon": "1.0.0-rc1",
-    "okhttpEventsource": "2.1.0",
+    "okhttpEventsource": "2.2.0",
     "slf4j": "1.7.21",
     "snakeyaml": "1.19",
     "jedis": "2.9.0"
@@ -326,11 +326,14 @@ def getFileFromClasspath(config, filePath) {
 }
 
 def addOsgiManifest(jarTask, List<Configuration> importConfigs, List<Configuration> exportConfigs) {
+    // For a prerelease build with "-beta", "-rc", etc., the prerelease qualifier has to be
+    // removed from the bundle version because OSGi doesn't understand it.
+    def implementationVersion = version.replaceFirst('-.*$', '')
     jarTask.manifest {
         attributes(
-            "Implementation-Version": version,
+            "Implementation-Version": implementationVersion,
             "Bundle-SymbolicName": "com.launchdarkly.sdk",
-            "Bundle-Version": version,
+            "Bundle-Version": implementationVersion,
             "Bundle-Name": "LaunchDarkly SDK",
             "Bundle-ManifestVersion": "2",
             "Bundle-Vendor": "LaunchDarkly"
@@ -351,7 +354,7 @@ def addOsgiManifest(jarTask, List<Configuration> importConfigs, List<Configurati
 
         // Similarly, we're adding package exports for every package in whatever libraries we're
         // making publicly available.
-        def sdkExports = getAllSdkPackages().collect { bundleExport(it, version) }
+        def sdkExports = getAllSdkPackages().collect { bundleExport(it, implementationVersion) }
         def exportedDependencies = forEachArtifactAndVisiblePackage(exportConfigs, { a, p ->
             bundleExport(p, a.moduleVersion.id.version)
         })

gradle.properties

@@ -1,4 +1,4 @@
-version=5.0.0-rc1
+version=5.0.0-rc2
 # The following empty ossrh properties are used by LaunchDarkly's internal integration testing framework
 # and should not be needed for typical development purposes (including by third-party developers).
 ossrhUsername=

packaging-test/test-app/build.gradle

@@ -36,6 +36,13 @@ dependencies {
 
 jar {
     bnd(
+        // This consumer-policy directive completely turns off version checking for the test app's
+        // OSGi imports, so for instance if the app uses version 2.x of package P, the import will
+        // just be for p rather than p;version="[2.x,3)". One wouldn't normally do this, but we
+        // need to be able to run the CI tests for snapshot/beta versions, and bnd does not handle
+        // those correctly (5.0.0-beta1 will become "[5.0.0,6)" which will not work because the
+        // beta is semantically *before* 5.0.0).
+        '-consumer-policy': '',
         'Bundle-Activator': 'testapp.TestAppOsgiEntryPoint',
         'Import-Package': 'com.launchdarkly.sdk,com.launchdarkly.sdk.json' +
             ',com.launchdarkly.sdk.server,org.slf4j' +

src/main/java/com/launchdarkly/sdk/server/ClientContextImpl.java

@@ -2,18 +2,66 @@
 
 import com.launchdarkly.sdk.server.interfaces.ClientContext;
 import com.launchdarkly.sdk.server.interfaces.HttpConfiguration;
+import com.launchdarkly.sdk.server.interfaces.LoggingConfiguration;
 
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * This is the package-private implementation of {@link ClientContext} that contains additional non-public
+ * SDK objects that may be used by our internal components.
+ * <p>
+ * All component factories, whether they are built-in ones or custom ones from the application, receive a
+ * {@link ClientContext} and can access its public properties. But only our built-in ones can see the
+ * package-private properties, which they can do by calling {@code ClientContextImpl.get(ClientContext)}
+ * to make sure that what they have is really a {@code ClientContextImpl} (as opposed to some other
+ * implementation of {@link ClientContext}, which might have been created for instance in application
+ * test code).
+ */
 final class ClientContextImpl implements ClientContext {
+  private static volatile ScheduledExecutorService fallbackSharedExecutor = null;
+  
   private final String sdkKey;
   private final HttpConfiguration httpConfiguration;
+  private final LoggingConfiguration loggingConfiguration;
   private final boolean offline;
-  private final DiagnosticAccumulator diagnosticAccumulator;
-  private final DiagnosticEvent.Init diagnosticInitEvent;
-  
-  ClientContextImpl(String sdkKey, LDConfig configuration, DiagnosticAccumulator diagnosticAccumulator) {
+  private final int threadPriority;
+  final ScheduledExecutorService sharedExecutor;
+  final DiagnosticAccumulator diagnosticAccumulator;
+  final DiagnosticEvent.Init diagnosticInitEvent;
+
+  private ClientContextImpl(
+      String sdkKey,
+      HttpConfiguration httpConfiguration,
+      LoggingConfiguration loggingConfiguration,
+      boolean offline,
+      int threadPriority,
+      ScheduledExecutorService sharedExecutor,
+      DiagnosticAccumulator diagnosticAccumulator,
+      DiagnosticEvent.Init diagnosticInitEvent
+  ) {
+    this.sdkKey = sdkKey;
+    this.httpConfiguration = httpConfiguration;
+    this.loggingConfiguration = loggingConfiguration;
+    this.offline = offline;
+    this.threadPriority = threadPriority;
+    this.sharedExecutor = sharedExecutor;
+    this.diagnosticAccumulator = diagnosticAccumulator;
+    this.diagnosticInitEvent = diagnosticInitEvent;
+  }
+
+  ClientContextImpl(
+      String sdkKey,
+      LDConfig configuration,
+      ScheduledExecutorService sharedExecutor,
+      DiagnosticAccumulator diagnosticAccumulator
+  ) {
     this.sdkKey = sdkKey;
     this.httpConfiguration = configuration.httpConfig;
+    this.loggingConfiguration = configuration.loggingConfig;
     this.offline = configuration.offline;
+    this.threadPriority = configuration.threadPriority;
+    this.sharedExecutor = sharedExecutor;
     if (!configuration.diagnosticOptOut && diagnosticAccumulator != null) {
       this.diagnosticAccumulator = diagnosticAccumulator;
       this.diagnosticInitEvent = new DiagnosticEvent.Init(diagnosticAccumulator.dataSinceDate, diagnosticAccumulator.diagnosticId, configuration);
@@ -37,28 +85,42 @@ public boolean isOffline() {
   public HttpConfiguration getHttpConfiguration() {
     return httpConfiguration;
   }
-  
-  // Note that the following two properties are package-private - they are only used by SDK internal components,
-  // not any custom components implemented by an application.
-  DiagnosticAccumulator getDiagnosticAccumulator() {
-    return diagnosticAccumulator;
+
+  @Override
+  public LoggingConfiguration getLoggingConfiguration() {
+    return loggingConfiguration;
   }
 
-  DiagnosticEvent.Init getDiagnosticInitEvent() {
-    return diagnosticInitEvent;
+  @Override
+  public int getThreadPriority() {
+    return threadPriority;
   }
 
-  static DiagnosticAccumulator getDiagnosticAccumulator(ClientContext context) {
+  /**
+   * This mechanism is a convenience for internal components to access the package-private fields of the
+   * context if it is a ClientContextImpl, and to receive null values for those fields if it is not.
+   * The latter case should only happen in application test code where the application developer has no
+   * way to create our package-private ClientContextImpl. In that case, we also generate a temporary
+   * sharedExecutor so components can work correctly in tests.
+   */
+  static ClientContextImpl get(ClientContext context) {
     if (context instanceof ClientContextImpl) {
-      return ((ClientContextImpl)context).getDiagnosticAccumulator();
+      return (ClientContextImpl)context;
     }
-    return null;
-  }
-
-  static DiagnosticEvent.Init getDiagnosticInitEvent(ClientContext context) {
-    if (context instanceof ClientContextImpl) {
-      return ((ClientContextImpl)context).getDiagnosticInitEvent();
+    synchronized (ClientContextImpl.class) {
+      if (fallbackSharedExecutor == null) {
+        fallbackSharedExecutor = Executors.newSingleThreadScheduledExecutor();
+      }
     }
-    return null;
+    return new ClientContextImpl(
+        context.getSdkKey(),
+        context.getHttpConfiguration(),
+        context.getLoggingConfiguration(),
+        context.isOffline(),
+        context.getThreadPriority(),
+        fallbackSharedExecutor,
+        null,
+        null
+        );
   }
 }