@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/metrics/index.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _timeTracker = _interopRequireDefault(require("../utils/timeTracker"));
+
+var _repeat = _interopRequireDefault(require("../utils/fn/repeat"));
+
+var _metrics = _interopRequireDefault(require("../services/metrics"));
+
+var _times = _interopRequireDefault(require("../services/metrics/times"));
+
+var _counters = _interopRequireDefault(require("../services/metrics/counters"));
+
+var _dto = require("../services/metrics/dto");
+
+var _impressions = _interopRequireDefault(require("../services/impressions"));
+
+var _bulk = _interopRequireDefault(require("../services/impressions/bulk"));
+
+var _count = _interopRequireDefault(require("../services/impressions/count"));
+
+var _dto2 = require("../services/impressions/dto");
+
+var _Collectors = require("./Collectors");
+
+var _constants = require("../utils/constants");
+
+/**
+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-metrics');
+var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
+
+var MetricsFactory = function MetricsFactory(context) {
+  var impressionsRetries = 0;
+  var settings = context.get(context.constants.SETTINGS);
+  var storage = context.get(context.constants.STORAGE);
+  var impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+  var shouldPushImpressionsCount = settings.sync.impressionsMode === _constants.OPTIMIZED;
+
+  var pushMetrics = function pushMetrics() {
+    if (storage.metrics.isEmpty() && storage.count.isEmpty()) return Promise.resolve();
+    log.debug('Pushing metrics');
+
+    var latencyTrackerStop = _timeTracker.default.start(_timeTracker.default.TaskNames.METRICS_PUSH); // POST latencies
+
+
+    var latenciesPromise = storage.metrics.isEmpty() ? null : (0, _metrics.default)((0, _times.default)(settings, {
+      body: JSON.stringify((0, _dto.fromLatenciesCollector)(storage.metrics))
+    })).then(function () {
+      return storage.metrics.clear();
+    }).catch(function () {
+      return storage.metrics.clear();
+    }); // POST counters
+
+    var countersPromise = storage.count.isEmpty() ? null : (0, _metrics.default)((0, _counters.default)(settings, {
+      body: JSON.stringify((0, _dto.fromCountersCollector)(storage.count))
+    })).then(function () {
+      return storage.count.clear();
+    }).catch(function () {
+      return storage.count.clear();
+    });
+    return Promise.all([latenciesPromise, countersPromise]).then(function (resp) {
+      // After both finishes, track the end and return the results
+      latencyTrackerStop();
+      return resp;
+    });
+  };
+
+  var pushImpressions = function pushImpressions() {
+    if (storage.impressions.isEmpty()) return Promise.resolve();
+    var imprCount = storage.impressions.queue.length;
+    log.info("Pushing " + imprCount + " impressions");
+
+    var latencyTrackerStop = _timeTracker.default.start(_timeTracker.default.TaskNames.IMPRESSIONS_PUSH);
+
+    return (0, _impressions.default)((0, _bulk.default)(settings, {
+      body: JSON.stringify((0, _dto2.fromImpressionsCollector)(storage.impressions, settings))
+    })).then(function () {
+      impressionsRetries = 0;
+      storage.impressions.clear();
+    }).catch(function (err) {
+      if (impressionsRetries) {
+        // For now we retry only once.
+        log.warn("Droping " + imprCount + " impressions after retry. Reason " + err + ".");
+        impressionsRetries = 0;
+        storage.impressions.clear();
+      } else {
+        impressionsRetries++;
+        log.warn("Failed to push " + imprCount + " impressions, keeping data to retry on next iteration. Reason " + err + ".");
+      }
+    }).then(function () {
+      return latencyTrackerStop();
+    });
+  };
+
+  var pushImpressionsCount = function pushImpressionsCount() {
+    var pf = (0, _dto2.fromImpressionsCountCollector)(impressionsCounter);
+    var imprCounts = pf.length;
+    if (imprCounts === 0) return Promise.resolve();
+    log.info("Pushing count of impressions for " + imprCounts + " features");
+    return (0, _impressions.default)((0, _count.default)(settings, {
+      body: JSON.stringify({
+        pf: pf
+      })
+    })).then(function () {
+      impressionsRetries = 0;
+    }).catch(function (err) {
+      if (impressionsRetries) {
+        // For now we retry only once.
+        log.warn("Droping count of impressions for " + imprCounts + " features after retry. Reason " + err + ".");
+        impressionsRetries = 0;
+      } else {
+        impressionsRetries++;
+        log.warn("Failed to push impressions count for " + imprCounts + " features, keeping data to retry on next iteration. Reason " + err + ".");
+      }
+    });
+  };
+
+  var stopImpressionsPublisher = false;
+  var stopPerformancePublisher = false;
+  var stopImpressionsCountPublisher = false;
+  return {
+    start: function start() {
+      stopImpressionsPublisher = (0, _repeat.default)(function (schedulePublisher) {
+        return pushImpressions().then(function () {
+          return schedulePublisher();
+        });
+      }, settings.scheduler.impressionsRefreshRate);
+      stopPerformancePublisher = (0, _repeat.default)(function (schedulePublisher) {
+        return pushMetrics().then(function () {
+          return schedulePublisher();
+        });
+      }, settings.scheduler.metricsRefreshRate);
+
+      if (shouldPushImpressionsCount) {
+        stopImpressionsCountPublisher = (0, _repeat.default)(function (schedulePublisher) {
+          return pushImpressionsCount().then(function () {
+            return schedulePublisher();
+          });
+        }, IMPRESSIONS_COUNT_RATE);
+      }
+    },
+    flush: function flush() {
+      if (shouldPushImpressionsCount) pushImpressionsCount();
+      return pushImpressions();
+    },
+    stop: function stop() {
+      stopImpressionsPublisher && stopImpressionsPublisher();
+      stopPerformancePublisher && stopPerformancePublisher();
+      stopImpressionsCountPublisher && stopImpressionsCountPublisher();
+    },
+    // Metrics collectors
+    collectors: {
+      segmentChanges: new _Collectors.SegmentChangesCollector(storage),
+      splitChanges: new _Collectors.SplitChangesCollector(storage),
+      mySegments: new _Collectors.MySegmentsCollector(storage),
+      client: new _Collectors.ClientCollector(storage)
+    }
+  };
+};
+
+var _default = MetricsFactory;
+exports.default = _default;

package/lib/producer/browser/Partial.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _task = _interopRequireDefault(require("../task"));
+
+var _MySegments = _interopRequireDefault(require("../updater/MySegments"));
+
+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-producer:mySegmentsHandler');
+/**
+ * Incremental updater to be used to share data in the browser.
+ */
+
+var PartialBrowserProducer = function PartialBrowserProducer(context) {
+  var settings = context.get(context.constants.SETTINGS);
+  var splitsStorage = context.get(context.constants.STORAGE).splits;
+
+  var _context$get = context.get(context.constants.READINESS),
+      splitsEventEmitter = _context$get.splits,
+      segmentsEventEmitter = _context$get.segments;
+
+  var mySegmentsUpdater = (0, _MySegments.default)(context);
+  var mySegmentsUpdaterTask = (0, _task.default)(synchronizeMySegments, settings.scheduler.segmentsRefreshRate);
+  splitsEventEmitter.on(splitsEventEmitter.SDK_SPLITS_ARRIVED, smartPausing); // needed for shared clients, we run `smartReady` a first time if splits were sync and don't use segments,
+  // to emit SDK_SEGMENTS_ARRIVED (and thus SDK_READY) immediately in next event cycle
+
+  if (!splitsStorage.usesSegments()) setTimeout(smartReady, 0);else splitsEventEmitter.once(splitsEventEmitter.SDK_SPLITS_ARRIVED, smartReady);
+  var _isSynchronizingMySegments = false;
+  /**
+   * @param {string[] | undefined} segmentList might be undefined
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+
+  function synchronizeMySegments(segmentList, noCache) {
+    _isSynchronizingMySegments = true; // `mySegmentsUpdater` promise always resolves, and with a false value if it fails to fetch or store mySegments
+
+    return mySegmentsUpdater(0, segmentList, noCache).then(function (res) {
+      _isSynchronizingMySegments = false;
+      return res;
+    });
+  }
+
+  var running = false; // we cannot rely on `mySegmentsUpdaterTask.isRunning` to check if doing polling
+
+  function isRunning() {
+    return running;
+  } // emit SDK_SEGMENTS_ARRIVED (and thus SDK_READY) if not ready yet and splits are not using segments
+
+
+  function smartReady() {
+    var isReady = context.get(context.constants.READY, true);
+    if (!isReady && !splitsStorage.usesSegments()) segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+  } // smartly pause/resume mySegmentsUpdaterTask while doing polling
+
+
+  function smartPausing() {
+    if (!running) return; // noop if not doing polling
+
+    var splitsHaveSegments = splitsStorage.usesSegments();
+
+    if (splitsHaveSegments !== mySegmentsUpdaterTask.isRunning()) {
+      log.info("Turning segments data polling " + (splitsHaveSegments ? 'ON' : 'OFF') + ".");
+
+      if (splitsHaveSegments) {
+        mySegmentsUpdaterTask.start();
+      } else {
+        mySegmentsUpdaterTask.stop();
+      }
+    }
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start: function start() {
+      running = true;
+      if (splitsStorage.usesSegments()) mySegmentsUpdaterTask.start();
+    },
+    // Stop periodic fetching (polling)
+    stop: function stop() {
+      running = false;
+      mySegmentsUpdaterTask.stop();
+    },
+    // Used by SyncManager to know if running in polling mode.
+    isRunning: isRunning,
+    // Used by MySegmentUpdateWorker
+    isSynchronizingMySegments: function isSynchronizingMySegments() {
+      return _isSynchronizingMySegments;
+    },
+    synchronizeMySegments: synchronizeMySegments
+  };
+};
+
+var _default = PartialBrowserProducer;
+exports.default = _default;

package/lib/producer/browser.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _task = _interopRequireDefault(require("./task"));
+
+var _SplitChanges = _interopRequireDefault(require("./updater/SplitChanges"));
+
+var _Partial = _interopRequireDefault(require("./browser/Partial"));
+
+/**
+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-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 = (0, _SplitChanges.default)(context);
+  var splitsUpdaterTask = (0, _task.default)(synchronizeSplits, settings.scheduler.featuresRefreshRate);
+  var mySegmentsProducer = (0, _Partial.default)(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
+  };
+};
+
+var _default = FullBrowserProducer;
+exports.default = _default;

package/lib/producer/fetcher/MySegments.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _timeout = _interopRequireDefault(require("../../utils/promise/timeout"));
+
+var _timeTracker = _interopRequireDefault(require("../../utils/timeTracker"));
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _mySegments = _interopRequireDefault(require("../../services/mySegments"));
+
+var _get = _interopRequireDefault(require("../../services/mySegments/get"));
+
+/**
+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 mySegmentsFetcher = function mySegmentsFetcher(settings, startingUp, metricCollectors, noCache) {
+  if (startingUp === void 0) {
+    startingUp = false;
+  }
+
+  var mySegmentsPromise = (0, _mySegments.default)((0, _get.default)(settings, noCache));
+  mySegmentsPromise = _timeTracker.default.start(_timeTracker.default.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise); // Decorate with the timeout functionality if required
+
+  if (startingUp) {
+    mySegmentsPromise = (0, _timeout.default)(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 _Errors.SplitError(error.message);
+    });
+  }).then(function (json) {
+    return json.mySegments.map(function (segment) {
+      return segment.name;
+    });
+  });
+};
+
+var _default = mySegmentsFetcher;
+exports.default = _default;

package/lib/producer/fetcher/SegmentChanges.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _segmentChanges = _interopRequireDefault(require("../../services/segmentChanges"));
+
+var _get = _interopRequireDefault(require("../../services/segmentChanges/get"));
+
+var _timeTracker = _interopRequireDefault(require("../../utils/timeTracker"));
+
+/**
+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.
+**/
+function greedyFetch(settings, lastSinceValue, segmentName, metricCollectors, noCache) {
+  return _timeTracker.default.start(_timeTracker.default.TaskNames.SEGMENTS_FETCH, metricCollectors, (0, _segmentChanges.default)((0, _get.default)(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);
+}
+
+var _default = segmentChangesFetcher;
+exports.default = _default;

package/lib/producer/fetcher/SplitChanges.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _timeout = _interopRequireDefault(require("../../utils/promise/timeout"));
+
+var _timeTracker = _interopRequireDefault(require("../../utils/timeTracker"));
+
+var _Errors = require("../../utils/lang/Errors");
+
+var _splitChanges = _interopRequireDefault(require("../../services/splitChanges"));
+
+var _get = _interopRequireDefault(require("../../services/splitChanges/get"));
+
+/**
+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.
+**/
+function splitChangesFetcher(settings, since, startingUp, metricCollectors, isNode, noCache) {
+  if (startingUp === void 0) {
+    startingUp = false;
+  }
+
+  var filterQueryString = settings.sync.__splitFiltersValidation.queryString;
+  var splitsPromise = (0, _splitChanges.default)((0, _get.default)(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 = _timeTracker.default.start(_timeTracker.default.TaskNames.SPLITS_FETCH, collectMetrics ? metricCollectors : false, splitsPromise);
+
+  if (startingUp) {
+    // Decorate with the timeout functionality if required
+    splitsPromise = (0, _timeout.default)(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 _Errors.SplitError(error.message);
+    });
+  });
+}
+
+var _default = splitChangesFetcher;
+exports.default = _default;