@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/producer/browser.js

@@ -0,0 +1,70 @@
+/**
+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';
+import TaskFactory from './task';
+import SplitChangesUpdater from './updater/SplitChanges';
+import PartialBrowserProducer from './browser/Partial';
+var log = logFactory('splitio-producer:updater');
+/**
+ * Startup all the background jobs required for a Browser SDK instance.
+ */
+
+var FullBrowserProducer = function FullBrowserProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var splitsUpdater = SplitChangesUpdater(context);
+  var splitsUpdaterTask = TaskFactory(synchronizeSplits, settings.scheduler.featuresRefreshRate);
+  var mySegmentsProducer = PartialBrowserProducer(context);
+  var _isSynchronizingSplits = false;
+  /**
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  function synchronizeSplits(noCache) {
+    _isSynchronizingSplits = true; // `splitsUpdater` promise always resolves, and with a false value if it fails to fetch or store splits
+
+    return splitsUpdater(0, noCache).then(function (res) {
+      _isSynchronizingSplits = false;
+      return res;
+    });
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start: function start() {
+      log.info('Starting BROWSER producer');
+      splitsUpdaterTask.start();
+      mySegmentsProducer.start();
+    },
+    // Stop periodic fetching (polling)
+    stop: function stop() {
+      log.info('Stopping BROWSER producer');
+      splitsUpdaterTask.stop();
+      mySegmentsProducer.stop();
+    },
+    // Used by SyncManager to know if running in polling mode.
+    isRunning: splitsUpdaterTask.isRunning,
+    // Used by SplitUpdateWorker
+    isSynchronizingSplits: function isSynchronizingSplits() {
+      return _isSynchronizingSplits;
+    },
+    synchronizeSplits: synchronizeSplits,
+    // Used by MySegmentUpdateWorker
+    isSynchronizingMySegments: mySegmentsProducer.isSynchronizingMySegments,
+    synchronizeMySegments: mySegmentsProducer.synchronizeMySegments
+  };
+};
+
+export default FullBrowserProducer;

package/es/producer/fetcher/MySegments.js

@@ -0,0 +1,47 @@
+/**
+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 timeout from '../../utils/promise/timeout';
+import tracker from '../../utils/timeTracker';
+import { SplitError } from '../../utils/lang/Errors';
+import mySegmentsService from '../../services/mySegments';
+import mySegmentsRequest from '../../services/mySegments/get';
+
+var mySegmentsFetcher = function mySegmentsFetcher(settings, startingUp, metricCollectors, noCache) {
+  if (startingUp === void 0) {
+    startingUp = false;
+  }
+
+  var mySegmentsPromise = mySegmentsService(mySegmentsRequest(settings, noCache));
+  mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise); // Decorate with the timeout functionality if required
+
+  if (startingUp) {
+    mySegmentsPromise = timeout(settings.startup.requestTimeoutBeforeReady, mySegmentsPromise);
+  } // Extract segment names
+
+
+  return mySegmentsPromise // JSON parsing errors are handled as SplitErrors, to distinguish from user callback errors
+  .then(function (resp) {
+    return resp.json().catch(function (error) {
+      throw new SplitError(error.message);
+    });
+  }).then(function (json) {
+    return json.mySegments.map(function (segment) {
+      return segment.name;
+    });
+  });
+};
+
+export default mySegmentsFetcher;

package/es/producer/fetcher/SegmentChanges.js

@@ -0,0 +1,52 @@
+/**
+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 segmentChangesService from '../../services/segmentChanges';
+import segmentChangesRequest from '../../services/segmentChanges/get';
+import tracker from '../../utils/timeTracker';
+
+function greedyFetch(settings, lastSinceValue, segmentName, metricCollectors, noCache) {
+  return tracker.start(tracker.TaskNames.SEGMENTS_FETCH, metricCollectors, segmentChangesService(segmentChangesRequest(settings, {
+    since: lastSinceValue,
+    segmentName: segmentName
+  }, noCache))) // no need to handle json parsing errors as SplitError, since errors are handled differently for segments
+  .then(function (resp) {
+    return resp.json();
+  }).then(function (json) {
+    var since = json.since,
+        till = json.till;
+
+    if (since === till) {
+      return [json];
+    } else {
+      return Promise.all([json, greedyFetch(settings, till, segmentName, undefined, noCache)]).then(function (flatMe) {
+        return [flatMe[0]].concat(flatMe[1]);
+      });
+    }
+  }).catch(function (err) {
+    // If the operation is forbidden it may be due to permissions, don't recover and propagate the error.
+    if (err.statusCode === 403) throw err; // if something goes wrong with the request to the server, we are going to
+    // stop requesting information till the next round of downloading
+
+    return [];
+  });
+} // @TODO migrate to a generator function and do the job incrementally
+
+
+function segmentChangesFetcher(settings, segmentName, since, metricCollectors, noCache) {
+  return greedyFetch(settings, since, segmentName, metricCollectors, noCache);
+}
+
+export default segmentChangesFetcher;

package/es/producer/fetcher/SplitChanges.js

@@ -0,0 +1,46 @@
+/**
+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 timeout from '../../utils/promise/timeout';
+import tracker from '../../utils/timeTracker';
+import { SplitError } from '../../utils/lang/Errors';
+import splitChangesService from '../../services/splitChanges';
+import splitChangesRequest from '../../services/splitChanges/get';
+
+function splitChangesFetcher(settings, since, startingUp, metricCollectors, isNode, noCache) {
+  if (startingUp === void 0) {
+    startingUp = false;
+  }
+
+  var filterQueryString = settings.sync.__splitFiltersValidation.queryString;
+  var splitsPromise = splitChangesService(splitChangesRequest(settings, since, filterQueryString, noCache));
+  var collectMetrics = startingUp || isNode; // If we are on the browser, only collect this metric for first fetch. On node do it always.
+
+  splitsPromise = tracker.start(tracker.TaskNames.SPLITS_FETCH, collectMetrics ? metricCollectors : false, splitsPromise);
+
+  if (startingUp) {
+    // Decorate with the timeout functionality if required
+    splitsPromise = timeout(settings.startup.requestTimeoutBeforeReady, splitsPromise);
+  }
+
+  return splitsPromise // JSON parsing errors are handled as SplitErrors, to distinguish from user callback errors
+  .then(function (resp) {
+    return resp.json().catch(function (error) {
+      throw new SplitError(error.message);
+    });
+  });
+}
+
+export default splitChangesFetcher;

package/es/producer/node.js

@@ -0,0 +1,130 @@
+/**
+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-producer:updater');
+import repeat from '../utils/fn/repeat';
+import SplitChangesUpdater from './updater/SplitChanges';
+import SegmentChangesUpdater from './updater/SegmentChanges';
+/**
+ * Expose start / stop mechanism for pulling data from services.
+ */
+
+var NodeUpdater = function NodeUpdater(context) {
+  var splitsUpdater = SplitChangesUpdater(context, true
+  /* tell split updater we are in node */
+  );
+  var segmentsUpdater = SegmentChangesUpdater(context);
+  var settings = context.get(context.constants.SETTINGS);
+  var stopSplitsUpdate = false;
+  var stopSegmentsUpdate = false;
+  var splitFetchCompleted = false;
+  var _isRunning = false;
+  var _isSynchronizingSplits = false;
+  var _isSynchronizingSegments = false;
+  /**
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  function synchronizeSplits(noCache) {
+    _isSynchronizingSplits = true; // `splitsUpdater` promise always resolves, and with a false value if it fails to fetch or store splits
+
+    return splitsUpdater(0, noCache).then(function (res) {
+      // Mark splits as ready (track first successfull call to start downloading segments)
+      splitFetchCompleted = true;
+      _isSynchronizingSplits = false;
+      return res;
+    });
+  }
+  /**
+   * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+   * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+   * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+   */
+
+
+  function synchronizeSegment(segmentNames, noCache, fetchOnlyNew) {
+    _isSynchronizingSegments = true; // `segmentsUpdater` promise always resolves, and with a false value if it fails to fetch or store some segment
+
+    return segmentsUpdater(segmentNames, noCache, fetchOnlyNew).then(function (res) {
+      _isSynchronizingSegments = false;
+      return res;
+    });
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start: function start() {
+      log.info('Starting NODEJS updater');
+      log.debug("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis");
+      log.debug("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"); // Schedule incremental update of segments only if needed
+
+      var spinUpSegmentUpdater = function spinUpSegmentUpdater() {
+        // We must check that Split polling is running (i.e. `stopSplitsUpdate !== false`),
+        // in case that `spinUpSegmentUpdater` is called once the client has been destroyed.
+        if (stopSplitsUpdate && !stopSegmentsUpdate) {
+          stopSegmentsUpdate = repeat(function (scheduleSegmentsUpdate) {
+            if (splitFetchCompleted) {
+              log.debug('Fetching segments');
+              synchronizeSegment().then(function () {
+                return scheduleSegmentsUpdate();
+              });
+            } else {
+              scheduleSegmentsUpdate();
+            }
+          }, settings.scheduler.segmentsRefreshRate);
+        }
+      };
+
+      stopSplitsUpdate = repeat(function (scheduleSplitsUpdate) {
+        log.debug('Fetching splits');
+        synchronizeSplits().then(function () {
+          // Spin up the segments update if needed
+          spinUpSegmentUpdater(); // Re-schedule update
+
+          scheduleSplitsUpdate();
+        });
+      }, settings.scheduler.featuresRefreshRate);
+      _isRunning = true;
+    },
+    // Stop periodic fetching (polling)
+    stop: function stop() {
+      log.info('Stopping NODEJS updater');
+      stopSplitsUpdate && stopSplitsUpdate();
+      stopSplitsUpdate = false; // Mark polling stopped, to be able to call `start` again and to avoid polling segments if `spinUpSegmentUpdater` is called after the client has been destroyed.
+
+      stopSegmentsUpdate && stopSegmentsUpdate();
+      stopSegmentsUpdate = false;
+      _isRunning = false;
+    },
+    // Used by SyncManager to know if running in polling mode.
+    isRunning: function isRunning() {
+      return _isRunning;
+    },
+    // Used by SplitUpdateWorker
+    isSynchronizingSplits: function isSynchronizingSplits() {
+      return _isSynchronizingSplits;
+    },
+    synchronizeSplits: synchronizeSplits,
+    // Used by SegmentUpdateWorker
+    isSynchronizingSegments: function isSynchronizingSegments() {
+      return _isSynchronizingSegments;
+    },
+    synchronizeSegment: synchronizeSegment
+  };
+};
+
+export default NodeUpdater;

