@splitsoftware/splitio 10.17.3 → 10.17.4-rc.2

package/lib/storage/SplitCache/InMemory.js

@@ -1,172 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _lang = require("../../utils/lang");
-
-var _usesSegments = _interopRequireDefault(require("../../utils/splits/usesSegments"));
-
-var _killLocally = _interopRequireDefault(require("./killLocally"));
-
-var SplitCacheInMemory = /*#__PURE__*/function () {
-  function SplitCacheInMemory() {
-    this.flush();
-  }
-
-  var _proto = SplitCacheInMemory.prototype;
-
-  _proto.addSplit = function addSplit(splitName, split) {
-    var splitFromMemory = this.getSplit(splitName);
-
-    if (splitFromMemory) {
-      // We had this Split already
-      var previousSplit = JSON.parse(splitFromMemory);
-
-      if (previousSplit.trafficTypeName) {
-        var previousTtName = previousSplit.trafficTypeName;
-        this.ttCache[previousTtName]--;
-        if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
-      }
-
-      if ((0, _usesSegments.default)(previousSplit.conditions)) {
-        // Substract from segments count for the previous version of this Split.
-        this.splitsWithSegmentsCount--;
-      }
-    }
-
-    var parsedSplit = JSON.parse(split);
-
-    if (parsedSplit) {
-      // Store the Split.
-      this.splitCache[splitName] = split; // Update TT cache
-
-      var ttName = parsedSplit.trafficTypeName;
-
-      if (ttName) {
-        // safeguard
-        if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
-        this.ttCache[ttName]++;
-      } // Add to segments count for the new version of the Split
-
-
-      if ((0, _usesSegments.default)(parsedSplit.conditions)) this.splitsWithSegmentsCount++;
-      return true;
-    } else {
-      return false;
-    }
-  };
-
-  _proto.addSplits = function addSplits(entries) {
-    var _this = this;
-
-    var results = [];
-    entries.forEach(function (keyValuePair) {
-      results.push(_this.addSplit(keyValuePair[0], keyValuePair[1]));
-    });
-    return results;
-  };
-
-  _proto.removeSplit = function removeSplit(splitName) {
-    var split = this.getSplit(splitName);
-
-    if (split) {
-      // Delete the Split
-      delete this.splitCache[splitName];
-      var parsedSplit = JSON.parse(split);
-      var ttName = parsedSplit.trafficTypeName;
-
-      if (ttName) {
-        // safeguard
-        this.ttCache[ttName]--; // Update tt cache
-
-        if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      } // Update the segments count.
-
-
-      if ((0, _usesSegments.default)(parsedSplit.conditions)) this.splitsWithSegmentsCount--;
-      return 1;
-    } else {
-      return 0;
-    }
-  };
-
-  _proto.removeSplits = function removeSplits(splitNames) {
-    var _this2 = this;
-
-    splitNames.forEach(function (n) {
-      return _this2.removeSplit(n);
-    });
-    return splitNames.length;
-  };
-
-  _proto.getSplit = function getSplit(splitName) {
-    return this.splitCache[splitName];
-  };
-
-  _proto.setChangeNumber = function setChangeNumber(changeNumber) {
-    this.changeNumber = changeNumber;
-    return true;
-  };
-
-  _proto.getChangeNumber = function getChangeNumber() {
-    return this.changeNumber;
-  };
-
-  _proto.getAll = function getAll() {
-    var _this3 = this;
-
-    return this.getKeys().map(function (key) {
-      return _this3.splitCache[key];
-    });
-  };
-
-  _proto.getKeys = function getKeys() {
-    return Object.keys(this.splitCache);
-  };
-
-  _proto.trafficTypeExists = function trafficTypeExists(trafficType) {
-    return (0, _lang.numberIsFinite)(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-  };
-
-  _proto.usesSegments = function usesSegments() {
-    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
-  };
-
-  _proto.flush = function flush() {
-    this.splitCache = {};
-    this.ttCache = {};
-    this.changeNumber = -1;
-    this.splitsWithSegmentsCount = 0;
-  }
-  /**
-   * Fetches multiple splits definitions.
-   */
-  ;
-
-  _proto.fetchMany = function fetchMany(splitNames) {
-    var _this4 = this;
-
-    var splits = {};
-    splitNames.forEach(function (splitName) {
-      splits[splitName] = _this4.splitCache[splitName] || null;
-    });
-    return splits;
-  }
-  /**
-   * Check if the splits information is already stored in cache. In memory there is no cache to check.
-   */
-  ;
-
-  _proto.checkCache = function checkCache() {
-    return false;
-  };
-
-  return SplitCacheInMemory;
-}();
-
-SplitCacheInMemory.prototype.killLocally = _killLocally.default;
-var _default = SplitCacheInMemory;
-exports.default = _default;

package/lib/storage/SplitCache/InRedis.js

@@ -1,224 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _lang = require("../../utils/lang");
-
-var _logger = _interopRequireDefault(require("../../utils/logger"));
-
-var log = (0, _logger.default)('splitio-storage:redis');
-/**
- * Discard errors for an answer of multiple operations.
- */
-
-var processPipelineAnswer = function processPipelineAnswer(results) {
-  return results.reduce(function (accum, errValuePair) {
-    if (errValuePair[0] === null) accum.push(errValuePair[1]);
-    return accum;
-  }, []);
-};
-
-var SplitCacheInRedis = /*#__PURE__*/function () {
-  function SplitCacheInRedis(keys, redis) {
-    var _this = this;
-
-    this.redis = redis;
-    this.keys = keys;
-    this.redisError = false;
-    this.redis.on('error', function (e) {
-      _this.redisError = e;
-    });
-    this.redis.on('connect', function () {
-      _this.redisError = false;
-    });
-  }
-
-  var _proto = SplitCacheInRedis.prototype;
-
-  _proto.addSplit = function addSplit(splitName, split) {
-    return this.redis.set(this.keys.buildSplitKey(splitName), split).then(function (status) {
-      return status === 'OK';
-    });
-  };
-
-  _proto.addSplits = function addSplits(entries) {
-    var _this2 = this;
-
-    if (entries.length) {
-      var cmds = entries.map(function (keyValuePair) {
-        return ['set', _this2.keys.buildSplitKey(keyValuePair[0]), keyValuePair[1]];
-      });
-      return this.redis.pipeline(cmds).exec().then(processPipelineAnswer).then(function (answers) {
-        return answers.map(function (status) {
-          return status === 'OK';
-        });
-      });
-    } else {
-      return [true];
-    }
-  }
-  /**
-   * Remove a given split from Redis. Returns the number of deleted keys.
-   */
-  ;
-
-  _proto.removeSplit = function removeSplit(splitName) {
-    return this.redis.del(this.keys.buildSplitKey(splitName));
-  }
-  /**
-   * Bulk delete of splits from Redis. Returns the number of deleted keys.
-   */
-  ;
-
-  _proto.removeSplits = function removeSplits(names) {
-    var _this3 = this;
-
-    if (names.length) {
-      return this.redis.del(names.map(function (n) {
-        return _this3.keys.buildSplitKey(n);
-      }));
-    } else {
-      return Promise.resolve(0);
-    }
-  }
-  /**
-   * Get split definition or null if it's not defined.
-   */
-  ;
-
-  _proto.getSplit = function getSplit(splitName) {
-    if (this.redisError) {
-      log.error(this.redisError);
-      throw this.redisError;
-    }
-
-    return this.redis.get(this.keys.buildSplitKey(splitName));
-  }
-  /**
-   * Set till number.
-   *
-   * @TODO pending error handling
-   */
-  ;
-
-  _proto.setChangeNumber = function setChangeNumber(changeNumber) {
-    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(function (status) {
-      return status === 'OK';
-    });
-  }
-  /**
-   * Get till number or null if it's not defined.
-   *
-   * @TODO pending error handling
-   */
-  ;
-
-  _proto.getChangeNumber = function getChangeNumber() {
-    return this.redis.get(this.keys.buildSplitsTillKey()).then(function (value) {
-      var i = parseInt(value, 10);
-      return (0, _lang.numberIsNaN)(i) ? -1 : i;
-    });
-  }
-  /**
-   * @TODO we need to benchmark which is the maximun number of commands we could
-   *       pipeline without kill redis performance.
-   */
-  ;
-
-  _proto.getAll = function getAll() {
-    var _this4 = this;
-
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) {
-      return _this4.redis.pipeline(listOfKeys.map(function (k) {
-        return ['get', k];
-      })).exec();
-    }).then(processPipelineAnswer);
-  };
-
-  _proto.getKeys = function getKeys() {
-    var _this5 = this;
-
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) {
-      return listOfKeys.map(_this5.keys.extractKey);
-    });
-  };
-
-  _proto.trafficTypeExists = function trafficTypeExists(trafficType) {
-    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-    return this.redis.get(this.keys.buildTrafficTypeKey(trafficType)).then(function (ttCount) {
-      ttCount = parseInt(ttCount, 10);
-
-      if (!(0, _lang.numberIsFinite)(ttCount) || ttCount < 0) {
-        log.info("Could not validate traffic type existance of " + trafficType + " due to data corruption of some sorts.");
-        return false;
-      }
-
-      return ttCount > 0;
-    }).catch(function (e) {
-      log.error("Could not validate traffic type existance of " + trafficType + " due to an error: " + e + "."); // If there is an error, bypass the validation so the event can get tracked.
-
-      return true;
-    });
-  } // noop, just keeping the interface. This is used by client-side implementations only.
-  ;
-
-  _proto.usesSegments = function usesSegments() {
-    return true;
-  }
-  /**
-   * Delete everything in the current database.
-   *
-   * @NOTE documentation says it never fails.
-   */
-  ;
-
-  _proto.flush = function flush() {
-    return this.redis.flushdb().then(function (status) {
-      return status === 'OK';
-    });
-  }
-  /**
-   * Fetches multiple splits definitions.
-   */
-  ;
-
-  _proto.fetchMany = function fetchMany(splitNames) {
-    var _this6 = this,
-        _this$redis;
-
-    if (this.redisError) {
-      log.error(this.redisError);
-      throw this.redisError;
-    }
-
-    var splits = {};
-    var keys = splitNames.map(function (splitName) {
-      return _this6.keys.buildSplitKey(splitName);
-    });
-    return (_this$redis = this.redis).mget.apply(_this$redis, keys).then(function (splitDefinitions) {
-      splitNames.forEach(function (splitName, idx) {
-        splits[splitName] = splitDefinitions[idx];
-      });
-      return Promise.resolve(splits);
-    }).catch(function (e) {
-      log.error("Could not grab splits due to an error: " + e + ".");
-      return Promise.reject(e);
-    });
-  }
-  /**
-   * Check if the splits information is already stored in cache. Redis would actually be the cache.
-   */
-  ;
-
-  _proto.checkCache = function checkCache() {
-    return false;
-  };
-
-  return SplitCacheInRedis;
-}();
-
-var _default = SplitCacheInRedis;
-exports.default = _default;

