prepare 5.4.0 release

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

@@ -36,7 +36,9 @@ abstract Event.FeatureRequest newUnknownFeatureRequestEvent(
   abstract Event.Custom newCustomEvent(String key, LDUser user, LDValue data, Double metricValue);
 
   abstract Event.Identify newIdentifyEvent(LDUser user);
-
+
+  abstract Event.AliasEvent newAliasEvent(LDUser user, LDUser previousUser);
+
   final Event.FeatureRequest newFeatureRequestEvent(
       DataModel.FeatureFlag flag,
       LDUser user,
@@ -166,6 +168,11 @@ Event.Custom newCustomEvent(String key, LDUser user, LDValue data, Double metric
     Event.Identify newIdentifyEvent(LDUser user) {
       return new Event.Identify(timestampFn.get(), user);
     }
+
+    @Override
+    Event.AliasEvent newAliasEvent(LDUser user, LDUser previousUser) {
+      return new Event.AliasEvent(timestampFn.get(), user, previousUser);
+    }
   }
 
   static final class Disabled extends EventFactory {
@@ -191,6 +198,11 @@ final Custom newCustomEvent(String key, LDUser user, LDValue data, Double metric
     final Identify newIdentifyEvent(LDUser user) {
       return null;
     }
+
+    @Override
+    Event.AliasEvent newAliasEvent(LDUser user, LDUser previousUser) {
+      return null;
+    }
   }
 
   private static boolean isExperiment(DataModel.FeatureFlag flag, EvaluationReason reason) {

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

@@ -64,26 +64,38 @@ private final void writeOutputEvent(Event event, JsonWriter jw) throws IOExcepti
         jw.value(fe.getPrereqOf());
       }
       writeEvaluationReason("reason", fe.getReason(), jw);
-      jw.endObject();
+      if (!fe.getContextKind().equals("user")) {
+        jw.name("contextKind").value(fe.getContextKind());
+      }
     } else if (event instanceof Event.Identify) {
       startEvent(event, "identify", event.getUser() == null ? null : event.getUser().getKey(), jw);
       writeUser(event.getUser(), jw);
-      jw.endObject();
     } else if (event instanceof Event.Custom) {
       Event.Custom ce = (Event.Custom)event;
       startEvent(event, "custom", ce.getKey(), jw);
       writeUserOrKey(ce, false, jw);
       writeLDValue("data", ce.getData(), jw);
+      if (!ce.getContextKind().equals("user")) {
+        jw.name("contextKind").value(ce.getContextKind());
+      }
       if (ce.getMetricValue() != null) {
         jw.name("metricValue");
         jw.value(ce.getMetricValue());
       }
-      jw.endObject();
     } else if (event instanceof Event.Index) {
       startEvent(event, "index", null, jw);
       writeUser(event.getUser(), jw);
-      jw.endObject();
+    } else if (event instanceof Event.AliasEvent) {
+      Event.AliasEvent ae = (Event.AliasEvent)event;
+      startEvent(event, "alias", ae.getKey(), jw);
+      jw.name("contextKind").value(ae.getContextKind());
+      jw.name("previousKey").value(ae.getPreviousKey());
+      jw.name("previousContextKind").value(ae.getPreviousContextKind());
+    } else {
+      return;
     }
+
+    jw.endObject();
   }
 
   private final void writeSummaryEvent(EventSummarizer.EventSummary summary, JsonWriter jw) throws IOException {

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

@@ -526,6 +526,11 @@ public String secureModeHash(LDUser user) {
     return null;
   }
 
+  @Override
+  public void alias(LDUser user, LDUser previousUser) {
+    this.eventProcessor.sendEvent(eventFactoryDefault.newAliasEvent(user, previousUser));
+  }
+
   /**
    * Returns the current version string of the client library.
    * @return a version string conforming to Semantic Versioning (http://semver.org)

src/main/java/com/launchdarkly/sdk/server/interfaces/Event.java

@@ -40,6 +40,15 @@ public long getCreationDate() {
   public LDUser getUser() {
     return user;
   }
+
+  /**
+   * Convert a user into a context kind string
+   * @param user the user to get the context kind from
+   * @return the context kind string
+   */
+  private static final String computeContextKind(LDUser user) {
+    return user != null && user.isAnonymous() ? "anonymousUser" : "user";
+  }
 
   /**
    * A custom event created with {@link LDClientInterface#track(String, LDUser)} or one of its overloads.
@@ -48,6 +57,7 @@ public static final class Custom extends Event {
     private final String key;
     private final LDValue data;
     private final Double metricValue;
+    private final String contextKind;
 
     /**
      * Constructs a custom event.
@@ -61,8 +71,9 @@ public static final class Custom extends Event {
     public Custom(long timestamp, String key, LDUser user, LDValue data, Double metricValue) {
       super(timestamp, user);
       this.key = key;
-      this.data = data == null ? LDValue.ofNull() : data;
+      this.data = LDValue.normalize(data);
       this.metricValue = metricValue;
+      this.contextKind = computeContextKind(user);
     }
 
     /**
@@ -88,6 +99,14 @@ public LDValue getData() {
     public Double getMetricValue() {
       return metricValue;
     }
+
+    /**
+     * The context kind of the user that generated this event
+     * @return the context kind
+     */
+    public String getContextKind() {
+      return contextKind;
+    }
   }
 
   /**
@@ -132,6 +151,7 @@ public static final class FeatureRequest extends Event {
     private final long debugEventsUntilDate;
     private final EvaluationReason reason;
     private final boolean debug;
+    private final String contextKind;
 
     /**
      * Constructs a feature request event.
@@ -162,6 +182,7 @@ public FeatureRequest(long timestamp, String key, LDUser user, int version, int
       this.debugEventsUntilDate = debugEventsUntilDate;
       this.reason = reason;
       this.debug = debug;
+      this.contextKind = computeContextKind(user);
     }
 
     /**
@@ -243,5 +264,70 @@ public EvaluationReason getReason() {
     public boolean isDebug() {
       return debug;
     }
+
+    /**
+     * The context kind of the user that generated this event
+     * @return the context kind
+     */
+    public String getContextKind() {
+      return contextKind;
+    }
+  }
+
+  /**
+   * An event generated by aliasing users
+   * @since 5.4.0
+   */
+  public static final class AliasEvent extends Event {
+    private final String key;
+    private final String contextKind;
+    private final String previousKey;
+    private final String previousContextKind;
+
+    /**
+     * Constructs an alias event.
+     * @param timestamp when the event was created
+     * @param user the user being aliased to
+     * @param previousUser the user being aliased from
+     */
+    public AliasEvent(long timestamp, LDUser user, LDUser previousUser) {
+      super(timestamp, user);
+      this.key = user.getKey();
+      this.contextKind = computeContextKind(user);
+      this.previousKey = previousUser.getKey();
+      this.previousContextKind = computeContextKind(previousUser);
+    }
+
+    /**
+     * Get the key of the user being aliased to
+     * @return the user key
+     */
+    public String getKey() {
+      return key;
+    }
+
+    /**
+     * Get the kind of the user being aliased to
+     * @return the context kind
+     */
+    public String getContextKind() {
+      return contextKind;
+    }
+
+    /**
+     * Get the key of the user being aliased from
+     * @return the previous user key
+     */
+    public String getPreviousKey() {
+      return previousKey;
+    }
+
+    /**
+     * Get the kind of the user being aliased from
+     * @return the previous context kind
+     */
+    public String getPreviousContextKind() {
+      return previousContextKind;
+    }
   }
 }

