@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/services/splitChanges/offline/node.js

@@ -0,0 +1,176 @@
+/**
+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 fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import logFactory from '../../../utils/logger';
+import { isString, endsWith, find, forOwn, uniq } from '../../../utils/lang';
+import parseCondition from './parseCondition';
+var log = logFactory('splitio-offline:splits-fetcher');
+var DEFAULT_FILENAME = '.split';
+
+function configFilesPath(config) {
+  if (config === void 0) {
+    config = {};
+  }
+
+  var configFilePath = config.features;
+
+  if (configFilePath === DEFAULT_FILENAME || !isString(configFilePath)) {
+    var root = process.env.HOME;
+    if (process.env.SPLIT_CONFIG_ROOT) root = process.env.SPLIT_CONFIG_ROOT;
+    if (!root) throw new Error('Missing split mock configuration root.');
+    configFilePath = path.join(root, DEFAULT_FILENAME);
+  } // Validate the extensions
+
+
+  if (!(endsWith(configFilePath, '.yaml', true) || endsWith(configFilePath, '.yml', true) || endsWith(configFilePath, '.split', true))) throw new Error("Invalid extension specified for Splits mock file. Accepted extensions are \".yml\" and \".yaml\". Your specified file is " + configFilePath);
+  if (!fs.existsSync(configFilePath)) throw new Error("Split configuration not found in " + configFilePath + " - Please review your Split file location.");
+  return configFilePath;
+} // This function is not pure nor meant to be. Here we apply modifications to cover
+//  for behaviour that's ensured by the BE.
+
+
+function arrangeConditions(mocksData) {
+  // Iterate through each Split data
+  forOwn(mocksData, function (data) {
+    var conditions = data.conditions; // On the manager, as the split jsons come with all treatments on the partitions prop,
+    // we'll add all the treatments to the first condition.
+
+    var firstRolloutCondition = find(conditions, function (cond) {
+      return cond.conditionType === 'ROLLOUT';
+    }); // Malformed mocks may have
+
+    var treatments = uniq(data.treatments); // If they're only specifying a whitelist we add the treatments there.
+
+    var allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
+    var fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
+    treatments.forEach(function (treatment) {
+      if (treatment !== fullyAllocatedTreatment) {
+        allTreatmentsCondition.partitions.push({
+          treatment: treatment,
+          size: 0
+        });
+      }
+    }); // Don't need these anymore
+
+    delete data.treatments;
+  });
+}
+
+export default function createGetSplitConfigForFile() {
+  var previousMock = 'NO_MOCK_LOADED'; // Parse `.split` configuration file and return a map of "Split Objects"
+
+  function readSplitConfigFile(filePath) {
+    var SPLIT_POSITION = 0;
+    var TREATMENT_POSITION = 1;
+    var data;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+      log.error(e.message);
+      return {};
+    }
+
+    if (data === previousMock) return false;
+    previousMock = data;
+    var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
+      var tuple = line.trim();
+
+      if (tuple === '' || tuple.charAt(0) === '#') {
+        log.debug("Ignoring empty line or comment at #" + index);
+      } else {
+        tuple = tuple.split(/\s+/);
+
+        if (tuple.length !== 2) {
+          log.debug("Ignoring line since it does not have exactly two columns #" + index);
+        } else {
+          var splitName = tuple[SPLIT_POSITION];
+          var condition = parseCondition({
+            treatment: tuple[TREATMENT_POSITION]
+          });
+          accum[splitName] = {
+            conditions: [condition],
+            configurations: {},
+            trafficTypeName: 'localhost'
+          };
+        }
+      }
+
+      return accum;
+    }, {});
+    return splitObjects;
+  } // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
+
+
+  function readYAMLConfigFile(filePath) {
+    var data = '';
+    var yamldoc = null;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf8');
+      if (data === previousMock) return false;
+      previousMock = data;
+      yamldoc = yaml.safeLoad(data);
+    } catch (e) {
+      log.error(e);
+      return {};
+    } // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+
+
+    var mocksData = yamldoc.reduce(function (accum, splitEntry) {
+      var splitName = Object.keys(splitEntry)[0];
+      if (!splitName || !isString(splitEntry[splitName].treatment)) log.error('Ignoring entry on YAML since the format is incorrect.');
+      var mockData = splitEntry[splitName]; // "Template" for each split accumulated data
+
+      if (!accum[splitName]) {
+        accum[splitName] = {
+          configurations: {},
+          conditions: [],
+          treatments: [],
+          trafficTypeName: 'localhost'
+        };
+      } // Assign the config if there is one on the mock
+
+
+      if (mockData.config) accum[splitName].configurations[mockData.treatment] = mockData.config; // Parse the condition from the entry.
+
+      var condition = parseCondition(mockData);
+      accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition); // Also keep track of the treatments, will be useful for manager functionality.
+
+      accum[splitName].treatments.push(mockData.treatment);
+      return accum;
+    }, {});
+    arrangeConditions(mocksData);
+    return mocksData;
+  } // Load the content of a configuration file into an Object
+
+
+  return function getSplitConfigForFile(settings) {
+    var filePath = configFilesPath(settings);
+    var mockData = null; // If we have a filePath, it means the extension is correct, choose the parser.
+
+    if (endsWith(filePath, '.split')) {
+      log.warn('.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+      mockData = readSplitConfigFile(filePath);
+    } else {
+      mockData = readYAMLConfigFile(filePath);
+    }
+
+    return mockData;
+  };
+}

package/es/services/splitChanges/offline/parseCondition.js

@@ -0,0 +1,43 @@
+import { isString } from '../../../utils/lang';
+export default function parseCondition(data) {
+  var treatment = data.treatment;
+
+  if (data.keys) {
+    return {
+      conditionType: 'WHITELIST',
+      matcherGroup: {
+        combiner: 'AND',
+        matchers: [{
+          keySelector: null,
+          matcherType: 'WHITELIST',
+          negate: false,
+          whitelistMatcherData: {
+            whitelist: isString(data.keys) ? [data.keys] : data.keys
+          }
+        }]
+      },
+      partitions: [{
+        treatment: treatment,
+        size: 100
+      }],
+      label: "whitelisted " + treatment
+    };
+  } else {
+    return {
+      conditionType: 'ROLLOUT',
+      matcherGroup: {
+        combiner: 'AND',
+        matchers: [{
+          keySelector: null,
+          matcherType: 'ALL_KEYS',
+          negate: false
+        }]
+      },
+      partitions: [{
+        treatment: treatment,
+        size: 100
+      }],
+      label: 'default rule'
+    };
+  }
+}

package/es/services/transport/index.js

@@ -0,0 +1,51 @@
+import getFetch from '../getFetch';
+import { SplitNetworkError } from '../../utils/lang/Errors';
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-services:service');
+var messageNoFetch = 'Global fetch API is not available.';
+export default function Fetcher(request) {
+  // using `fetch(url, options)` signature to work with unfetch
+  var url = request.url;
+  var fetch = getFetch();
+  return fetch ? fetch(url, request) // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
+  .then(function (response) {
+    if (!response.ok) {
+      return response.text().then(function (message) {
+        return Promise.reject({
+          response: response,
+          message: message
+        });
+      });
+    }
+
+    return response;
+  }).catch(function (error) {
+    var resp = error && error.response;
+    var msg = '';
+
+    if (resp) {
+      // An HTTP error
+      switch (resp.status) {
+        case 404:
+          msg = 'Invalid API key or resource not found.';
+          break;
+        // Don't use resp.statusText since reason phrase is removed in HTTP/2
+
+        default:
+          msg = error.message;
+          break;
+      }
+    } else {
+      // Something else, either an error making the request or a Network error.
+      msg = error.message;
+    }
+
+    if (!resp || resp.status !== 403) {
+      // 403's log we'll be handled somewhere else.
+      log[request.logErrorsAsInfo ? 'info' : 'error']("Response status is not OK. Status: " + (resp ? resp.status : 'NO_STATUS') + ". URL: " + url + ". Message: " + msg);
+    } // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
+
+
+    throw new SplitNetworkError(msg, resp && resp.status);
+  }) : Promise.reject(new SplitNetworkError(messageNoFetch));
+}

package/es/storage/AttributesCache/InMemory.js

@@ -0,0 +1,85 @@
+import objectAssign from 'object-assign';
+
+var AttributesCacheInMemory = /*#__PURE__*/function () {
+  function AttributesCacheInMemory() {
+    this.attributesCache = {};
+  }
+  /**
+   * Create or update the value for the given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored
+   */
+
+
+  var _proto = AttributesCacheInMemory.prototype;
+
+  _proto.setAttribute = function setAttribute(attributeName, attributeValue) {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+  /**
+   * Retrieves the value of a given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  ;
+
+  _proto.getAttribute = function getAttribute(attributeName) {
+    return this.attributesCache[attributeName];
+  }
+  /**
+   * Create or update all the given attributes
+   *
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  ;
+
+  _proto.setAttributes = function setAttributes(attributes) {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+  /**
+   * Retrieve the full attributes map
+   *
+   * @returns {Map<string, Object>} stored attributes
+   */
+  ;
+
+  _proto.getAll = function getAll() {
+    return this.attributesCache;
+  }
+  /**
+   * Removes a given attribute from the map
+   *
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  ;
+
+  _proto.removeAttribute = function removeAttribute(attributeName) {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * Clears all attributes stored in the SDK
+   *
+   */
+  ;
+
+  _proto.clear = function clear() {
+    this.attributesCache = {};
+    return true;
+  };
+
+  return AttributesCacheInMemory;
+}();
+
+export default AttributesCacheInMemory;

package/es/storage/BaseMetricsAsyncCache.js

@@ -0,0 +1,23 @@
+var BaseMetricsAsyncCache = /*#__PURE__*/function () {
+  function BaseMetricsAsyncCache() {}
+
+  var _proto = BaseMetricsAsyncCache.prototype;
+
+  /**
+   * Async storage caches will always count as empty from an SDK Producer point of view.
+   */
+  _proto.isEmpty = function isEmpty() {
+    return true;
+  }
+  /**
+   * On async storages we will save metrics on Redis but nothing more. No clean ups or consumptions.
+   */
+  ;
+
+  _proto.clear = function clear() {// noop.
+  };
+
+  return BaseMetricsAsyncCache;
+}();
+
+export { BaseMetricsAsyncCache as default };

package/es/storage/CountCache/InMemory.js

@@ -0,0 +1,48 @@
+/**
+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 CountCacheInMemory = /*#__PURE__*/function () {
+  function CountCacheInMemory() {
+    this.clear();
+  }
+
+  var _proto = CountCacheInMemory.prototype;
+
+  _proto.clear = function clear() {
+    this.counters = {};
+    return this;
+  };
+
+  _proto.state = function state() {
+    return this.counters;
+  };
+
+  _proto.track = function track(metricName) {
+    if (this.counters[metricName] === undefined) this.counters[metricName] = 1;else this.counters[metricName]++;
+    return this.counters[metricName];
+  };
+
+  _proto.isEmpty = function isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.counters;
+  };
+
+  return CountCacheInMemory;
+}();
+
+export default CountCacheInMemory;

