launchdarkly-js-sdk-common 4.3.1 → 5.0.0-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the `launchdarkly-js-sdk-common` package will be documented in this file. Changes that affect the dependent SDKs such as `launchdarkly-js-client-sdk` should also be logged in those projects, in the next release that uses the updated version of this package. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [4.3.1] - 2022-10-17
+### Fixed:
+- Fixed an issue that prevented the `flag-used` inspector from being called.
+
 ## [4.3.0] - 2022-10-17
 ### Added:
 - Added support for `Inspectors` that can be used for collecting information for monitoring, analytics, and debugging.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "4.3.1",
+  "version": "5.0.0-alpha.1",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",
@@ -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",

package/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;

package/src/ContextFilter.js

@@ -0,0 +1,147 @@
+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) {
+      if (cloned._meta.secondary === null) {
+        delete cloned._meta.secondary;
+      }
+      if (cloned._meta.secondary !== undefined) {
+        cloned._meta.secondary = String(cloned._meta.secondary);
+      }
+      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)
+      );
+    }
+    if (user.secondary !== undefined && user.secondary !== null) {
+      filtered._meta = filtered._meta || {};
+      filtered._meta.secondary = String(user.secondary);
+    }
+
+    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;

package/src/EventProcessor.js

@@ -1,6 +1,6 @@
 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');
