launchdarkly-js-sdk-common 4.0.0 → 4.0.1

package/src/Stream.js

@@ -0,0 +1,154 @@
+const messages = require('./messages');
+const { base64URLEncode, getLDHeaders, transformHeaders, objectHasOwnProperty } = require('./utils');
+
+// The underlying event source implementation is abstracted via the platform object, which should
+// have these three properties:
+// eventSourceFactory(): a function that takes a URL and optional config object and returns an object
+//   with the same methods as the regular HTML5 EventSource object. The properties in the config
+//   object are those supported by the launchdarkly-eventsource package; browser EventSource
+//   implementations don't have any config options.
+// eventSourceIsActive(): a function that takes an EventSource-compatible object and returns true if
+//   it is in an active state (connected or connecting).
+// eventSourceAllowsReport: true if REPORT is supported.
+
+// The read timeout for the stream is a fixed value that is set to be slightly longer than the expected
+// 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
+
+function Stream(platform, config, environment, diagnosticsAccumulator) {
+  const baseUrl = config.streamUrl;
+  const logger = config.logger;
+  const stream = {};
+  const evalUrlPrefix = baseUrl + '/eval/' + environment;
+  const useReport = config.useReport;
+  const withReasons = config.evaluationReasons;
+  const streamReconnectDelay = config.streamReconnectDelay;
+  const headers = getLDHeaders(platform, config);
+  let firstConnectionErrorLogged = false;
+  let es = null;
+  let reconnectTimeoutReference = null;
+  let connectionAttemptStartTime;
+  let user = null;
+  let hash = null;
+  let handlers = null;
+
+  stream.connect = function(newUser, newHash, newHandlers) {
+    user = newUser;
+    hash = newHash;
+    handlers = {};
+    for (const key in newHandlers || {}) {
+      handlers[key] = function(e) {
+        // Reset the state for logging the first connection error so that the first
+        // connection error following a successful connection will once again be logged.
+        // We will decorate *all* handlers to do this to keep this abstraction agnostic
+        // for different stream implementations.
+        firstConnectionErrorLogged = false;
+        logConnectionResult(true);
+        newHandlers[key] && newHandlers[key](e);
+      };
+    }
+    tryConnect();
+  };
+
+  stream.disconnect = function() {
+    clearTimeout(reconnectTimeoutReference);
+    reconnectTimeoutReference = null;
+    closeConnection();
+  };
+
+  stream.isConnected = function() {
+    return !!(es && platform.eventSourceIsActive && platform.eventSourceIsActive(es));
+  };
+
+  function handleError(err) {
+    if (!firstConnectionErrorLogged) {
+      logger.warn(messages.streamError(err, streamReconnectDelay));
+      firstConnectionErrorLogged = true;
+    }
+    logConnectionResult(false);
+    closeConnection();
+    tryConnect(streamReconnectDelay);
+  }
+
+  function tryConnect(delay) {
+    if (!reconnectTimeoutReference) {
+      if (delay) {
+        reconnectTimeoutReference = setTimeout(openConnection, delay);
+      } else {
+        openConnection();
+      }
+    }
+  }
+
+  function openConnection() {
+    reconnectTimeoutReference = null;
+    let url;
+    let query = '';
+    const options = { headers, readTimeoutMillis: streamReadTimeoutMillis };
+    if (platform.eventSourceFactory) {
+      if (hash !== null && hash !== undefined) {
+        query = 'h=' + hash;
+      }
+      if (useReport) {
+        if (platform.eventSourceAllowsReport) {
+          url = evalUrlPrefix;
+          options.method = 'REPORT';
+          options.headers['Content-Type'] = 'application/json';
+          options.body = JSON.stringify(user);
+        } else {
+          // if we can't do REPORT, fall back to the old ping-based stream
+          url = baseUrl + '/ping/' + environment;
+          query = '';
+        }
+      } else {
+        url = evalUrlPrefix + '/' + base64URLEncode(JSON.stringify(user));
+      }
+      options.headers = transformHeaders(options.headers, config);
+      if (withReasons) {
+        query = query + (query ? '&' : '') + 'withReasons=true';
+      }
+      url = url + (query ? '?' : '') + query;
+
+      closeConnection();
+      logger.info(messages.streamConnecting(url));
+      logConnectionStarted();
+
+      es = platform.eventSourceFactory(url, options);
+      for (const key in handlers) {
+        if (objectHasOwnProperty(handlers, key)) {
+          es.addEventListener(key, handlers[key]);
+        }
+      }
+
+      es.onerror = handleError;
+    }
+  }
+
+  function closeConnection() {
+    if (es) {
+      logger.info(messages.streamClosing());
+      es.close();
+      es = null;
+    }
+  }
+
+  function logConnectionStarted() {
+    connectionAttemptStartTime = new Date().getTime();
+  }
+
+  function logConnectionResult(success) {
+    if (connectionAttemptStartTime && diagnosticsAccumulator) {
+      diagnosticsAccumulator.recordStreamInit(
+        connectionAttemptStartTime,
+        !success,
+        new Date().getTime() - connectionAttemptStartTime
+      );
+    }
+    connectionAttemptStartTime = null;
+  }
+
+  return stream;
+}
+
+module.exports = Stream;