package/lib/storage/SplitCache/killLocally.js

@@ -1,42 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = killLocally;
-
-var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
-
-/**
- * Kill `splitName` at `this` split storage, setting `defaultTreatment` and `changeNumber`,
- * only if the split exists and its `changeNumber` is older than the given one.
- * Used for SPLIT_KILL push notifications.
- *
- * @param {string} splitName
- * @param {string} defaultTreatment
- * @param {number} changeNumber
- * @returns {Promise} a promise that is resolved once the split kill is performed.
- * The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated, for instance,
- * if the `changeNumber` is old, if the `splitName` is not found, or if the storage fails to apply the update.
- */
-function killLocally(splitName, defaultTreatment, changeNumber) {
-  var _this = this;
-
-  var split = this.getSplit(splitName);
-  var splitPromise = (0, _thenable.default)(split) ? split : Promise.resolve(split);
-  return splitPromise.then(function (split) {
-    if (split) {
-      var parsedSplit = JSON.parse(split);
-
-      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-        parsedSplit.killed = true;
-        parsedSplit.defaultTreatment = defaultTreatment;
-        parsedSplit.changeNumber = changeNumber;
-        var newSplit = JSON.stringify(parsedSplit);
-        return _this.addSplit(splitName, newSplit);
-      }
-    }
-
-    return false;
-  });
-}

