@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/storage/ImpressionsCache/InMemory.js

@@ -0,0 +1,71 @@
+/**
+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.
+**/
+var ImpressionsCacheInMemory = /*#__PURE__*/function () {
+  function ImpressionsCacheInMemory() {
+    this.queue = [];
+  }
+  /**
+   * Get collected data
+   */
+
+
+  var _proto = ImpressionsCacheInMemory.prototype;
+
+  _proto.state = function state() {
+    return this.queue;
+  }
+  /**
+   * Store objects in sequential order
+   */
+  ;
+
+  _proto.track = function track(data) {
+    var _this$queue;
+
+    (_this$queue = this.queue).push.apply(_this$queue, data);
+
+    return this;
+  }
+  /**
+   * Recycle the collector queue
+   */
+  ;
+
+  _proto.clear = function clear() {
+    this.queue.length = 0;
+    return this;
+  }
+  /**
+   * Hook JSON.stringify to expose the state of the counters
+   */
+  ;
+
+  _proto.toJSON = function toJSON() {
+    return this.queue;
+  }
+  /**
+   * Check if the is data changed from the defaults
+   */
+  ;
+
+  _proto.isEmpty = function isEmpty() {
+    return this.queue.length === 0;
+  };
+
+  return ImpressionsCacheInMemory;
+}();
+
+export default ImpressionsCacheInMemory;

package/es/storage/ImpressionsCache/InRedis.js

