@splitsoftware/splitio 10.17.3-rc.3 → 10.17.3-rc.4

package/src/storage/ImpressionsCache/InRedis.js

@@ -0,0 +1,65 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+class ImpressionsCacheInRedis {
+  constructor(keys, redis, meta) {
+    this.keys = keys;
+    this.redis = redis;
+    this.meta = meta;
+  }
+
+  track(impressions) {
+    return this.redis.rpush(
+      this.keys.buildImpressionsKey(),
+      this.toJSON(impressions)
+    ).then(queuedCount => {
+      // If this is the creation of the key on Redis, set the expiration for it in 1hr.
+      if (queuedCount === impressions.length) {
+        return this.redis.expire(this.keys.buildImpressionsKey(), 3600);
+      }
+    });
+  }
+
+  toJSON(impressions) {
+    return impressions.map(impression => {
+      const {
+        keyName, bucketingKey, feature, treatment, label, time, changeNumber
+      } = impression;
+
+      return JSON.stringify({
+        m: this.meta,
+        i: {
+          k: keyName,
+          b: bucketingKey,
+          f: feature,
+          t: treatment,
+          r: label,
+          c: changeNumber,
+          m: time
+        }
+      });
+    });
+  }
+
+  /**
+   * We are returning true because the go syncronizer push the impressions from redis.
+   */
+  isEmpty() {
+    return true;
+  }
+}
+
+export default ImpressionsCacheInRedis;

package/src/storage/Keys.js

@@ -0,0 +1,122 @@
+import { startsWith } from '../utils/lang';
+
+const everythingAtTheEnd = /[^.]+$/;
+const everythingAfterCount = /count\.([^/]+)$/;
+const latencyMetricNameAndBucket = /latency\.([^/]+)\.bucket\.([0-9]+)$/;
+
+class KeyBuilder {
+  constructor(settings) {
+    this.settings = settings;
+  }
+
+  buildSplitKey(splitName) {
+    return `${this.settings.storage.prefix}.split.${splitName}`;
+  }
+
+  buildTrafficTypeKey(trafficType) {
+    return `${this.settings.storage.prefix}.trafficType.${trafficType}`;
+  }
+
+  buildSplitsTillKey() {
+    return `${this.settings.storage.prefix}.splits.till`;
+  }
+
+  buildSplitsReady() {
+    return `${this.settings.storage.prefix}.splits.ready`;
+  }
+
+  isSplitKey(key) {
+    return startsWith(key, `${this.settings.storage.prefix}.split.`);
+  }
+
+  buildSegmentNameKey(segmentName) {
+    return `${this.settings.storage.prefix}.segment.${segmentName}`;
+  }
+
+  buildSegmentTillKey(segmentName) {
+    return `${this.settings.storage.prefix}.segment.${segmentName}.till`;
+  }
+
+  buildRegisteredSegmentsKey() {
+    return `${this.settings.storage.prefix}.segments.registered`;
+  }
+
+  buildSegmentsReady() {
+    return `${this.settings.storage.prefix}.segments.ready`;
+  }
+
+  buildVersionablePrefix() {
+    return `${this.settings.storage.prefix}/${this.settings.version}/${this.settings.runtime.ip}`;
+  }
+
+  buildImpressionsKey() {
+    return `${this.settings.storage.prefix}.impressions`;
+  }
+
+  buildEventsKey() {
+    return `${this.settings.storage.prefix}.events`;
+  }
+
+  buildLatencyKeyPrefix() {
+    return `${this.buildVersionablePrefix()}/latency`;
+  }
+
+  buildLatencyKey(metricName, bucketNumber) {
+    return `${this.buildLatencyKeyPrefix()}.${metricName}.bucket.${bucketNumber}`;
+  }
+
+  buildCountKey(metricName) {
+    return `${this.buildVersionablePrefix()}/count.${metricName}`;
+  }
+
+  buildGaugeKey(metricName) {
+    return `${this.buildVersionablePrefix()}/gauge.${metricName}`;
+  }
+
+  searchPatternForCountKeys() {
+    return `${this.buildVersionablePrefix()}/count.*`;
+  }
+
+  searchPatternForSplitKeys() {
+    return `${this.settings.storage.prefix}.split.*`;
+  }
+
+  searchPatternForLatency() {
+    return `${this.buildLatencyKeyPrefix()}.*`;
+  }
+
+  extractKey(builtKey) {
+    const s = builtKey.match(everythingAtTheEnd);
+
+    if (s && s.length) {
+      return s[0];
+    } else {
+      throw new Error('Invalid latency key provided');
+    }
+  }
+
+  extractCounterName(counterKey) {
+    const m = counterKey.match(everythingAfterCount);
+
+    if (m && m.length) {
+      return m[1]; // everything after count
+    } else {
+      throw new Error('Invalid counter key provided');
+    }
+  }
+
+  extractLatencyMetricNameAndBucket(latencyKey) {
+    const parts = latencyKey.match(latencyMetricNameAndBucket);
+
+    if (parts && parts.length > 2) {
+      return {
+        metricName: parts[1],
+        bucketNumber: parts[2]
+      };
+    } else {
+      throw new Error('Invalid counter key provided');
+    }
+  }
+}
+
+export default KeyBuilder;