package/lib/storage/browser.js

@@ -1,122 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = void 0;
-
-var _InMemory = _interopRequireDefault(require("./SplitCache/InMemory"));
-
-var _InLocalStorage = _interopRequireDefault(require("./SplitCache/InLocalStorage"));
-
-var _InMemory2 = _interopRequireDefault(require("./SegmentCache/InMemory"));
-
-var _InLocalStorage2 = _interopRequireDefault(require("./SegmentCache/InLocalStorage"));
-
-var _InMemory3 = _interopRequireDefault(require("./ImpressionsCache/InMemory"));
-
-var _InMemory4 = _interopRequireDefault(require("./LatencyCache/InMemory"));
-
-var _InMemory5 = _interopRequireDefault(require("./CountCache/InMemory"));
-
-var _InMemory6 = _interopRequireDefault(require("./EventsCache/InMemory"));
-
-var _Keys = _interopRequireDefault(require("./Keys"));
-
-var _KeysLocalStorage = _interopRequireDefault(require("./KeysLocalStorage"));
-
-var _constants = require("../utils/constants");
-
-// This value might be eventually set via a config parameter
-var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-
-exports.DEFAULT_CACHE_EXPIRATION_IN_MILLIS = DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-
-var BrowserStorageFactory = function BrowserStorageFactory(context) {
-  var settings = context.get(context.constants.SETTINGS);
-  var storage = settings.storage;
-
-  switch (storage.type) {
-    case _constants.STORAGE_MEMORY:
-      {
-        var keys = new _Keys.default(settings);
-        return {
-          splits: new _InMemory.default(),
-          segments: new _InMemory2.default(keys),
-          impressions: new _InMemory3.default(),
-          metrics: new _InMemory4.default(),
-          count: new _InMemory5.default(),
-          events: new _InMemory6.default(context),
-          // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-          shared: function shared(settings) {
-            var childKeyBuilder = new _Keys.default(settings);
-            return {
-              splits: this.splits,
-              segments: new _InMemory2.default(childKeyBuilder),
-              impressions: this.impressions,
-              metrics: this.metrics,
-              count: this.count,
-              events: this.events,
-              destroy: function destroy() {
-                this.splits = new _InMemory.default();
-                this.segments.flush();
-              }
-            };
-          },
-          destroy: function destroy() {
-            this.splits.flush();
-            this.segments.flush();
-            this.impressions.clear();
-            this.metrics.clear();
-            this.count.clear();
-            this.events.clear();
-          }
-        };
-      }
-
-    case _constants.STORAGE_LOCALSTORAGE:
-      {
-        var _keys = new _KeysLocalStorage.default(settings);
-
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        return {
-          splits: new _InLocalStorage.default(_keys, expirationTimestamp, settings.sync.__splitFiltersValidation),
-          segments: new _InLocalStorage2.default(_keys),
-          impressions: new _InMemory3.default(),
-          metrics: new _InMemory4.default(),
-          count: new _InMemory5.default(),
-          events: new _InMemory6.default(context),
-          // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-          shared: function shared(settings) {
-            var childKeysBuilder = new _KeysLocalStorage.default(settings);
-            return {
-              splits: this.splits,
-              segments: new _InLocalStorage2.default(childKeysBuilder),
-              impressions: this.impressions,
-              metrics: this.metrics,
-              count: this.count,
-              events: this.events,
-              destroy: function destroy() {
-                this.splits = new _InMemory.default();
-                this.segments = new _InMemory2.default(childKeysBuilder);
-              }
-            };
-          },
-          destroy: function destroy() {
-            this.splits = new _InMemory.default();
-            this.segments = new _InMemory2.default(new _Keys.default(settings));
-            this.impressions.clear();
-            this.metrics.clear();
-            this.count.clear();
-            this.events.clear();
-          }
-        };
-      }
-
-    default:
-      throw new Error('Unsupported storage type');
-  }
-};
-
-var _default = BrowserStorageFactory;
-exports.default = _default;