package/es/storage/CountCache/InRedis.js

@@ -0,0 +1,42 @@
+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 BaseMetricsAsyncCache from '../BaseMetricsAsyncCache';
+
+var CountCacheInRedis = /*#__PURE__*/function (_BaseMetricsAsyncCach) {
+  _inheritsLoose(CountCacheInRedis, _BaseMetricsAsyncCach);
+
+  function CountCacheInRedis(keys, redis) {
+    var _this;
+
+    _this = _BaseMetricsAsyncCach.call(this) || this;
+    _this.keys = keys;
+    _this.redis = redis;
+    return _this;
+  }
+
+  var _proto = CountCacheInRedis.prototype;
+
+  _proto.track = function track(metricName) {
+    return this.redis.incr(this.keys.buildCountKey(metricName)).catch(function () {// noop, for telemetry metrics there's no need to throw.
+    });
+  };
+
+  return CountCacheInRedis;
+}(BaseMetricsAsyncCache);
+
+export default CountCacheInRedis;

package/es/storage/EventsCache/InMemory.js

@@ -0,0 +1,109 @@
+/**
+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 thenable from '../../utils/promise/thenable';
+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 (thenable(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;
+}();
+
+export default EventsCache;

package/es/storage/EventsCache/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.
+**/
+import logFactory from '../../utils/logger';
+var log = logFactory('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;
+}();
+
+export default EventsCache;