package/src/storage/KeysLocalStorage.js

@@ -0,0 +1,52 @@
+import { startsWith } from '../utils/lang';
+import KeyBuilder from './Keys';
+import { matching } from '../utils/key/factory';
+
+class KeyBuilderForLocalStorage extends KeyBuilder {
+
+  constructor(settings) {
+    super(settings);
+    this.regexSplitCacheKey = new RegExp(`^${this.settings.storage.prefix}\\.(splits?|trafficType)\\.`);
+  }
+
+  buildSegmentNameKey(segmentName) {
+    return `${this.settings.storage.prefix}.${matching(this.settings.core.key)}.segment.${segmentName}`;
+  }
+
+  extractSegmentName(builtSegmentKeyName) {
+    const prefix = `${this.settings.storage.prefix}.${matching(this.settings.core.key)}.segment.`;
+
+    if (startsWith(builtSegmentKeyName, prefix))
+      return builtSegmentKeyName.substr(prefix.length);
+  }
+
+  buildSplitsWithSegmentCountKey() {
+    return `${this.settings.storage.prefix}.splits.usingSegments`;
+  }
+
+  buildLastUpdatedKey() {
+    return `${this.settings.storage.prefix}.splits.lastUpdated`;
+  }
+
+  isSplitCacheKey(key) {
+    return this.regexSplitCacheKey.test(key);
+  }
+
+  buildSplitsFilterQueryKey() {
+    return `${this.settings.storage.prefix}.splits.filterQuery`;
+  }
+
+  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+  buildOldSegmentNameKey(segmentName) {
+    return `${matching(this.settings.core.key)}.${this.settings.storage.prefix}.segment.${segmentName}`;
+  }
+  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+  extractOldSegmentKey(maybeOldKey) {
+    const prefix = `${matching(this.settings.core.key)}.${this.settings.storage.prefix}.segment.`;
+
+    if (startsWith(maybeOldKey, prefix))
+      return maybeOldKey.substr(prefix.length);
+  }
+}
+
+export default KeyBuilderForLocalStorage;

package/src/storage/LatencyCache/InMemory.js

@@ -0,0 +1,56 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import findIndex from './findIndex';
+
+class LatencyCacheInMemory {
+  constructor() {
+    this.clear();
+  }
+
+  clear() {
+    this.counters = {};
+
+    return this;
+  }
+
+  state() {
+    return this.counters;
+  }
+
+  track(metricName, latency) {
+    // Initialize if needed
+    if (this.counters[metricName] === undefined) {
+      this.counters[metricName] = [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+      ];
+    }
+
+    // +1 based on the latency number
+    this.counters[metricName][findIndex(latency)]++;
+
+    return this;
+  }
+
+  isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  }
+
+  toJSON() {
+    return this.counters;
+  }
+}
+
+export default LatencyCacheInMemory;

package/src/storage/LatencyCache/InRedis.js

@@ -0,0 +1,35 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import findIndex from './findIndex';
+import BaseMetricsAsyncCache from '../BaseMetricsAsyncCache';
+
+class LatencyCacheInRedis extends BaseMetricsAsyncCache {
+  constructor(keys, redis) {
+    super();
+    this.keys = keys;
+    this.redis = redis;
+  }
+
+  track(metricName, latency) {
+    const bucketNumber = findIndex(latency);
+
+    return this.redis.incr(this.keys.buildLatencyKey(metricName, bucketNumber)).catch(() => {
+      // noop, for telemetry metrics there's no need to throw.
+    });
+  }
+}
+
+export default LatencyCacheInRedis;

package/src/storage/LatencyCache/findIndex.js

@@ -0,0 +1,7 @@
+import binarySearch from '../../utils/binarySearch';
+
+export default binarySearch.bind(null, [
+  1, 1.5, 2.25, 3.38, 5.06, 7.59, 11.39, 17.09, 25.63, 38.44, 57.67, 86.5,
+  129.75, 194.62, 291.93, 437.89, 656.84, 985.26, 1477.89, 2216.84, 3325.26,
+  4987.89, 7481.83
+]);

package/src/storage/Meta.js

