prepare 5.0.0 release

.ldrelease/config.yml

@@ -6,7 +6,8 @@ repo:
 
 branches:
   - name: main
-    description: 4.x
+    description: 5.x
+  - name: 4.x
   - name: 3.x
 
 publications:

package.json

@@ -9,6 +9,7 @@
   "scripts": {
     "lint": "eslint --format 'node_modules/eslint-formatter-pretty' --ignore-path .eslintignore",
     "lint:all": "eslint --format 'node_modules/eslint-formatter-pretty' --ignore-path .eslintignore src",
+    "lint-fix:all": "eslint --fix --format 'node_modules/eslint-formatter-pretty' --ignore-path .eslintignore src",
     "format": "npm run format:md && npm run format:js",
     "format:md": "prettier --parser markdown --ignore-path .prettierignore --write '*.md'",
     "format:js": "prettier --ignore-path .prettierignore --write 'src/**/*.js'",
@@ -26,6 +27,7 @@
     "@babel/preset-env": "^7.6.3",
     "@babel/runtime": "7.6.3",
     "@rollup/plugin-replace": "^2.2.0",
+    "@types/jest": "^27.4.1",
     "babel-eslint": "^10.1.0",
     "babel-jest": "^25.1.0",
     "cross-env": "^5.1.4",

src/AnonymousContextProcessor.js

@@ -0,0 +1,95 @@
+const { v1: uuidv1 } = require('uuid');
+const { getContextKinds } = require('./context');
+
+const errors = require('./errors');
+const messages = require('./messages');
+const utils = require('./utils');
+
+const ldUserIdKey = 'ld:$anonUserId';
+
+/**
+ * Create an object which can process a context and populate any required keys
+ * for anonymous objects.
+ *
+ * @param {Object} persistentStorage The persistent storage from which to store
+ * and access persisted anonymous context keys.
+ * @returns An AnonymousContextProcessor.
+ */
+function AnonymousContextProcessor(persistentStorage) {
+  function getContextKeyIdString(kind) {
+    if (kind === undefined || kind === null || kind === 'user') {
+      return ldUserIdKey;
+    }
+    return `ld:$contextKey:${kind}`;
+  }
+
+  function getCachedContextKey(kind) {
+    return persistentStorage.get(getContextKeyIdString(kind));
+  }
+
+  function setCachedContextKey(id, kind) {
+    return persistentStorage.set(getContextKeyIdString(kind), id);
+  }
+
+  /**
+   * Process a single kind context, or a single context within a multi-kind context.
+   * @param {string} kind The kind of the context. Independent because the kind is not prevent
+   * within a context in a multi-kind context.
+   * @param {Object} context
+   * @returns {Promise} a promise that resolves to a processed contexts, or rejects
+   * a context which cannot be processed.
+   */
+  function processSingleKindContext(kind, context) {
+    // We are working on a copy of an original context, so we want to re-assign
+    // versus duplicating it again.
+
+    /* eslint-disable no-param-reassign */
+    if (context.key !== null && context.key !== undefined) {
+      context.key = context.key.toString();
+      return Promise.resolve(context);
+    }
+
+    if (context.anonymous) {
+      // If the key doesn't exist, then the persistent storage will resolve
+      // with undefined.
+      return getCachedContextKey(kind).then(cachedId => {
+        if (cachedId) {
+          context.key = cachedId;
+          return context;
+        } else {
+          const id = uuidv1();
+          context.key = id;
+          return setCachedContextKey(id, kind).then(() => context);
+        }
+      });
+    } else {
+      return Promise.reject(new errors.LDInvalidUserError(messages.invalidContext()));
+    }
+    /* eslint-enable no-param-reassign */
+  }
+
+  /**
+   * Process the context, returning a Promise that resolves to the processed context, or rejects if there is an error.
+   * @param {Object} context
+   * @returns {Promise} A promise which resolves to a processed context, or a rejection if the context cannot be
+   * processed. The context should still be checked for overall validity after being processed.
+   */
+  this.processContext = context => {
+    if (!context) {
+      return Promise.reject(new errors.LDInvalidUserError(messages.contextNotSpecified()));
+    }
+
+    const processedContext = utils.clone(context);
+
+    if (context.kind === 'multi') {
+      const kinds = getContextKinds(processedContext);
+
+      return Promise.all(kinds.map(kind => processSingleKindContext(kind, processedContext[kind]))).then(
+        () => processedContext
+      );
+    }
+    return processSingleKindContext(context.kind, processedContext);
+  };
+}
+
+module.exports = AnonymousContextProcessor;

src/ContextFilter.js

@@ -0,0 +1,137 @@
+const AttributeReference = require('./attributeReference');
+
+function ContextFilter(config) {
+  const filter = {};
+
+  const allAttributesPrivate = config.allAttributesPrivate;
+  const privateAttributes = config.privateAttributes || [];
+
+  // These attributes cannot be removed via a private attribute.
+  const protectedAttributes = ['key', 'kind', '_meta', 'anonymous'];
+
+  const legacyTopLevelCopyAttributes = ['name', 'ip', 'firstName', 'lastName', 'email', 'avatar', 'country'];
+
+  /**
+   * For the given context and configuration get a list of attributes to filter.
+   * @param {Object} context
+   * @returns {string[]} A list of the attributes to filter.
+   */
+  const getAttributesToFilter = context =>
+    (allAttributesPrivate
+      ? Object.keys(context)
+      : [...privateAttributes, ...((context._meta && context._meta.privateAttributes) || [])]
+    ).filter(attr => !protectedAttributes.some(protectedAttr => AttributeReference.compare(attr, protectedAttr)));
+
+  /**
+   * @param {Object} context
+   * @returns {Object} A copy of the context with private attributes removed,
+   * and the redactedAttributes meta populated.
+   */
+  const filterSingleKind = context => {
+    if (typeof context !== 'object' || context === null || Array.isArray(context)) {
+      return undefined;
+    }
+
+    const { cloned, excluded } = AttributeReference.cloneExcluding(context, getAttributesToFilter(context));
+    cloned.key = String(cloned.key);
+    if (excluded.length) {
+      if (!cloned._meta) {
+        cloned._meta = {};
+      }
+      cloned._meta.redactedAttributes = excluded;
+    }
+    if (cloned._meta) {
+      delete cloned._meta['privateAttributes'];
+      if (Object.keys(cloned._meta).length === 0) {
+        delete cloned._meta;
+      }
+    }
+    // Make sure anonymous is boolean if present.
+    // Null counts as present, and would be falsy, which is the default.
+    if (cloned.anonymous !== undefined) {
+      cloned.anonymous = !!cloned.anonymous;
+    }
+
+    return cloned;
+  };
+
+  /**
+   * @param {Object} context
+   * @returns {Object} A copy of the context with the private attributes removed,
+   * and the redactedAttributes meta populated for each sub-context.
+   */
+  const filterMultiKind = context => {
+    const filtered = {
+      kind: context.kind,
+    };
+    const contextKeys = Object.keys(context);
+
+    for (const contextKey of contextKeys) {
+      if (contextKey !== 'kind') {
+        const filteredContext = filterSingleKind(context[contextKey]);
+        if (filteredContext) {
+          filtered[contextKey] = filteredContext;
+        }
+      }
+    }
+    return filtered;
+  };
+
+  /**
+   * Convert the LDUser object into an LDContext object.
+   * @param {Object} user The LDUser to produce an LDContext for.
+   * @returns {Object} A single kind context based on the provided user.
+   */
+  const legacyToSingleKind = user => {
+    const filtered = {
+      /* Destructure custom items into the top level.
+         Duplicate keys will be overridden by previously
+         top level items.
+      */
+      ...(user.custom || {}),
+
+      // Implicity a user kind.
+      kind: 'user',
+
+      key: user.key,
+    };
+
+    if (user.anonymous !== undefined) {
+      filtered.anonymous = !!user.anonymous;
+    }
+
+    // Copy top level keys and convert them to strings.
+    // Remove keys that may have been destructured from `custom`.
+    for (const key of legacyTopLevelCopyAttributes) {
+      delete filtered[key];
+      if (user[key] !== undefined && user[key] !== null) {
+        filtered[key] = String(user[key]);
+      }
+    }
+
+    if (user.privateAttributeNames !== undefined && user.privateAttributeNames !== null) {
+      filtered._meta = filtered._meta || {};
+      // If any private attributes started with '/' we need to convert them to references, otherwise the '/' will
+      // cause the literal to incorrectly be treated as a reference.
+      filtered._meta.privateAttributes = user.privateAttributeNames.map(
+        literal => (literal.startsWith('/') ? AttributeReference.literalToReference(literal) : literal)
+      );
+    }
+
+    return filtered;
+  };
+
+  filter.filter = context => {
+    if (context.kind === undefined || context.kind === null) {
+      return filterSingleKind(legacyToSingleKind(context));
+    } else if (context.kind === 'multi') {
+      return filterMultiKind(context);
+    } else {
+      return filterSingleKind(context);
+    }
+  };
+
+  return filter;
+}
+
+module.exports = ContextFilter;

src/EventProcessor.js

@@ -1,9 +1,10 @@
 const EventSender = require('./EventSender');
 const EventSummarizer = require('./EventSummarizer');
-const UserFilter = require('./UserFilter');
+const ContextFilter = require('./ContextFilter');
 const errors = require('./errors');
 const messages = require('./messages');
 const utils = require('./utils');
+const { getContextKeys } = require('./context');
 
 function EventProcessor(
   platform,
@@ -17,8 +18,7 @@ function EventProcessor(
   const eventSender = sender || EventSender(platform, environmentId, options);
   const mainEventsUrl = utils.appendUrlPath(options.eventsUrl, '/events/bulk/' + environmentId);
   const summarizer = EventSummarizer();
-  const userFilter = UserFilter(options);
-  const inlineUsers = options.inlineUsersInEvents;
+  const contextFilter = ContextFilter(options);
   const samplingInterval = options.samplingInterval;
   const eventCapacity = options.eventCapacity;
   const flushInterval = options.flushInterval;
@@ -47,16 +47,12 @@ function EventProcessor(
   // Transform an event from its internal format to the format we use when sending a payload.
   function makeOutputEvent(e) {
     const ret = utils.extend({}, e);
-    if (e.kind === 'alias') {
-      // alias events do not require any transformation
-      return ret;
-    }
-    if (inlineUsers || e.kind === 'identify') {
-      // identify events always have an inline user
-      ret.user = userFilter.filterUser(e.user);
+    if (e.kind === 'identify') {
+      // identify events always have an inline context
+      ret.context = contextFilter.filter(e.context);
     } else {
-      ret.userKey = e.user.key;
-      delete ret['user'];
+      ret.contextKeys = getContextKeysFromEvent(e);
+      delete ret['context'];
     }
     if (e.kind === 'feature') {
       delete ret['trackEvents'];
@@ -65,6 +61,10 @@ function EventProcessor(
     return ret;
   }
 
+  function getContextKeysFromEvent(event) {
+    return getContextKeys(event.context, logger);
+  }
+
   function addToOutbox(event) {
     if (queue.length < eventCapacity) {
       queue.push(event);
@@ -107,7 +107,7 @@ function EventProcessor(
     }
     if (addDebugEvent) {
       const debugEvent = utils.extend({}, event, { kind: 'debug' });
-      debugEvent.user = userFilter.filterUser(debugEvent.user);
+      debugEvent.context = contextFilter.filter(debugEvent.context);
       delete debugEvent['trackEvents'];
       delete debugEvent['debugEventsUntilDate'];
       addToOutbox(debugEvent);
@@ -136,7 +136,8 @@ function EventProcessor(
     }
     queue = [];
     logger.debug(messages.debugPostingEvents(eventsToSend.length));
-    return eventSender.sendEvents(eventsToSend, mainEventsUrl).then(responseInfo => {
+    return eventSender.sendEvents(eventsToSend, mainEventsUrl).then(responses => {
+      const responseInfo = responses && responses[0];
       if (responseInfo) {
         if (responseInfo.serverTime) {
           lastKnownPastTime = responseInfo.serverTime;

src/EventSender.js

@@ -31,7 +31,7 @@ function EventSender(platform, environmentId, options) {
       const headers = isDiagnostic
         ? baseHeaders
         : utils.extend({}, baseHeaders, {
-            'X-LaunchDarkly-Event-Schema': '3',
+            'X-LaunchDarkly-Event-Schema': '4',
             'X-LaunchDarkly-Payload-ID': payloadId,
           });
       return platform
@@ -73,7 +73,7 @@ function EventSender(platform, environmentId, options) {
       // no need to break up events into chunks if we can send a POST
       chunks = [events];
     } else {
-      chunks = utils.chunkUserEventsForUrl(MAX_URL_LENGTH - url.length, events);
+      chunks = utils.chunkEventsForUrl(MAX_URL_LENGTH - url.length, events);
     }
     const results = [];
     for (let i = 0; i < chunks.length; i++) {