package/es/producer/offline/browser.js

@@ -0,0 +1,26 @@
+/**
+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 TaskFactory from '../task';
+import FromFeaturesUpdater from '../updater/SplitChangesFromFeatures';
+
+var OfflineFeatureProducer = function OfflineFeatureProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var updater = FromFeaturesUpdater(context);
+  var updaterTask = TaskFactory(updater, settings.scheduler.offlineRefreshRate);
+  return updaterTask;
+};
+
+export default OfflineFeatureProducer;

package/es/producer/offline/node.js

@@ -0,0 +1,26 @@
+/**
+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 TaskFactory from '../task';
+import FromFileSystemUpdater from '../updater/SplitChangesFromFileSystem';
+
+var OfflineFileSystemProducer = function OfflineFileSystemProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var updater = FromFileSystemUpdater(context);
+  var updaterTask = TaskFactory(updater, settings.scheduler.offlineRefreshRate);
+  return updaterTask;
+};
+
+export default OfflineFileSystemProducer;

package/es/producer/task.js

@@ -0,0 +1,50 @@
+/**
+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-producer:task');
+import repeat from '../utils/fn/repeat';
+import { getFnName } from '../utils/lang';
+/**
+ * Startable task factory.
+ */
+
+var TaskFactory = function TaskFactory(updater, period) {
+  var updaterName = getFnName(updater);
+  var stopUpdater = false;
+  return {
+    start: function start() {
+      if (!stopUpdater) {
+        log.debug("Starting " + updaterName + " refreshing each " + period);
+        stopUpdater = repeat(function (reschedule) {
+          log.debug("Running " + updaterName);
+          updater().then(function () {
+            return reschedule();
+          });
+        }, period);
+      }
+    },
+    stop: function stop() {
+      log.debug("Stopping " + updaterName);
+      stopUpdater && stopUpdater();
+      stopUpdater = false;
+    },
+    isRunning: function isRunning() {
+      return stopUpdater ? true : false;
+    }
+  };
+};
+
+export default TaskFactory;