package/lib/storage/node.js

@@ -1,104 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _RedisAdapter = _interopRequireDefault(require("./RedisAdapter"));
-
-var _InMemory = _interopRequireDefault(require("./SplitCache/InMemory"));
-
-var _InRedis = _interopRequireDefault(require("./SplitCache/InRedis"));
-
-var _InMemory2 = _interopRequireDefault(require("./SegmentCache/InMemory"));
-
-var _InRedis2 = _interopRequireDefault(require("./SegmentCache/InRedis"));
-
-var _InMemory3 = _interopRequireDefault(require("./ImpressionsCache/InMemory"));
-
-var _InRedis3 = _interopRequireDefault(require("./ImpressionsCache/InRedis"));
-
-var _InMemory4 = _interopRequireDefault(require("./LatencyCache/InMemory"));
-
-var _InRedis4 = _interopRequireDefault(require("./LatencyCache/InRedis"));
-
-var _InMemory5 = _interopRequireDefault(require("./CountCache/InMemory"));
-
-var _InRedis5 = _interopRequireDefault(require("./CountCache/InRedis"));
-
-var _InMemory6 = _interopRequireDefault(require("./EventsCache/InMemory"));
-
-var _InRedis6 = _interopRequireDefault(require("./EventsCache/InRedis"));
-
-var _Keys = _interopRequireDefault(require("./Keys"));
-
-var _Meta = _interopRequireDefault(require("./Meta"));
-
-var _constants = require("../utils/constants");
-
-var NodeStorageFactory = function NodeStorageFactory(context) {
-  var settings = context.get(context.constants.SETTINGS);
-  var storage = settings.storage;
-  var keys = new _Keys.default(settings);
-
-  switch (storage.type) {
-    case _constants.STORAGE_REDIS:
-      {
-        var redis = new _RedisAdapter.default(storage.options);
-        var meta = (0, _Meta.default)(settings); // subscription to Redis connect event in order to emit SDK_READY
-
-        var _context$get = context.get(context.constants.READINESS),
-            splits = _context$get.splits,
-            segments = _context$get.segments;
-
-        redis.on('connect', function () {
-          splits.emit(splits.SDK_SPLITS_ARRIVED);
-          segments.emit(segments.SDK_SEGMENTS_ARRIVED);
-        });
-        return {
-          splits: new _InRedis.default(keys, redis),
-          segments: new _InRedis2.default(keys, redis),
-          impressions: new _InRedis3.default(keys, redis, meta),
-          metrics: new _InRedis4.default(keys, redis),
-          count: new _InRedis5.default(keys, redis),
-          events: new _InRedis6.default(keys, redis, meta),
-          // When using REDIS we should:
-          // 1- Disconnect from the storage
-          // 2- Stop sending data to Redis and instance using empty in memory implementation
-          destroy: function destroy() {
-            redis.disconnect();
-            this.splits = new _InMemory.default();
-            this.segments = new _InMemory2.default(keys);
-            this.impressions = new _InMemory3.default();
-            this.metrics = new _InMemory4.default();
-            this.count = new _InMemory5.default();
-            this.events = new _InMemory6.default(context);
-          }
-        };
-      }
-
-    case _constants.STORAGE_MEMORY:
-    default:
-      return {
-        splits: new _InMemory.default(),
-        segments: new _InMemory2.default(keys),
-        impressions: new _InMemory3.default(),
-        metrics: new _InMemory4.default(),
-        count: new _InMemory5.default(),
-        events: new _InMemory6.default(context),
-        // When using MEMORY we should flush all the storages and leave them empty
-        destroy: function destroy() {
-          this.splits.flush();
-          this.segments.flush();
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-  }
-};
-
-var _default = NodeStorageFactory;
-exports.default = _default;

package/lib/storage/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "./node.js",
-  "browser": "./browser.js"
-}