@@ -0,0 +1,7 @@
+export default function MetaBuilder(settings) {
+  return {
+    s: settings.version,
+    i: settings.runtime.ip,
+    n: settings.runtime.hostname
+  };
+}

package/src/storage/RedisAdapter.js

@@ -0,0 +1,170 @@
+import ioredis from 'ioredis';
+import { merge, isString } from '../utils/lang';
+import { _Set, setToArray } from '../utils/lang/Sets';
+import thenable from '../utils/promise/thenable';
+import timeout from '../utils/promise/timeout';
+
+import LogFactory from '../utils/logger';
+const log = LogFactory('splitio-storage:redis-adapter');
+
+// If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
+const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget'];
+
+// Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
+const DEFAULT_OPTIONS = {
+  connectionTimeout: 10000,
+  operationTimeout: 5000
+};
+// Library specifics.
+const DEFAULT_LIBRARY_OPTIONS = {
+  enableOfflineQueue: false,
+  connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
+  lazyConnect: false
+};
+
+/**
+ * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ */
+export default class RedisAdapter extends ioredis {
+  constructor(storageSettings) {
+    const options = RedisAdapter._defineOptions(storageSettings);
+    // Call the ioredis constructor
+    super(...RedisAdapter._defineLibrarySettings(options));
+
+    this._options = options;
+    this._notReadyCommandsQueue = [];
+    this._runningCommands = new _Set();
+    this._listenToEvents();
+    this._setTimeoutWrappers();
+    this._setDisconnectWrapper();
+  }
+
+  _listenToEvents() {
+    this.once('ready', () => {
+      const commandsCount = this._notReadyCommandsQueue ? this._notReadyCommandsQueue.length : 0;
+      log.info(`Redis connection established. Queued commands: ${commandsCount}.`);
+      commandsCount && this._notReadyCommandsQueue.forEach(queued => {
+        log.info(`Executing queued ${queued.name} command.`);
+        queued.command().then(queued.resolve).catch(queued.reject);
+      });
+      // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
+      this._notReadyCommandsQueue = false;
+    });
+    this.once('close', () => {
+      log.info('Redis connection closed.');
+    });
+  }
+
+  _setTimeoutWrappers() {
+    const instance = this;
+
+    METHODS_TO_PROMISE_WRAP.forEach(method => {
+      const originalMethod = instance[method];
+
+      instance[method] = function() {
+        const params = arguments;
+
+        function commandWrapper() {
+          log.debug(`Executing ${method}.`);
+          // Return original method
+          const result = originalMethod.apply(instance, params);
+
+          if (thenable(result)) {
+            // For handling pending commands on disconnect, add to the set and remove once finished.
+            // On sync commands there's no need, only thenables.
+            instance._runningCommands.add(result);
+            const cleanUpRunningCommandsCb = function(res) {
+              instance._runningCommands.delete(result);
+              return res;
+            };
+            // Both success and error remove from queue.
+            result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
+
+            return timeout(instance._options.operationTimeout, result).catch(err => {
+              log.error(`${method} operation threw an error or exceeded configured timeout of ${instance._options.operationTimeout}ms. Message: ${err}`);
+              // Handling is not the adapter responsibility.
+              throw err;
+            });
+          }
+
+          return result;
+        }
+
+        if (instance._notReadyCommandsQueue) {
+          return new Promise((res, rej) => {
+            instance._notReadyCommandsQueue.unshift({
+              resolve: res,
+              reject: rej,
+              command: commandWrapper,
+              name: method.toUpperCase()
+            });
+          });
+        } else {
+          return commandWrapper();
+        }
+      };
+    });
+  }
+
+  _setDisconnectWrapper() {
+    const instance = this;
+    const originalMethod = instance.disconnect;
+
+    instance.disconnect = function disconnect() {
+      const params = arguments;
+
+      setTimeout(function deferedDisconnect() {
+        if (instance._runningCommands.size > 0) {
+          log.info(`Attempting to disconnect but there are ${instance._runningCommands.size} commands still waiting for resolution. Defering disconnection until those finish.`);
+
+          Promise.all(setToArray(instance._runningCommands))
+            .then(() => {
+              log.debug('Pending commands finished successfully, disconnecting.');
+              originalMethod.apply(instance, params);
+            })
+            .catch(e => {
+              log.warn(`Pending commands finished with error: ${e}. Proceeding with disconnection.`);
+              originalMethod.apply(instance, params);
+            });
+        } else {
+          log.debug('No commands pending execution, disconnect.');
+          // Nothing pending, just proceed.
+          originalMethod.apply(instance, params);
+        }
+      }, 10);
+    };
+  }
+
+  /**
+   * Receives the options and returns an array of parameters for the ioredis constructor.
+   * Keeping both redis setup options for backwards compatibility.
+   */
+  static _defineLibrarySettings(options) {
+    const opts = merge({}, DEFAULT_LIBRARY_OPTIONS);
+    const result = [opts];
+
+    if (!isString(options.url)) {
+      merge(opts, { // If it's not the string URL, merge the params separately.
+        host: options.host,
+        port: options.port,
+        db: options.db,
+        password: options.pass
+      });
+    } else { // If it IS the string URL, that'll be the first param for ioredis.
+      result.unshift(options.url);
+    }
+
+    return result;
+  }
+
+  /**
+   * Parses the options into what we care about.
+   */
+  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }) {
+    const parsedOptions = {
+      connectionTimeout, operationTimeout, url, host, port, db, pass
+    };
+
+    return merge({}, DEFAULT_OPTIONS, parsedOptions);
+  }
+}