src/main/java/com/launchdarkly/sdk/server/interfaces/LDClientInterface.java

@@ -266,9 +266,23 @@ public interface LDClientInterface extends Closeable {
    * For more info: <a href="https://github.com/launchdarkly/js-client#secure-mode">https://github.com/launchdarkly/js-client#secure-mode</a>
    * @param user the user to be hashed along with the SDK key
    * @return the hash, or null if the hash could not be calculated
-     */
+   */
   String secureModeHash(LDUser user);
 
+  /**
+   * Associates two users for analytics purposes. 
+   * 
+   * This can be helpful in the situation where a person is represented by multiple 
+   * LaunchDarkly users. This may happen, for example, when a person initially logs into 
+   * an application-- the person might be represented by an anonymous user prior to logging
+   * in and a different user after logging in, as denoted by a different user key.
+   * 
+   * @param user the newly identified user.
+   * @param previousUser the previously identified user.
+   * @since 5.4.0
+   */
+  void alias(LDUser user, LDUser previousUser);
+
   /**
    * The current version string of the SDK.
    * @return a string in Semantic Versioning 2.0.0 format

src/test/java/com/launchdarkly/sdk/server/EventOutputTest.java

@@ -9,6 +9,7 @@
 import com.launchdarkly.sdk.UserAttribute;
 import com.launchdarkly.sdk.server.EventSummarizer.EventSummary;
 import com.launchdarkly.sdk.server.interfaces.Event;
+import com.launchdarkly.sdk.server.interfaces.Event.AliasEvent;
 import com.launchdarkly.sdk.server.interfaces.Event.FeatureRequest;
 
 import org.junit.Test;
@@ -166,12 +167,16 @@ private void testPrivateAttributes(EventsConfiguration config, LDUser user, Stri
     assertEquals(o.build(), userJson);
   }
 
-  private ObjectBuilder buildFeatureEventProps(String key) {
+  private ObjectBuilder buildFeatureEventProps(String key, String userKey) {
     return LDValue.buildObject()
         .put("kind", "feature")
         .put("key", key)
         .put("creationDate", 100000)
-        .put("userKey", "userkey");
+        .put("userKey", userKey);
+  }
+
+  private ObjectBuilder buildFeatureEventProps(String key) {
+    return buildFeatureEventProps(key, "userkey");
   }
 
   @Test
@@ -180,6 +185,7 @@ public void featureEventIsSerialized() throws Exception {
     EventFactory factoryWithReason = eventFactoryWithTimestamp(100000, true);
     DataModel.FeatureFlag flag = flagBuilder("flag").version(11).build();
     LDUser user = new LDUser.Builder("userkey").name("me").build();
+    LDUser anon = new LDUser.Builder("anonymouskey").anonymous(true).build();
     EventOutputFormatter f = new EventOutputFormatter(defaultEventsConfig());
 
     FeatureRequest feWithVariation = factory.newFeatureRequestEvent(flag, user,
@@ -266,6 +272,18 @@ public void featureEventIsSerialized() throws Exception {
         .put("prereqOf", "parent")
         .build();
     assertEquals(feJson8, getSingleOutputEvent(f, prereqWithoutResult));
+
+    FeatureRequest anonFeWithVariation = factory.newFeatureRequestEvent(flag, anon,
+        new Evaluator.EvalResult(LDValue.of("flagvalue"), 1, EvaluationReason.off()),
+        LDValue.of("defaultvalue"));
+    LDValue anonFeJson1 = buildFeatureEventProps("flag", "anonymouskey")
+        .put("version", 11)
+        .put("variation", 1)
+        .put("value", "flagvalue")
+        .put("default", "defaultvalue")
+        .put("contextKind", "anonymousUser")
+        .build();
+    assertEquals(anonFeJson1, getSingleOutputEvent(f, anonFeWithVariation));
   }
 
   @Test
@@ -288,6 +306,7 @@ public void identifyEventIsSerialized() throws IOException {
   public void customEventIsSerialized() throws IOException {
     EventFactory factory = eventFactoryWithTimestamp(100000, false);
     LDUser user = new LDUser.Builder("userkey").name("me").build();
+    LDUser anon = new LDUser.Builder("userkey").name("me").anonymous(true).build();
     EventOutputFormatter f = new EventOutputFormatter(defaultEventsConfig());
 
     Event.Custom ceWithoutData = factory.newCustomEvent("customkey", user, LDValue.ofNull(), null);
@@ -329,6 +348,18 @@ public void customEventIsSerialized() throws IOException {
         "\"metricValue\":2.5" +
         "}");
     assertEquals(ceJson4, getSingleOutputEvent(f, ceWithDataAndMetric));
+
+    Event.Custom ceWithDataAndMetricAnon = factory.newCustomEvent("customkey", anon, LDValue.of("thing"), 2.5);
+    LDValue ceJson5 = parseValue("{" +
+        "\"kind\":\"custom\"," +
+        "\"creationDate\":100000," +
+        "\"key\":\"customkey\"," +
+        "\"userKey\":\"userkey\"," +
+        "\"data\":\"thing\"," +
+        "\"metricValue\":2.5," +
+        "\"contextKind\":\"anonymousUser\"" +
+        "}");
+    assertEquals(ceJson5, getSingleOutputEvent(f, ceWithDataAndMetricAnon));
   }
 
   @Test
@@ -401,6 +432,65 @@ public void unknownEventClassIsNotSerialized() throws Exception {
     assertEquals("[]", w.toString());
   }
 
+  @Test
+  public void aliasEventIsSerialized() throws IOException {
+    EventFactory factory = eventFactoryWithTimestamp(1000, false);
+    LDUser user1 = new LDUser.Builder("bob-key").build();
+    LDUser user2 = new LDUser.Builder("jeff-key").build();
+    LDUser anon1 = new LDUser.Builder("bob-key-anon").anonymous(true).build();
+    LDUser anon2 = new LDUser.Builder("jeff-key-anon").anonymous(true).build();
+    AliasEvent userToUser = factory.newAliasEvent(user1, user2);
+    AliasEvent userToAnon = factory.newAliasEvent(anon1, user1);
+    AliasEvent anonToUser = factory.newAliasEvent(user1, anon1);
+    AliasEvent anonToAnon = factory.newAliasEvent(anon1, anon2);
+
+    EventOutputFormatter fmt = new EventOutputFormatter(defaultEventsConfig());
+
+    LDValue userToUserExpected = parseValue("{" +
+      "\"kind\":\"alias\"," +
+      "\"creationDate\":1000," +
+      "\"key\":\"bob-key\"," +
+      "\"contextKind\":\"user\"," +
+      "\"previousKey\":\"jeff-key\"," +
+      "\"previousContextKind\":\"user\"" +
+      "}");
+
+    assertEquals(userToUserExpected, getSingleOutputEvent(fmt, userToUser));
+
+    LDValue userToAnonExpected = parseValue("{" +
+      "\"kind\":\"alias\"," +
+      "\"creationDate\":1000," +
+      "\"key\":\"bob-key-anon\"," +
+      "\"contextKind\":\"anonymousUser\"," +
+      "\"previousKey\":\"bob-key\"," +
+      "\"previousContextKind\":\"user\"" +
+      "}");
+
+    assertEquals(userToAnonExpected, getSingleOutputEvent(fmt, userToAnon));
+
+    LDValue anonToUserExpected = parseValue("{" +
+      "\"kind\":\"alias\"," +
+      "\"creationDate\":1000," +
+      "\"key\":\"bob-key\"," +
+      "\"contextKind\":\"user\"," +
+      "\"previousKey\":\"bob-key-anon\"," +
+      "\"previousContextKind\":\"anonymousUser\"" +
+      "}");
+
+    assertEquals(anonToUserExpected, getSingleOutputEvent(fmt, anonToUser));
+
+    LDValue anonToAnonExpected = parseValue("{" +
+      "\"kind\":\"alias\"," +
+      "\"creationDate\":1000," +
+      "\"key\":\"bob-key-anon\"," +
+      "\"contextKind\":\"anonymousUser\"," +
+      "\"previousKey\":\"jeff-key-anon\"," +
+      "\"previousContextKind\":\"anonymousUser\"" +
+      "}");
+
+    assertEquals(anonToAnonExpected, getSingleOutputEvent(fmt, anonToAnon));
+  }
+
   private static class FakeEventClass extends Event {
     public FakeEventClass(long creationDate, LDUser user) {
       super(creationDate, user);