package/src/UserFilter.js

@@ -0,0 +1,75 @@
+const utils = require('./utils');
+
+/**
+ * The UserFilter object transforms user objects into objects suitable to be sent as JSON to
+ * the server, hiding any private user attributes.
+ *
+ * @param {Object} the LaunchDarkly client configuration object
+ **/
+function UserFilter(config) {
+  const filter = {};
+  const allAttributesPrivate = config.allAttributesPrivate;
+  const privateAttributeNames = config.privateAttributeNames || [];
+  const ignoreAttrs = { key: true, custom: true, anonymous: true };
+  const allowedTopLevelAttrs = {
+    key: true,
+    secondary: true,
+    ip: true,
+    country: true,
+    email: true,
+    firstName: true,
+    lastName: true,
+    avatar: true,
+    name: true,
+    anonymous: true,
+    custom: true,
+  };
+
+  filter.filterUser = function(user) {
+    if (!user) {
+      return null;
+    }
+    const userPrivateAttrs = user.privateAttributeNames || [];
+
+    const isPrivateAttr = function(name) {
+      return (
+        !ignoreAttrs[name] &&
+        (allAttributesPrivate || userPrivateAttrs.indexOf(name) !== -1 || privateAttributeNames.indexOf(name) !== -1)
+      );
+    };
+    const filterAttrs = function(props, isAttributeAllowed) {
+      return Object.keys(props).reduce(
+        (acc, name) => {
+          const ret = acc;
+          if (isAttributeAllowed(name)) {
+            if (isPrivateAttr(name)) {
+              // add to hidden list
+              ret[1][name] = true;
+            } else {
+              ret[0][name] = props[name];
+            }
+          }
+          return ret;
+        },
+        [{}, {}]
+      );
+    };
+    const result = filterAttrs(user, key => allowedTopLevelAttrs[key]);
+    const filteredProps = result[0];
+    let removedAttrs = result[1];
+    if (user.custom) {
+      const customResult = filterAttrs(user.custom, () => true);
+      filteredProps.custom = customResult[0];
+      removedAttrs = utils.extend({}, removedAttrs, customResult[1]);
+    }
+    const removedAttrNames = Object.keys(removedAttrs);
+    if (removedAttrNames.length) {
+      removedAttrNames.sort();
+      filteredProps.privateAttrs = removedAttrNames;
+    }
+    return filteredProps;
+  };
+  return filter;
+}
+
+module.exports = UserFilter;

package/src/UserValidator.js

@@ -0,0 +1,56 @@
+const { v1: uuidv1 } = require('uuid');
+
+const errors = require('./errors');
+const messages = require('./messages');
+const utils = require('./utils');
+
+// Transforms the user object if necessary to make sure it has a valid key.
+// 1. If a key is present, but is not a string, change it to a string.
+// 2. If no key is present, and "anonymous" is true, use a UUID as a key. This is cached in local
+// storage if possible.
+// 3. If there is no key (or no user object), return an error.
+
+const ldUserIdKey = 'ld:$anonUserId';
+
+function UserValidator(persistentStorage) {
+  function getCachedUserId() {
+    return persistentStorage.get(ldUserIdKey);
+  }
+
+  function setCachedUserId(id) {
+    return persistentStorage.set(ldUserIdKey, id);
+  }
+
+  const ret = {};
+
+  // Validates the user, returning a Promise that resolves to the validated user, or rejects if there is an error.
+  ret.validateUser = user => {
+    if (!user) {
+      return Promise.reject(new errors.LDInvalidUserError(messages.userNotSpecified()));
+    }
+
+    const userOut = utils.clone(user);
+    if (userOut.key !== null && userOut.key !== undefined) {
+      userOut.key = userOut.key.toString();
+      return Promise.resolve(userOut);
+    }
+    if (userOut.anonymous) {
+      return getCachedUserId().then(cachedId => {
+        if (cachedId) {
+          userOut.key = cachedId;
+          return userOut;
+        } else {
+          const id = uuidv1();
+          userOut.key = id;
+          return setCachedUserId(id).then(() => userOut);
+        }
+      });
+    } else {
+      return Promise.reject(new errors.LDInvalidUserError(messages.invalidUser()));
+    }
+  };
+
+  return ret;
+}
+
+module.exports = UserValidator;

package/src/__tests__/.eslintrc.yaml

@@ -0,0 +1,7 @@
+---
+globals:
+  VERSION: true
+  sinon: true
+  expect: true
+  requestor: true
+  client: true