package/src/storage/SegmentCache/InLocalStorage/index.js

@@ -0,0 +1,140 @@
+import logFactory from '../../../utils/logger';
+const log = logFactory('splitio-storage:localstorage');
+
+const DEFINED = '1';
+
+class SegmentCacheInLocalStorage {
+
+  constructor(keys) {
+    this.keys = keys;
+    // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
+  }
+
+  addToSegment(segmentName/*, segmentKeys: Array<string>*/) {
+    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    try {
+      localStorage.setItem(segmentKey, DEFINED);
+      return true;
+    } catch (e) {
+      log.error(e);
+      return false;
+    }
+  }
+
+  removeFromSegment(segmentName/*, segmentKeys: Array<string>*/) {
+    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
+
+    try {
+      localStorage.removeItem(segmentKey);
+      return true;
+    } catch (e) {
+      log.error(e);
+      return false;
+    }
+  }
+
+  /**
+   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+   *
+   * @param {string[]} segmentNames list of segment names
+   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+   */
+  resetSegments(segmentNames) {
+    let isDiff = false;
+    let index;
+
+    // Scan current values from localStorage
+    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
+      let segmentName = this.keys.extractSegmentName(key);
+
+      if (segmentName) {
+        accum.push(segmentName);
+      } else {
+        // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+        segmentName = this.keys.extractOldSegmentKey(key);
+
+        if (segmentName) { // this was an old segment key, let's clean up.
+          const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
+          try {
+            // If the new format key is not there, create it.
+            if (!localStorage.getItem(newSegmentKey) && segmentNames.indexOf(segmentName) > -1) {
+              localStorage.setItem(newSegmentKey, DEFINED);
+              // we are migrating a segment, let's track it.
+              accum.push(segmentName);
+            }
+            localStorage.removeItem(key); // we migrated the current key, let's delete it.
+          } catch (e) {
+            log.error(e);
+          }
+        }
+      }
+
+      return accum;
+    }, []);
+
+    // Extreme fast => everything is empty
+    if (segmentNames.length === 0 && storedSegmentNames.length === segmentNames.length)
+      return isDiff;
+
+    // Quick path
+    if (storedSegmentNames.length !== segmentNames.length) {
+      isDiff = true;
+
+      storedSegmentNames.forEach(segmentName => this.removeFromSegment(segmentName));
+      segmentNames.forEach(segmentName => this.addToSegment(segmentName));
+    } else {
+      // Slowest path => we need to find at least 1 difference because
+      for (index = 0; index < segmentNames.length && storedSegmentNames.indexOf(segmentNames[index]) !== -1; index++) {
+        // TODO: why empty statement?
+      }
+
+      if (index < segmentNames.length) {
+        isDiff = true;
+
+        storedSegmentNames.forEach(segmentName => this.removeFromSegment(segmentName));
+        segmentNames.forEach(segmentName => this.addToSegment(segmentName));
+      }
+    }
+
+    return isDiff;
+  }
+
+  isInSegment(segmentName/*, key: string*/) {
+    return localStorage.getItem(this.keys.buildSegmentNameKey(segmentName)) === DEFINED;
+  }
+
+  setChangeNumber(/*segmentName: string, changeNumber: number*/) {
+    return true;
+  }
+
+  getChangeNumber(/*segmentName: string*/) {
+    return -1;
+  }
+
+  registerSegment(/*segment: string*/) {
+    return false;
+  }
+
+  registerSegments(/*segments: Iterable<string>*/) {
+    return false;
+  }
+
+  getRegisteredSegments() {
+    return [];
+  }
+
+  /**
+   * Removes list of segments from localStorage
+   * @NOTE this method is not being used at the moment
+   */
+  flush() {
+    log.info('Flushing MySegments data from localStorage');
+
+    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+    // We could optimize next sentence, since it implies iterating over all localStorage items
+    this.resetSegments([]);
+  }
+}
+
+export default SegmentCacheInLocalStorage;