package/es/producer/updater/MySegments.js

@@ -0,0 +1,108 @@
+/**
+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';
+import { SplitError } from '../../utils/lang/Errors';
+var log = logFactory('splitio-producer:my-segments');
+import mySegmentsFetcher from '../fetcher/MySegments';
+export default function MySegmentsUpdaterFactory(context) {
+  var _context$getAll = context.getAll(),
+      settings = _context$getAll[context.constants.SETTINGS],
+      readiness = _context$getAll[context.constants.READINESS],
+      storage = _context$getAll[context.constants.STORAGE],
+      metricCollectors = _context$getAll[context.constants.COLLECTORS];
+
+  var segmentsEventEmitter = readiness.segments;
+  var readyOnAlreadyExistentState = true;
+  var startingUp = true; // @TODO if allowing custom storages, handle async execution and wrap errors as SplitErrors to distinguish from user callback errors
+
+  function updateSegments(segmentsData) {
+    var mySegmentsCache = storage.segments;
+    var shouldNotifyUpdate;
+
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    } else {
+      // Add/Delete the segment
+      var name = segmentsData.name,
+          add = segmentsData.add;
+
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
+    } // Notify update if required
+
+
+    if (storage.splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+      readyOnAlreadyExistentState = false;
+      segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+    }
+  }
+  /**
+   * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData it can be:
+   *  (1) the list of segment names to sync in the storage,
+   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+   *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+
+  return function MySegmentsUpdater(retry, segmentsData, noCache) {
+    if (retry === void 0) {
+      retry = 0;
+    }
+
+    var updaterPromise;
+
+    if (segmentsData) {
+      // If segmentsData is provided, there is no need to fetch mySegments
+      updaterPromise = new Promise(function (res) {
+        updateSegments(segmentsData);
+        res();
+      });
+    } else {
+      // NOTE: We only collect metrics on startup.
+      updaterPromise = mySegmentsFetcher(settings, startingUp, metricCollectors, noCache).then(function (segments) {
+        // Only when we have downloaded segments completely, we should not keep retrying anymore
+        startingUp = false;
+        updateSegments(segments);
+      });
+    }
+
+    return updaterPromise.catch(function (error) {
+      // handle user callback errors
+      if (!(error instanceof SplitError)) setTimeout(function () {
+        throw error;
+      }, 0);
+
+      if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+        retry += 1;
+        log.warn("Retrying download of segments #" + retry + ". Reason: " + error);
+        return MySegmentsUpdater(retry);
+      } else {
+        startingUp = false;
+      }
+
+      return false; // shouldUpdate = false
+    });
+  };
+}