@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/storage/EventsCache/InMemory.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+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 MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
+
+var EventsCache = /*#__PURE__*/function () {
+  function EventsCache(context) {
+    var _this = this;
+
+    var settings = context.get(context.constants.SETTINGS);
+    var eventsModule = context.get(context.constants.EVENTS);
+    this.onFullQueue = false;
+    this.maxQueue = settings.scheduler.eventsQueueSize;
+    this.queue = [];
+    this.queueByteSize = 0;
+
+    if ((0, _thenable.default)(eventsModule)) {
+      eventsModule.then(function (events) {
+        _this.onFullQueue = events.flushAndResetTimer;
+
+        _this._checkForFlush(); // Events is ready, check the queue.
+
+      });
+    } else if (typeof eventsModule.flushAndResetTimer === 'function') {
+      this.onFullQueue = eventsModule.flushAndResetTimer;
+    }
+  }
+  /**
+   * Get the current state of the queue.
+   */
+
+
+  var _proto = EventsCache.prototype;
+
+  _proto.state = function state() {
+    return this.queue;
+  }
+  /**
+   * Add a new event object at the end of the queue.
+   */
+  ;
+
+  _proto.track = function track(data, size) {
+    if (size === void 0) {
+      size = 0;
+    }
+
+    this.queueByteSize += size;
+    this.queue.push(data);
+
+    this._checkForFlush();
+
+    return true;
+  }
+  /**
+   * Clear the data stored on the cache.
+   */
+  ;
+
+  _proto.clear = function clear() {
+    this.queue = [];
+    this.queueByteSize = 0;
+    return this;
+  }
+  /**
+   * Returns the payload we will use for posting data.
+   */
+  ;
+
+  _proto.toJSON = function toJSON() {
+    return this.queue;
+  }
+  /**
+   * Check if the cache is empty.
+   */
+  ;
+
+  _proto.isEmpty = function isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * Check if the cache queue is full and we need to flush it.
+   */
+  ;
+
+  _proto._checkForFlush = function _checkForFlush() {
+    if (this.queueByteSize > MAX_QUEUE_BYTE_SIZE || // 0 means no maximum value, in case we want to avoid this being triggered. Size limit is not affected by it.
+    this.maxQueue > 0 && this.queue.length >= this.maxQueue) {
+      this.onFullQueue && this.onFullQueue();
+    }
+  };
+
+  return EventsCache;
+}();
+
+var _default = EventsCache;
+exports.default = _default;

package/lib/storage/EventsCache/InRedis.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+/**
+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 log = (0, _logger.default)('splitio-storage:redis');
+
+var EventsCache = /*#__PURE__*/function () {
+  function EventsCache(keys, redis, meta) {
+    this.keys = keys;
+    this.redis = redis;
+    this.meta = meta;
+    this.eventsKey = keys.buildEventsKey();
+  }
+  /**
+   * Add a new event object into the queue.
+   */
+
+
+  var _proto = EventsCache.prototype;
+
+  _proto.track = function track(eventData) {
+    return this.redis.rpush(this.eventsKey, this._toJSON(eventData)) // We use boolean values to signal successful queueing
+    .then(function () {
+      return true;
+    }).catch(function (err) {
+      log.error("Error adding event to queue: " + err + ".");
+      return false;
+    });
+  }
+  /**
+   * Generates the JSON as we'll store it on Redis.
+   */
+  ;
+
+  _proto._toJSON = function _toJSON(eventData) {
+    return JSON.stringify({
+      m: this.meta,
+      e: eventData
+    });
+  }
+  /**
+   * We are returning true because the go syncronizer push the impressions from redis.
+   */
+  ;
+
+  _proto.isEmpty = function isEmpty() {
+    return true;
+  };
+
+  return EventsCache;
+}();
+
+var _default = EventsCache;
+exports.default = _default;

package/lib/storage/ImpressionsCache/InMemory.js

@@ -0,0 +1,77 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+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;
+}();
+
+var _default = ImpressionsCacheInMemory;
+exports.default = _default;

package/lib/storage/ImpressionsCache/InRedis.js

@@ -0,0 +1,79 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+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;
+}();
+
+var _default = ImpressionsCacheInRedis;
+exports.default = _default;

package/lib/storage/Keys.js

@@ -0,0 +1,132 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lang = require("../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 (0, _lang.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;
+}();
+
+var _default = KeyBuilder;
+exports.default = _default;

package/lib/storage/KeysLocalStorage.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _lang = require("../utils/lang");
+
+var _Keys = _interopRequireDefault(require("./Keys"));
+
+var _factory = require("../utils/key/factory");
+
+var KeyBuilderForLocalStorage = /*#__PURE__*/function (_KeyBuilder) {
+  (0, _inheritsLoose2.default)(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 + "." + (0, _factory.matching)(this.settings.core.key) + ".segment." + segmentName;
+  };
+
+  _proto.extractSegmentName = function extractSegmentName(builtSegmentKeyName) {
+    var prefix = this.settings.storage.prefix + "." + (0, _factory.matching)(this.settings.core.key) + ".segment.";
+    if ((0, _lang.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 (0, _factory.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 = (0, _factory.matching)(this.settings.core.key) + "." + this.settings.storage.prefix + ".segment.";
+    if ((0, _lang.startsWith)(maybeOldKey, prefix)) return maybeOldKey.substr(prefix.length);
+  };
+
+  return KeyBuilderForLocalStorage;
+}(_Keys.default);
+
+var _default = KeyBuilderForLocalStorage;
+exports.default = _default;

package/lib/storage/LatencyCache/InMemory.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _findIndex = _interopRequireDefault(require("./findIndex"));
+
+/**
+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 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][(0, _findIndex.default)(latency)]++;
+    return this;
+  };
+
+  _proto.isEmpty = function isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.counters;
+  };
+
+  return LatencyCacheInMemory;
+}();
+
+var _default = LatencyCacheInMemory;
+exports.default = _default;

package/lib/storage/LatencyCache/InRedis.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+
+var _findIndex = _interopRequireDefault(require("./findIndex"));
+
+var _BaseMetricsAsyncCache = _interopRequireDefault(require("../BaseMetricsAsyncCache"));
+
+/**
+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 LatencyCacheInRedis = /*#__PURE__*/function (_BaseMetricsAsyncCach) {
+  (0, _inheritsLoose2.default)(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 = (0, _findIndex.default)(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.default);
+
+var _default = LatencyCacheInRedis;
+exports.default = _default;

package/lib/storage/LatencyCache/findIndex.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _binarySearch = _interopRequireDefault(require("../../utils/binarySearch"));
+
+var _default = _binarySearch.default.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]);
+
+exports.default = _default;

package/lib/storage/Meta.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = MetaBuilder;
+
+function MetaBuilder(settings) {
+  return {
+    s: settings.version,
+    i: settings.runtime.ip,
+    n: settings.runtime.hostname
+  };
+}