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

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

@@ -0,0 +1,190 @@
+/**
+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';
+const log = logFactory('splitio-offline:splits-fetcher');
+
+const DEFAULT_FILENAME = '.split';
+
+function configFilesPath(config = {}) {
+  let configFilePath = config.features;
+
+  if (configFilePath === DEFAULT_FILENAME || !isString(configFilePath)) {
+    let 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, data => {
+    const 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.
+    const firstRolloutCondition = find(conditions, cond => cond.conditionType === 'ROLLOUT');
+    // Malformed mocks may have
+    const treatments = uniq(data.treatments);
+    // If they're only specifying a whitelist we add the treatments there.
+    const allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
+
+    const fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
+
+    treatments.forEach(treatment => {
+      if (treatment !== fullyAllocatedTreatment) {
+        allTreatmentsCondition.partitions.push({
+          treatment, size: 0
+        });
+      }
+    });
+
+    // Don't need these anymore
+    delete data.treatments;
+  });
+}
+
+export default function createGetSplitConfigForFile() {
+
+  let previousMock = 'NO_MOCK_LOADED';
+
+  // Parse `.split` configuration file and return a map of "Split Objects"
+  function readSplitConfigFile(filePath) {
+    const SPLIT_POSITION = 0;
+    const TREATMENT_POSITION = 1;
+    let data;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+      log.error(e.message);
+
+      return {};
+    }
+
+    if (data === previousMock) return false;
+    previousMock = data;
+
+    const splitObjects = data.split(/\r?\n/).reduce((accum, line, index) => {
+      let 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 {
+          const splitName = tuple[SPLIT_POSITION];
+          const 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) {
+    let data = '';
+    let 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.
+    const mocksData = yamldoc.reduce((accum, splitEntry) => {
+      const splitName = Object.keys(splitEntry)[0];
+
+      if (!splitName || !isString(splitEntry[splitName].treatment))
+        log.error('Ignoring entry on YAML since the format is incorrect.');
+
+      const 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.
+      const 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) {
+    const filePath = configFilesPath(settings);
+    let 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/src/services/splitChanges/offline/package.json

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

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

@@ -0,0 +1,52 @@
+import { isString } from '../../../utils/lang';
+
+export default function parseCondition(data) {
+  const 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/src/services/transport/index.js

@@ -0,0 +1,44 @@
+import getFetch from '../getFetch';
+import { SplitNetworkError } from '../../utils/lang/Errors';
+import logFactory from '../../utils/logger';
+const log = logFactory('splitio-services:service');
+
+const messageNoFetch = 'Global fetch API is not available.';
+
+export default function Fetcher(request) {
+  // using `fetch(url, options)` signature to work with unfetch
+  const url = request.url;
+  const 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(response => {
+      if (!response.ok) {
+        return response.text().then(message => Promise.reject({ response, message }));
+      }
+      return response;
+    })
+    .catch(error => {
+      const resp = error && error.response;
+      let 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/src/storage/AttributesCache/InMemory.js

@@ -0,0 +1,76 @@
+import objectAssign from 'object-assign';
+
+class AttributesCacheInMemory {
+
+  constructor() {
+    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
+   */
+  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
+   */
+  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
+   */
+  setAttributes(attributes) {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   *
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll() {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   *
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  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
+   *
+   */
+  clear() {
+    this.attributesCache = {};
+    return true;
+  }
+
+}
+
+export default AttributesCacheInMemory;

package/src/storage/BaseMetricsAsyncCache.js

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

package/src/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.
+**/
+
+class CountCacheInMemory {
+  constructor() {
+    this.clear();
+  }
+
+  clear() {
+    this.counters = {};
+
+    return this;
+  }
+
+  state() {
+    return this.counters;
+  }
+
+  track(metricName) {
+    if (this.counters[metricName] === undefined) this.counters[metricName] = 1;
+    else this.counters[metricName]++;
+
+    return this.counters[metricName];
+  }
+
+  isEmpty() {
+    return Object.keys(this.counters).length === 0;
+  }
+
+  toJSON() {
+    return this.counters;
+  }
+}
+
+export default CountCacheInMemory;

package/src/storage/CountCache/InRedis.js

@@ -0,0 +1,32 @@
+/**
+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';
+
+class CountCacheInRedis extends BaseMetricsAsyncCache {
+  constructor(keys, redis) {
+    super();
+    this.keys = keys;
+    this.redis = redis;
+  }
+
+  track(metricName) {
+    return this.redis.incr(this.keys.buildCountKey(metricName)).catch(() => {
+      // noop, for telemetry metrics there's no need to throw.
+    });
+  }
+}
+
+export default CountCacheInRedis;

package/src/storage/EventsCache/InMemory.js

@@ -0,0 +1,99 @@
+/**
+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';
+
+const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
+
+class EventsCache {
+
+  constructor(context) {
+    const settings = context.get(context.constants.SETTINGS);
+    const eventsModule = context.get(context.constants.EVENTS);
+
+    this.onFullQueue = false;
+    this.maxQueue = settings.scheduler.eventsQueueSize;
+    this.queue = [];
+    this.queueByteSize = 0;
+
+    if (thenable(eventsModule)) {
+      eventsModule.then(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.
+   */
+  state() {
+    return this.queue;
+  }
+
+  /**
+   * Add a new event object at the end of the queue.
+   */
+  track(data, size = 0) {
+    this.queueByteSize += size;
+    this.queue.push(data);
+
+    this._checkForFlush();
+
+    return true;
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.queue = [];
+    this.queueByteSize = 0;
+
+    return this;
+  }
+
+  /**
+   * Returns the payload we will use for posting data.
+   */
+  toJSON() {
+    return this.queue;
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+
+  /**
+   * Check if the cache queue is full and we need to flush it.
+   */
+  _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();
+    }
+  }
+}
+
+export default EventsCache;

package/src/storage/EventsCache/InRedis.js

@@ -0,0 +1,62 @@
+/**
+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';
+const log = logFactory('splitio-storage:redis');
+
+class EventsCache {
+  constructor(keys, redis, meta) {
+    this.keys = keys;
+    this.redis = redis;
+    this.meta = meta;
+
+    this.eventsKey = keys.buildEventsKey();
+  }
+
+  /**
+   * Add a new event object into the queue.
+   */
+  track(eventData) {
+    return this.redis.rpush(
+      this.eventsKey,
+      this._toJSON(eventData)
+    )
+      // We use boolean values to signal successful queueing
+      .then(() => true)
+      .catch(err => {
+        log.error(`Error adding event to queue: ${err}.`);
+        return false;
+      });
+  }
+
+  /**
+   * Generates the JSON as we'll store it on Redis.
+   */
+  _toJSON(eventData) {
+    return JSON.stringify({
+      m: this.meta,
+      e: eventData
+    });
+  }
+
+  /**
+   * We are returning true because the go syncronizer push the impressions from redis.
+   */
+  isEmpty() {
+    return true;
+  }
+}
+
+export default EventsCache;

package/src/storage/ImpressionsCache/InMemory.js

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