@@ -17,8 +17,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 +46,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 = getContextKeys(e);
+      delete ret['context'];
     }
     if (e.kind === 'feature') {
       delete ret['trackEvents'];
@@ -65,6 +60,28 @@ function EventProcessor(
     return ret;
   }
 
+  function getContextKeys(event) {
+    const keys = {};
+    const context = event.context;
+    if (context !== undefined) {
+      if (context.kind === undefined) {
+        keys.user = String(context.key);
+      } else if (context.kind === 'multi') {
+        Object.entries(context)
+          .filter(([key]) => key !== 'kind')
+          .forEach(([key, value]) => {
+            if (value !== undefined && value.key !== undefined) {
+              keys[key] = value.key;
+            }
+          });
+      } else {
+        keys[context.kind] = String(context.key);
+      }
+      return keys;
+    }
+    return undefined;
+  }
+
   function addToOutbox(event) {
     if (queue.length < eventCapacity) {
       queue.push(event);
@@ -107,7 +124,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);

package/src/EventSender.js

@@ -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++) {

package/src/Identity.js

@@ -1,23 +1,22 @@
 const utils = require('./utils');
 
-function Identity(initialUser, onChange) {
+function Identity(initialContext, onChange) {
   const ident = {};
-  let user;
+  let context;
 
-  ident.setUser = function(u) {
-    const previousUser = user && utils.clone(user);
-    user = utils.sanitizeUser(u);
-    if (user && onChange) {
-      onChange(utils.clone(user), previousUser);
+  ident.setContext = function(c) {
+    context = utils.sanitizeContext(c);
+    if (context && onChange) {
+      onChange(utils.clone(context));
     }
   };
 
-  ident.getUser = function() {
-    return user ? utils.clone(user) : null;
+  ident.getContext = function() {
+    return context ? utils.clone(context) : null;
   };
 
-  if (initialUser) {
-    ident.setUser(initialUser);
+  if (initialContext) {
+    ident.setContext(initialContext);
   }
 
   return ident;

package/src/PersistentFlagStore.js

@@ -5,9 +5,9 @@ function PersistentFlagStore(storage, environment, hash, ident) {
 
   function getFlagsKey() {
     let key = '';
-    const user = ident.getUser();
-    if (user) {
-      key = hash || utils.btoa(JSON.stringify(user));
+    const context = ident.getContext();
+    if (context) {
+      key = hash || utils.btoa(JSON.stringify(context));
     }
     return 'ld:' + environment + ':' + key;
   }

package/src/Requestor.js

@@ -79,9 +79,9 @@ function Requestor(platform, options, environment) {
     return fetchJSON(utils.appendUrlPath(baseUrl, path), null);
   };
 
-  // Requests the current state of all flags for the given user from LaunchDarkly. Returns a Promise
+  // Requests the current state of all flags for the given context from LaunchDarkly. Returns a Promise
   // which will resolve with the parsed JSON response, or will be rejected if the request failed.
-  requestor.fetchFlagSettings = function(user, hash) {
+  requestor.fetchFlagSettings = function(context, hash) {
     let data;
     let endpoint;
     let query = '';
@@ -89,9 +89,9 @@ function Requestor(platform, options, environment) {
 
     if (useReport) {
       endpoint = [baseUrl, '/sdk/evalx/', environment, '/user'].join('');
-      body = JSON.stringify(user);
+      body = JSON.stringify(context);
     } else {
-      data = utils.base64URLEncode(JSON.stringify(user));
+      data = utils.base64URLEncode(JSON.stringify(context));
       endpoint = [baseUrl, '/sdk/evalx/', environment, '/users/', data].join('');
     }
     if (hash) {

package/src/Stream.js

@@ -1,6 +1,7 @@
 const messages = require('./messages');
 const { appendUrlPath, base64URLEncode, objectHasOwnProperty } = require('./utils');
 const { getLDHeaders, transformHeaders } = require('./headers');
+const { isHttpErrorRecoverable } = require('./errors');
 
 // The underlying event source implementation is abstracted via the platform object, which should
 // have these three properties:
@@ -16,6 +17,8 @@ const { getLDHeaders, transformHeaders } = require('./headers');
 // interval between heartbeats from the LaunchDarkly streaming server. If this amount of time elapses
 // with no new data, the connection will be cycled.
 const streamReadTimeoutMillis = 5 * 60 * 1000; // 5 minutes
+const maxRetryDelay = 30 * 1000; // Maximum retry delay 30 seconds.
+const jitterRatio = 0.5; // Delay should be 50%-100% of calculated time.
 
 function Stream(platform, config, environment, diagnosticsAccumulator) {
   const baseUrl = config.streamUrl;
@@ -24,18 +27,34 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
   const evalUrlPrefix = appendUrlPath(baseUrl, '/eval/' + environment);
   const useReport = config.useReport;
   const withReasons = config.evaluationReasons;
-  const streamReconnectDelay = config.streamReconnectDelay;
+  const baseReconnectDelay = config.streamReconnectDelay;
   const headers = getLDHeaders(platform, config);
   let firstConnectionErrorLogged = false;
   let es = null;
   let reconnectTimeoutReference = null;
   let connectionAttemptStartTime;
-  let user = null;
+  let context = null;
   let hash = null;
   let handlers = null;
+  let retryCount = 0;
 
-  stream.connect = function(newUser, newHash, newHandlers) {
-    user = newUser;
+  function backoff() {
+    const delay = baseReconnectDelay * Math.pow(2, retryCount);
+    return delay > maxRetryDelay ? maxRetryDelay : delay;
+  }
+
+  function jitter(computedDelayMillis) {
+    return computedDelayMillis - Math.trunc(Math.random() * jitterRatio * computedDelayMillis);
+  }
+
+  function getNextRetryDelay() {
+    const delay = jitter(backoff());
+    retryCount += 1;
+    return delay;
+  }
+
+  stream.connect = function(newContext, newHash, newHandlers) {
+    context = newContext;
     hash = newHash;
     handlers = {};
     for (const key in newHandlers || {}) {
@@ -63,13 +82,31 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
   };
 
   function handleError(err) {
+    // The event source may not produce a status. But the LaunchDarkly
+    // polyfill can. If we can get the status, then we should stop retrying
+    // on certain error codes.
+    if (err.status && typeof err.status === 'number' && !isHttpErrorRecoverable(err.status)) {
+      // If we encounter an unrecoverable condition, then we do not want to
+      // retry anymore.
+      closeConnection();
+      logger.error(messages.unrecoverableStreamError(err));
+      // Ensure any pending retry attempts are not done.
+      if (reconnectTimeoutReference) {
+        clearTimeout(reconnectTimeoutReference);
+        reconnectTimeoutReference = null;
+      }
+      return;
+    }
+
+    const delay = getNextRetryDelay();
+
     if (!firstConnectionErrorLogged) {
-      logger.warn(messages.streamError(err, streamReconnectDelay));
+      logger.warn(messages.streamError(err, delay));
       firstConnectionErrorLogged = true;
     }
     logConnectionResult(false);
     closeConnection();
-    tryConnect(streamReconnectDelay);
+    tryConnect(delay);
   }
 
   function tryConnect(delay) {
@@ -96,14 +133,14 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
           url = evalUrlPrefix;
           options.method = 'REPORT';
           options.headers['Content-Type'] = 'application/json';
-          options.body = JSON.stringify(user);
+          options.body = JSON.stringify(context);
         } else {
           // if we can't do REPORT, fall back to the old ping-based stream
           url = appendUrlPath(baseUrl, '/ping/' + environment);
           query = '';
         }
       } else {
-        url = evalUrlPrefix + '/' + base64URLEncode(JSON.stringify(user));
+        url = evalUrlPrefix + '/' + base64URLEncode(JSON.stringify(context));
       }
       options.headers = transformHeaders(options.headers, config);
       if (withReasons) {
@@ -123,6 +160,11 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
       }
 
       es.onerror = handleError;
+
+      es.onopen = () => {
+        // If the connection is a success, then reset the retryCount.
+        retryCount = 0;
+      };
     }
   }