prepare 5.9.1 release

build.gradle

@@ -74,7 +74,7 @@ ext.versions = [
     "jackson": "2.11.2", 
     "launchdarklyJavaSdkCommon": "1.3.0",
     "okhttp": "4.8.1", // specify this for the SDK build instead of relying on the transitive dependency from okhttp-eventsource
-    "okhttpEventsource": "2.3.2",
+    "okhttpEventsource": "2.6.1",
     "slf4j": "1.7.21",
     "snakeyaml": "1.26",
     "jedis": "2.9.0"

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

@@ -0,0 +1,141 @@
+package com.launchdarkly.sdk.server;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.JsonElement;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.launchdarkly.sdk.server.DataModel.FeatureFlag;
+import com.launchdarkly.sdk.server.DataModel.Segment;
+import com.launchdarkly.sdk.server.DataModel.VersionedData;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.DataKind;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.FullDataSet;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.ItemDescriptor;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.KeyedItems;
+import com.launchdarkly.sdk.server.interfaces.SerializationException;
+
+import java.io.IOException;
+import java.util.AbstractMap;
+import java.util.Map;
+
+import static com.launchdarkly.sdk.server.DataModel.FEATURES;
+import static com.launchdarkly.sdk.server.DataModel.SEGMENTS;
+import static com.launchdarkly.sdk.server.JsonHelpers.gsonInstance;
+
+/**
+ * JSON conversion logic specifically for our data model types.
+ * <p>
+ * More general JSON helpers are in JsonHelpers.
+ */
+abstract class DataModelSerialization {
+  /**
+   * Deserializes a data model object from JSON that was already parsed by Gson.
+   * <p>
+   * For built-in data model classes, our usual abstraction for deserializing from a string is inefficient in
+   * this case, because Gson has already parsed the original JSON and then we would have to convert the
+   * JsonElement back into a string and parse it again. So it's best to call Gson directly instead of going
+   * through our abstraction in that case, but it's also best to implement that special-casing just once here
+   * instead of scattered throughout the SDK.
+   * 
+   * @param kind the data kind
+   * @param parsedJson the parsed JSON
+   * @return the deserialized item
+   */
+  static VersionedData deserializeFromParsedJson(DataKind kind, JsonElement parsedJson) throws SerializationException {
+    VersionedData item;
+    try {
+      if (kind == FEATURES) {
+        item = gsonInstance().fromJson(parsedJson, FeatureFlag.class);
+      } else if (kind == SEGMENTS) {
+        item = gsonInstance().fromJson(parsedJson, Segment.class);
+      } else {
+        // This shouldn't happen since we only use this method internally with our predefined data kinds
+        throw new IllegalArgumentException("unknown data kind");
+      }
+    } catch (RuntimeException e) {
+      // A variety of unchecked exceptions can be thrown from JSON parsing; treat them all the same
+      throw new SerializationException(e);
+    }
+    return item;
+  }
+
+  /**
+   * Deserializes a data model object from a Gson reader.
+   * 
+   * @param kind the data kind
+   * @param jr the JSON reader
+   * @return the deserialized item
+   */
+  static VersionedData deserializeFromJsonReader(DataKind kind, JsonReader jr) throws SerializationException {
+    VersionedData item;
+    try {
+      if (kind == FEATURES) {
+        item = gsonInstance().fromJson(jr, FeatureFlag.class);
+      } else if (kind == SEGMENTS) {
+        item = gsonInstance().fromJson(jr, Segment.class);
+      } else {
+        // This shouldn't happen since we only use this method internally with our predefined data kinds
+        throw new IllegalArgumentException("unknown data kind");
+      }
+    } catch (RuntimeException e) {
+      // A variety of unchecked exceptions can be thrown from JSON parsing; treat them all the same
+      throw new SerializationException(e);
+    }
+    return item;
+  }
+
+  /**
+   * Deserializes a full set of flag/segment data from a standard JSON object representation
+   * in the form {"flags": ..., "segments": ...} (which is used in both streaming and polling
+   * responses).
+   * 
+   * @param jr the JSON reader
+   * @return the deserialized data
+   */
+  static FullDataSet<ItemDescriptor> parseFullDataSet(JsonReader jr) throws SerializationException {
+    ImmutableList.Builder<Map.Entry<String, ItemDescriptor>> flags = ImmutableList.builder();
+    ImmutableList.Builder<Map.Entry<String, ItemDescriptor>> segments = ImmutableList.builder();
+
+    try {
+      jr.beginObject();
+      while (jr.peek() != JsonToken.END_OBJECT) {
+        String kindName = jr.nextName();
+        Class<?> itemClass;
+        ImmutableList.Builder<Map.Entry<String, ItemDescriptor>> listBuilder;
+        switch (kindName) {
+        case "flags":
+          itemClass = DataModel.FeatureFlag.class;
+          listBuilder = flags;
+          break;
+        case "segments":
+          itemClass = DataModel.Segment.class;
+          listBuilder = segments;
+          break;
+        default:
+          jr.skipValue();
+          continue;
+        }
+        jr.beginObject();
+        while (jr.peek() != JsonToken.END_OBJECT) {
+          String key = jr.nextName();
+          @SuppressWarnings("unchecked")
+          Object item = JsonHelpers.deserialize(jr, (Class<Object>)itemClass);
+          listBuilder.add(new AbstractMap.SimpleEntry<>(key,
+              new ItemDescriptor(((VersionedData)item).getVersion(), item)));
+        }
+        jr.endObject();
+      }
+      jr.endObject();
+
+      return new FullDataSet<ItemDescriptor>(ImmutableMap.of(
+          FEATURES, new KeyedItems<>(flags.build()),
+          SEGMENTS, new KeyedItems<>(segments.build())
+          ).entrySet());
+    } catch (IOException e) {
+      throw new SerializationException(e);
+    } catch (RuntimeException e) {
+      // A variety of unchecked exceptions can be thrown from JSON parsing; treat them all the same
+      throw new SerializationException(e);
+    }
+  }
+}

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

@@ -460,6 +460,7 @@ private void triggerFlush(EventBuffer outbox, BlockingQueue<FlushPayload> payloa
       } else {
         logger.debug("Skipped flushing because all workers are busy");
         // All the workers are busy so we can't flush now; keep the events in our state
+        outbox.summarizer.restoreTo(payload.summary);
         synchronized(busyFlushWorkersCount) {
           busyFlushWorkersCount.decrementAndGet();
           busyFlushWorkersCount.notify();
@@ -506,7 +507,7 @@ void addToSummary(Event e) {
     }
 
     boolean isEmpty() {
-      return events.isEmpty() && summarizer.snapshot().isEmpty();
+      return events.isEmpty() && summarizer.isEmpty();
     }
 
     long getAndClearDroppedCount() {
@@ -517,7 +518,7 @@ long getAndClearDroppedCount() {
 
     FlushPayload getPayload() {
       Event[] eventsOut = events.toArray(new Event[events.size()]);
-      EventSummarizer.EventSummary summary = summarizer.snapshot();
+      EventSummarizer.EventSummary summary = summarizer.getSummaryAndReset();
       return new FlushPayload(eventsOut, summary);
     }
 

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

@@ -1,6 +1,9 @@
 package com.launchdarkly.sdk.server;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.gson.stream.JsonReader;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.FullDataSet;
+import com.launchdarkly.sdk.server.interfaces.DataStoreTypes.ItemDescriptor;
 import com.launchdarkly.sdk.server.interfaces.HttpConfiguration;
 import com.launchdarkly.sdk.server.interfaces.SerializationException;
 
@@ -11,6 +14,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 
+import static com.launchdarkly.sdk.server.DataModelSerialization.parseFullDataSet;
 import static com.launchdarkly.sdk.server.Util.concatenateUriPath;
 import static com.launchdarkly.sdk.server.Util.configureHttpClientBuilder;
 import static com.launchdarkly.sdk.server.Util.getHeadersBuilderFor;
@@ -23,7 +27,7 @@
 import okhttp3.Response;
 
 /**
- * Implementation of getting flag data via a polling request. Used by both streaming and polling components.
+ * Implementation of getting flag data via a polling request.
  */
 final class DefaultFeatureRequestor implements FeatureRequestor {
   private static final Logger logger = Loggers.DATA_SOURCE;
@@ -59,7 +63,8 @@ public void close() {
     Util.deleteDirectory(cacheDir);
   }
 
-  public AllData getAllData(boolean returnDataEvenIfCached) throws IOException, HttpErrorException, SerializationException {
+  public FullDataSet<ItemDescriptor> getAllData(boolean returnDataEvenIfCached)
+      throws IOException, HttpErrorException, SerializationException {
     Request request = new Request.Builder()
         .url(pollingUri.toURL())
         .headers(headers)
@@ -75,18 +80,18 @@ public AllData getAllData(boolean returnDataEvenIfCached) throws IOException, Ht
         logger.debug("Cache hit count: " + httpClient.cache().hitCount() + " Cache network Count: " + httpClient.cache().networkCount());
         return null;
       }
-
-      String body = response.body().string();
 
-      if (!response.isSuccessful()) {
-        throw new HttpErrorException(response.code());
-      }
-      logger.debug("Get flag(s) response: " + response.toString() + " with body: " + body);
+      logger.debug("Get flag(s) response: " + response.toString());
       logger.debug("Network response: " + response.networkResponse());
       logger.debug("Cache hit count: " + httpClient.cache().hitCount() + " Cache network Count: " + httpClient.cache().networkCount());
       logger.debug("Cache response: " + response.cacheResponse());
-
-      return JsonHelpers.deserialize(body, AllData.class);
+
+      if (!response.isSuccessful()) {
+        throw new HttpErrorException(response.code());
+      }
+
+      JsonReader jr = new JsonReader(response.body().charStream());
+      return parseFullDataSet(jr);
     }
   }
 }

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

@@ -5,12 +5,14 @@
 import com.launchdarkly.sdk.EvaluationReason;
 import com.launchdarkly.sdk.LDUser;
 import com.launchdarkly.sdk.LDValue;
-import com.launchdarkly.sdk.server.EventSummarizer.CounterKey;
 import com.launchdarkly.sdk.server.EventSummarizer.CounterValue;
+import com.launchdarkly.sdk.server.EventSummarizer.FlagInfo;
+import com.launchdarkly.sdk.server.EventSummarizer.SimpleIntKeyedMap;
 import com.launchdarkly.sdk.server.interfaces.Event;
 
 import java.io.IOException;
 import java.io.Writer;
+import java.util.Map;
 
 /**
  * Transforms analytics events and summary data into the JSON format that we send to LaunchDarkly.
@@ -28,6 +30,7 @@ final class EventOutputFormatter {
     this.gson = JsonHelpers.gsonInstanceForEventsSerialization(config);
   }
 
+  @SuppressWarnings("resource")
   final int writeOutputEvents(Event[] events, EventSummarizer.EventSummary summary, Writer writer) throws IOException {
     int count = events.length;    
     try (JsonWriter jsonWriter = new JsonWriter(writer)) {
@@ -112,59 +115,48 @@ private final void writeSummaryEvent(EventSummarizer.EventSummary summary, JsonW
     jw.name("features");
     jw.beginObject();
 
-    CounterKey[] unprocessedKeys = summary.counters.keySet().toArray(new CounterKey[summary.counters.size()]);
-    for (int i = 0; i < unprocessedKeys.length; i++) {
-      if (unprocessedKeys[i] == null) {
-        continue;
-      }
-      CounterKey key = unprocessedKeys[i];
-      String flagKey = key.key;
-      CounterValue firstValue = summary.counters.get(key);
+    for (Map.Entry<String, FlagInfo> flag: summary.counters.entrySet()) {
+      String flagKey = flag.getKey();
+      FlagInfo flagInfo = flag.getValue();
 
       jw.name(flagKey);
       jw.beginObject();
 
-      writeLDValue("default", firstValue.defaultVal, jw);
+      writeLDValue("default", flagInfo.defaultVal, jw);
 
       jw.name("counters");
       jw.beginArray();
 
-      for (int j = i; j < unprocessedKeys.length; j++) {
-        CounterKey keyForThisFlag = unprocessedKeys[j];
-        if (j != i && (keyForThisFlag == null || !keyForThisFlag.key.equals(flagKey))) {
-          continue;
-        }
-        CounterValue value = keyForThisFlag == key ? firstValue : summary.counters.get(keyForThisFlag);
-        unprocessedKeys[j] = null;
-
-        jw.beginObject();
-
-        if (keyForThisFlag.variation >= 0) {
-          jw.name("variation");
-          jw.value(keyForThisFlag.variation);
+      for (int i = 0; i < flagInfo.versionsAndVariations.size(); i++) {
+        int version = flagInfo.versionsAndVariations.keyAt(i);
+        SimpleIntKeyedMap<CounterValue> variations = flagInfo.versionsAndVariations.valueAt(i);
+        for (int j = 0; j < variations.size(); j++) {
+          int variation = variations.keyAt(j);
+          CounterValue counter = variations.valueAt(j);
+
+          jw.beginObject();
+
+          if (variation >= 0) {
+            jw.name("variation").value(variation);
+          }
+          if (version >= 0) {
+            jw.name("version").value(version);
+          } else {
+            jw.name("unknown").value(true);
+          }
+          writeLDValue("value", counter.flagValue, jw);
+          jw.name("count").value(counter.count);
+
+          jw.endObject();
         }
-        if (keyForThisFlag.version >= 0) {
-          jw.name("version");
-          jw.value(keyForThisFlag.version);
-        } else {
-          jw.name("unknown");
-          jw.value(true);
-        }
-        writeLDValue("value", value.flagValue, jw);
-        jw.name("count");
-        jw.value(value.count);
-
-        jw.endObject(); // end of this counter
       }
-      
+
       jw.endArray(); // end of "counters" array
-
       jw.endObject(); // end of this flag
     }
 
     jw.endObject(); // end of "features"
-
-    jw.endObject();
+    jw.endObject(); // end of summary event object
   }
 
   private final void startEvent(Event event, String kind, String key, JsonWriter jw) throws IOException {