@@ -0,0 +1,73 @@
+/**
+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.
+**/
+var ImpressionsCacheInRedis = /*#__PURE__*/function () {
+  function ImpressionsCacheInRedis(keys, redis, meta) {
+    this.keys = keys;
+    this.redis = redis;
+    this.meta = meta;
+  }
+
+  var _proto = ImpressionsCacheInRedis.prototype;
+
+  _proto.track = function track(impressions) {
+    var _this = this;
+
+    return this.redis.rpush(this.keys.buildImpressionsKey(), this.toJSON(impressions)).then(function (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);
+      }
+    });
+  };
+
+  _proto.toJSON = function toJSON(impressions) {
+    var _this2 = this;
+
+    return impressions.map(function (impression) {
+      var keyName = impression.keyName,
+          bucketingKey = impression.bucketingKey,
+          feature = impression.feature,
+          treatment = impression.treatment,
+          label = impression.label,
+          time = impression.time,
+          changeNumber = impression.changeNumber;
+      return JSON.stringify({
+        m: _this2.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.
+   */
+  ;
+
+  _proto.isEmpty = function isEmpty() {
+    return true;
+  };
+
+  return ImpressionsCacheInRedis;
+}();
+
+export default ImpressionsCacheInRedis;

package/es/storage/Keys.js

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

package/es/storage/KeysLocalStorage.js

@@ -0,0 +1,58 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import { startsWith } from '../utils/lang';
+import KeyBuilder from './Keys';
+import { matching } from '../utils/key/factory';
+
+var KeyBuilderForLocalStorage = /*#__PURE__*/function (_KeyBuilder) {
+  _inheritsLoose(KeyBuilderForLocalStorage, _KeyBuilder);
+
+  function KeyBuilderForLocalStorage(settings) {
+    var _this;
+
+    _this = _KeyBuilder.call(this, settings) || this;
+    _this.regexSplitCacheKey = new RegExp("^" + _this.settings.storage.prefix + "\\.(splits?|trafficType)\\.");
+    return _this;
+  }
+
+  var _proto = KeyBuilderForLocalStorage.prototype;
+
+  _proto.buildSegmentNameKey = function buildSegmentNameKey(segmentName) {
+    return this.settings.storage.prefix + "." + matching(this.settings.core.key) + ".segment." + segmentName;
+  };
+
+  _proto.extractSegmentName = function extractSegmentName(builtSegmentKeyName) {
+    var prefix = this.settings.storage.prefix + "." + matching(this.settings.core.key) + ".segment.";
+    if (startsWith(builtSegmentKeyName, prefix)) return builtSegmentKeyName.substr(prefix.length);
+  };
+
+  _proto.buildSplitsWithSegmentCountKey = function buildSplitsWithSegmentCountKey() {
+    return this.settings.storage.prefix + ".splits.usingSegments";
+  };
+
+  _proto.buildLastUpdatedKey = function buildLastUpdatedKey() {
+    return this.settings.storage.prefix + ".splits.lastUpdated";
+  };
+
+  _proto.isSplitCacheKey = function isSplitCacheKey(key) {
+    return this.regexSplitCacheKey.test(key);
+  };
+
+  _proto.buildSplitsFilterQueryKey = function 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
+  ;
+
+  _proto.buildOldSegmentNameKey = function 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
+  ;
+
+  _proto.extractOldSegmentKey = function extractOldSegmentKey(maybeOldKey) {
+    var prefix = matching(this.settings.core.key) + "." + this.settings.storage.prefix + ".segment.";
+    if (startsWith(maybeOldKey, prefix)) return maybeOldKey.substr(prefix.length);
+  };
+
+  return KeyBuilderForLocalStorage;
+}(KeyBuilder);
+
+export default KeyBuilderForLocalStorage;

package/es/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';
+
+var LatencyCacheInMemory = /*#__PURE__*/function () {
+  function LatencyCacheInMemory() {
+    this.clear();
+  }
+
+  var _proto = LatencyCacheInMemory.prototype;
+
+  _proto.clear = function clear() {
+    this.counters = {};
+    return this;
+  };
+
+  _proto.state = function state() {
+    return this.counters;
+  };
+
+  _proto.track = function 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;
+  };
+
+  _proto.isEmpty = function isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.counters;
+  };
+
+  return LatencyCacheInMemory;
+}();
+
+export default LatencyCacheInMemory;

package/es/storage/LatencyCache/InRedis.js

@@ -0,0 +1,44 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+/**
+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';
+
+var LatencyCacheInRedis = /*#__PURE__*/function (_BaseMetricsAsyncCach) {
+  _inheritsLoose(LatencyCacheInRedis, _BaseMetricsAsyncCach);
+
+  function LatencyCacheInRedis(keys, redis) {
+    var _this;
+
+    _this = _BaseMetricsAsyncCach.call(this) || this;
+    _this.keys = keys;
+    _this.redis = redis;
+    return _this;
+  }
+
+  var _proto = LatencyCacheInRedis.prototype;
+
+  _proto.track = function track(metricName, latency) {
+    var bucketNumber = findIndex(latency);
+    return this.redis.incr(this.keys.buildLatencyKey(metricName, bucketNumber)).catch(function () {// noop, for telemetry metrics there's no need to throw.
+    });
+  };
+
+  return LatencyCacheInRedis;
+}(BaseMetricsAsyncCache);
+
+export default LatencyCacheInRedis;

package/es/storage/LatencyCache/findIndex.js

@@ -0,0 +1,2 @@
+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/es/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/es/storage/RedisAdapter.js

@@ -0,0 +1,198 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+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';
+var log = LogFactory('splitio-storage:redis-adapter'); // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
+
+var 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.
+
+var DEFAULT_OPTIONS = {
+  connectionTimeout: 10000,
+  operationTimeout: 5000
+}; // Library specifics.
+
+var 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.
+ */
+
+var RedisAdapter = /*#__PURE__*/function (_ioredis) {
+  _inheritsLoose(RedisAdapter, _ioredis);
+
+  function RedisAdapter(storageSettings) {
+    var _this;
+
+    var options = RedisAdapter._defineOptions(storageSettings); // Call the ioredis constructor
+
+
+    _this = _ioredis.call.apply(_ioredis, [this].concat(RedisAdapter._defineLibrarySettings(options))) || this;
+    _this._options = options;
+    _this._notReadyCommandsQueue = [];
+    _this._runningCommands = new _Set();
+
+    _this._listenToEvents();
+
+    _this._setTimeoutWrappers();
+
+    _this._setDisconnectWrapper();
+
+    return _this;
+  }
+
+  var _proto = RedisAdapter.prototype;
+
+  _proto._listenToEvents = function _listenToEvents() {
+    var _this2 = this;
+
+    this.once('ready', function () {
+      var commandsCount = _this2._notReadyCommandsQueue ? _this2._notReadyCommandsQueue.length : 0;
+      log.info("Redis connection established. Queued commands: " + commandsCount + ".");
+      commandsCount && _this2._notReadyCommandsQueue.forEach(function (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.
+
+      _this2._notReadyCommandsQueue = false;
+    });
+    this.once('close', function () {
+      log.info('Redis connection closed.');
+    });
+  };
+
+  _proto._setTimeoutWrappers = function _setTimeoutWrappers() {
+    var instance = this;
+    METHODS_TO_PROMISE_WRAP.forEach(function (method) {
+      var originalMethod = instance[method];
+
+      instance[method] = function () {
+        var params = arguments;
+
+        function commandWrapper() {
+          log.debug("Executing " + method + "."); // Return original method
+
+          var 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);
+
+            var cleanUpRunningCommandsCb = function cleanUpRunningCommandsCb(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(function (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(function (res, rej) {
+            instance._notReadyCommandsQueue.unshift({
+              resolve: res,
+              reject: rej,
+              command: commandWrapper,
+              name: method.toUpperCase()
+            });
+          });
+        } else {
+          return commandWrapper();
+        }
+      };
+    });
+  };
+
+  _proto._setDisconnectWrapper = function _setDisconnectWrapper() {
+    var instance = this;
+    var originalMethod = instance.disconnect;
+
+    instance.disconnect = function disconnect() {
+      var 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(function () {
+            log.debug('Pending commands finished successfully, disconnecting.');
+            originalMethod.apply(instance, params);
+          }).catch(function (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.
+   */
+  ;
+
+  RedisAdapter._defineLibrarySettings = function _defineLibrarySettings(options) {
+    var opts = merge({}, DEFAULT_LIBRARY_OPTIONS);
+    var 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.
+   */
+  ;
+
+  RedisAdapter._defineOptions = function _defineOptions(_ref) {
+    var connectionTimeout = _ref.connectionTimeout,
+        operationTimeout = _ref.operationTimeout,
+        url = _ref.url,
+        host = _ref.host,
+        port = _ref.port,
+        db = _ref.db,
+        pass = _ref.pass;
+    var parsedOptions = {
+      connectionTimeout: connectionTimeout,
+      operationTimeout: operationTimeout,
+      url: url,
+      host: host,
+      port: port,
+      db: db,
+      pass: pass
+    };
+    return merge({}, DEFAULT_OPTIONS, parsedOptions);
+  };
+
+  return RedisAdapter;
+}(ioredis);
+
+export { RedisAdapter as default };