prepare 2.3.0 release (#27)

Author: LaunchDarklyCI

include/launchdarkly/client.h

@@ -77,6 +77,19 @@ LD_EXPORT(LDBoolean) LDClientTrackMetric(struct LDClient *const client,
     const char *const key, const struct LDUser *const user,
     struct LDJSON *const data, const double metric);
 
+/**
+ * @brief Record a alias event
+ * @param[in] client The client to use. May not be `NULL`.
+ * @param[in] currentUser The new version of a user. Ownership is not
+ * transferred. May not be `NULL`.
+ * @param[in] previousUser The previous version of a user. Ownership is not
+ * transferred. May not be `NULL`.
+ * @return True if the event was queued, False on error.
+ */
+LD_EXPORT(LDBoolean) LDClientAlias(struct LDClient *const client,
+    const struct LDUser *const currentUser,
+    const struct LDUser *const previousUser);
+
 /**
  * @brief Generates an identify event for a user.
  * @param[in] client The client to use. May not be `NULL`.

src/client.c

@@ -185,6 +185,39 @@ LDClientTrackMetric(struct LDClient *const client, const char *const key,
     return LDi_track(client->eventProcessor, user, key, data, metric, true);
 }
 
+LDBoolean
+LDClientAlias(
+    struct LDClient *const     client,
+    const struct LDUser *const currentUser,
+    const struct LDUser *const previousUser
+) {
+    LD_ASSERT_API(client);
+    LD_ASSERT_API(currentUser);
+    LD_ASSERT_API(previousUser);
+
+    #ifdef LAUNCHDARKLY_DEFENSIVE
+        if (client == NULL) {
+            LD_LOG(LD_LOG_WARNING, "LDClientAlias NULL client");
+
+            return 0;
+        }
+
+        if (currentUser == NULL) {
+            LD_LOG(LD_LOG_WARNING, "LDClientAlias NULL currentUser");
+
+            return 0;
+        }
+
+        if (previousUser == NULL) {
+            LD_LOG(LD_LOG_WARNING, "LDClientAlias NULL previousUser");
+
+            return 0;
+        }
+    #endif
+
+    return LDi_alias(client->eventProcessor, currentUser, previousUser);
+}
+
 LDBoolean
 LDClientIdentify(struct LDClient *const client, const struct LDUser *const user)
 {

src/event_processor.c

@@ -840,6 +840,18 @@ LDi_newFeatureRequestEvent(
         }
     }
 
+    if (user->anonymous) {
+        if (!(tmp = LDNewText("anonymousUser"))) {
+            goto error;
+        }
+
+        if (!LDObjectSetKey(event, "contextKind", tmp)) {
+            LDJSONFree(tmp);
+
+            goto error;
+        }
+    }
+
     return event;
 
   error:
@@ -1172,6 +1184,18 @@ LDi_newCustomEvent(
         }
     }
 
+    if (user->anonymous) {
+        if (!(tmp = LDNewText("anonymousUser"))) {
+            goto error;
+        }
+
+        if (!LDObjectSetKey(event, "contextKind", tmp)) {
+            LDJSONFree(tmp);
+
+            goto error;
+        }
+    }
+
     return event;
 
   error:
@@ -1372,6 +1396,103 @@ LDi_track(
     return true;
 }
 
+static struct LDJSON *
+contextKindString(const struct LDUser *const user)
+{
+    if (user->anonymous) {
+        return LDNewText("anonymousUser");
+    } else {
+        return LDNewText("user");
+    }
+}
+
+struct LDJSON *
+LDi_newAliasEvent(
+    const struct LDUser *const   currentUser,
+    const struct LDUser *const   previousUser,
+    const double                 now
+) {
+    struct LDJSON *tmp, *event;
+
+    LD_ASSERT(currentUser);
+    LD_ASSERT(previousUser);
+
+    tmp   = NULL;
+    event = NULL;
+
+    if (!(event = LDi_newBaseEvent("alias", now))) {
+        goto error;
+    }
+
+    if (!(tmp = LDNewText(currentUser->key))) {
+        goto error;
+    }
+
+    if (!LDObjectSetKey(event, "key", tmp)) {
+        goto error;
+    }
+
+    if (!(tmp = LDNewText(previousUser->key))) {
+        goto error;
+    }
+
+    if (!LDObjectSetKey(event, "previousKey", tmp)) {
+        goto error;
+    }
+
+    if (!(tmp = contextKindString(currentUser))) {
+        goto error;
+    }
+
+    if (!LDObjectSetKey(event, "contextKind", tmp)) {
+        goto error;
+    }
+
+    if (!(tmp = contextKindString(previousUser))) {
+        goto error;
+    }
+
+    if (!LDObjectSetKey(event, "previousContextKind", tmp)) {
+        goto error;
+    }
+
+    return event;
+
+  error:
+    LDJSONFree(event);
+    LDJSONFree(tmp);
+
+    return NULL;
+}
+
+LDBoolean
+LDi_alias(
+    struct EventProcessor *const context,
+    const struct LDUser *const   currentUser,
+    const struct LDUser *const   previousUser
+) {
+    struct LDJSON *event;
+    double now;
+
+    LD_ASSERT(context);
+    LD_ASSERT(currentUser);
+    LD_ASSERT(previousUser);
+
+    LDi_getUnixMilliseconds(&now);
+
+    if (!(event = LDi_newAliasEvent(currentUser, previousUser, now))) {
+        LD_LOG(LD_LOG_ERROR, "failed to construct alias event");
+
+        return 0;
+    }
+
+    LDi_mutex_lock(&context->lock);
+    LDi_addEvent(context, event);
+    LDi_mutex_unlock(&context->lock);
+
+    return 1;
+}
+
 bool
 LDi_bundleEventPayload(
     struct EventProcessor *const context,

src/event_processor.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <launchdarkly/boolean.h>
 #include <launchdarkly/json.h>
 #include <launchdarkly/variations.h>
 
@@ -34,6 +35,13 @@ LDi_track(
     const bool                   hasMetric
 );
 
+LDBoolean
+LDi_alias(
+    struct EventProcessor *const context,
+    const struct LDUser *const   currentUser,
+    const struct LDUser *const   previousUser
+);
+
 bool
 LDi_processEvaluation(
     /* required */

src/event_processor_internal.h

@@ -64,6 +64,13 @@ LDi_newCustomEvent(
     const double                       now
 );
 
+struct LDJSON *
+LDi_newAliasEvent(
+    const struct LDUser *const currentUser,
+    const struct LDUser *const previousUser,
+    const double               now
+);
+
 void
 LDi_possiblyQueueEvent(
     struct EventProcessor *const context,

tests/test-event-processor.c

@@ -534,6 +534,65 @@ testExperimentationRuleNonDetailed()
     LDClientClose(client);
 }
 
+static void
+testConstructAliasEvent()
+{
+    struct LDUser *previous, *current;
+    struct LDJSON *result, *expected;
+
+    LD_ASSERT(previous = LDUserNew("a"));
+    LD_ASSERT(current = LDUserNew("b"));
+
+    LDUserSetAnonymous(previous, true);
+
+    LD_ASSERT(result = LDi_newAliasEvent(current, previous, 52));
+
+    LD_ASSERT(expected = LDNewObject());
+    LD_ASSERT(LDObjectSetKey(expected, "kind", LDNewText("alias")));
+    LD_ASSERT(LDObjectSetKey(expected, "creationDate", LDNewNumber(52)));
+    LD_ASSERT(LDObjectSetKey(expected, "key", LDNewText("b")));
+    LD_ASSERT(LDObjectSetKey(expected, "contextKind", LDNewText("user")));
+    LD_ASSERT(LDObjectSetKey(expected, "previousKey", LDNewText("a")));
+    LD_ASSERT(LDObjectSetKey(expected, "previousContextKind",
+      LDNewText("anonymousUser")));
+
+    LD_ASSERT(LDJSONCompare(result, expected));
+
+    LDJSONFree(expected);
+    LDJSONFree(result);
+    LDUserFree(previous);
+    LDUserFree(current);
+}
+
+static void
+testAliasEventIsQueued()
+{
+    struct LDClient *client;
+    double metricValue;
+    const char *metricName;
+    struct LDJSON *payload, *event;
+    struct LDUser *previous, *current;
+
+    LD_ASSERT(previous = LDUserNew("p"));
+    LD_ASSERT(current = LDUserNew("c"));
+
+    LD_ASSERT(client = makeOfflineClient());
+
+    LDClientAlias(client, current, previous);
+
+    LD_ASSERT(LDi_bundleEventPayload(client->eventProcessor, &payload))
+
+    LD_ASSERT(LDCollectionGetSize(payload) == 1);
+    LD_ASSERT(event = LDArrayLookup(payload, 0));
+    LD_ASSERT(strcmp("alias", LDGetText(LDObjectLookup(event, "kind"))) == 0);
+
+    LDUserFree(previous);
+    LDUserFree(current);
+    LDJSONFree(payload);
+
+    LDClientClose(client);
+}
+
 int
 main()
 {
@@ -553,6 +612,8 @@ main()
     testDetailsIncludedIfDetailed();
     testExperimentationFallthroughNonDetailed();
     testExperimentationRuleNonDetailed();
+    testConstructAliasEvent();
+    testAliasEventIsQueued();
 
     LDBasicLoggerThreadSafeShutdown();