@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/integrations/node.js

@@ -0,0 +1,3 @@
+var integrationsManagerFactory = function integrationsManagerFactory() {};
+
+export default integrationsManagerFactory;

package/es/listeners/browser.js

@@ -0,0 +1,157 @@
+import eventsBulkRequest from '../services/events/bulk';
+import eventsService from '../services/events';
+import impressionsBulkRequest from '../services/impressions/bulk';
+import impressionsCountRequest from '../services/impressions/count';
+import impressionsService from '../services/impressions';
+import { fromImpressionsCollector, fromImpressionsCountCollector } from '../services/impressions/dto';
+import logFactory from '../utils/logger';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
+import objectAssign from 'object-assign';
+var log = logFactory('splitio-client:cleanup'); // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+
+var UNLOAD_DOM_EVENT = 'unload';
+/**
+ * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ *
+ */
+
+var BrowserSignalListener = /*#__PURE__*/function () {
+  function BrowserSignalListener(context, syncManager) {
+    this.storage = context.get(context.constants.STORAGE);
+    this.settings = context.get(context.constants.SETTINGS);
+    this.syncManager = syncManager;
+    this.flushData = this.flushData.bind(this);
+
+    if (this.settings.sync.impressionsMode === OPTIMIZED) {
+      this.impressionsCounter = context.get(context.constants.IMPRESSIONS_COUNTER);
+    }
+  }
+  /**
+   * start method.
+   * Called when SplitFactory is initialized.
+   * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+   */
+
+
+  var _proto = BrowserSignalListener.prototype;
+
+  _proto.start = function start() {
+    if (typeof window !== 'undefined' && window.addEventListener) {
+      log.debug('Registering flush handler when unload page event is triggered.');
+      window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+    }
+  }
+  /**
+   * stop method.
+   * Called when client is destroyed.
+   * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+   */
+  ;
+
+  _proto.stop = function stop() {
+    if (typeof window !== 'undefined' && window.removeEventListener) {
+      log.debug('Deregistering flush handler when unload page event is triggered.');
+      window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+    }
+  }
+  /**
+   * _flushData method.
+   * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
+   * using beacon API if possible, or falling back to regular post transport.
+   */
+  ;
+
+  _proto.flushData = function flushData() {
+    this._flushImpressions();
+
+    this._flushEvents();
+
+    if (this.impressionsCounter) {
+      this._flushImpressionsCount();
+    } // Close streaming
+
+
+    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
+  };
+
+  _proto._flushImpressions = function _flushImpressions() {
+    var impressions = this.storage.impressions; // if there are impressions in storage, send them to backend
+
+    if (!impressions.isEmpty()) {
+      var url = this.settings.url('/testImpressions/beacon');
+      var impressionsPayload = fromImpressionsCollector(impressions, this.settings);
+      var extraMetadata = {
+        // sim stands for Sync/Split Impressions Mode
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+      };
+
+      if (!this._sendBeacon(url, impressionsPayload, extraMetadata)) {
+        impressionsService(impressionsBulkRequest(this.settings, {
+          body: JSON.stringify(impressionsPayload)
+        }));
+      }
+
+      impressions.clear();
+    }
+  };
+
+  _proto._flushImpressionsCount = function _flushImpressionsCount() {
+    var impressionsCountPayload = {
+      pf: fromImpressionsCountCollector(this.impressionsCounter)
+    };
+    var imprCounts = impressionsCountPayload.pf.length;
+    if (imprCounts === 0) return;
+    var url = this.settings.url('/testImpressions/count/beacon');
+
+    if (!this._sendBeacon(url, impressionsCountPayload)) {
+      impressionsService(impressionsCountRequest(this.settings, {
+        body: JSON.stringify(impressionsCountPayload)
+      }));
+    }
+  };
+
+  _proto._flushEvents = function _flushEvents() {
+    var events = this.storage.events; // if there are events in storage, send them to backend
+
+    if (!events.isEmpty()) {
+      var url = this.settings.url('/events/beacon');
+      var eventsPayload = events.toJSON();
+
+      if (!this._sendBeacon(url, eventsPayload)) {
+        eventsService(eventsBulkRequest(this.settings, {
+          body: JSON.stringify(eventsPayload)
+        }));
+      }
+
+      events.clear();
+    }
+  }
+  /**
+   * _sendBeacon method.
+   * Util method that check if beacon API is available, build the payload and send it.
+   */
+  ;
+
+  _proto._sendBeacon = function _sendBeacon(url, data, extraMetadata) {
+    // eslint-disable-next-line compat/compat
+    if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
+      var json = {
+        entries: data,
+        token: this.settings.core.authorizationKey,
+        sdk: this.settings.version
+      }; // Extend with endpoint specific metadata where needed
+
+      if (extraMetadata) objectAssign(json, extraMetadata); // Stringify the payload
+
+      var payload = JSON.stringify(json); // eslint-disable-next-line compat/compat
+
+      return navigator.sendBeacon(url, payload);
+    }
+
+    return false;
+  };
+
+  return BrowserSignalListener;
+}();
+
+export { BrowserSignalListener as default };

package/es/listeners/node.js

@@ -0,0 +1,65 @@
+import logFactory from '../utils/logger';
+import thenable from '../utils/promise/thenable';
+var log = logFactory('splitio-client:cleanup');
+/**
+ * We'll listen for SIGTERM since it's the standard signal for server shutdown.
+ *
+ * If you're stopping the execution yourself via the keyboard, or by calling process.exit,
+ * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
+ * the process is already exiting.
+ */
+
+var NodeSignalListener = /*#__PURE__*/function () {
+  function NodeSignalListener() {
+    this._sigtermHandler = this._sigtermHandler.bind(this);
+  }
+
+  var _proto = NodeSignalListener.prototype;
+
+  _proto.start = function start(handler) {
+    this.handler = handler;
+    log.debug('Registering cleanup handlers.');
+    process.on('SIGTERM', this._sigtermHandler);
+  };
+
+  _proto.stop = function stop() {
+    log.debug('Deregistering cleanup handlers.');
+    process.removeListener('SIGTERM', this._sigtermHandler);
+  }
+  /**
+   * Call the handler, clean up listeners and emit the signal again.
+   */
+  ;
+
+  _proto._sigtermHandler = function _sigtermHandler() {
+    var _this = this;
+
+    var wrapUp = function wrapUp() {
+      // Cleaned up, remove handlers.
+      _this.stop(); // This handler prevented the default behaviour, start again.
+
+
+      process.kill(process.pid, 'SIGTERM');
+    };
+
+    log.debug('Split SDK graceful shutdown after SIGTERM.');
+    var handlerResult = null;
+
+    try {
+      handlerResult = this.handler();
+    } catch (err) {
+      log.error("Error with Split graceful shutdown: " + err);
+    }
+
+    if (thenable(handlerResult)) {
+      // Always exit, even with errors. The promise is returned for UT purposses.
+      return handlerResult.then(wrapUp).catch(wrapUp);
+    } else {
+      wrapUp();
+    }
+  };
+
+  return NodeSignalListener;
+}();
+
+export { NodeSignalListener as default };

package/es/manager/index.js

@@ -0,0 +1,104 @@
+import objectAssign from 'object-assign';
+import thenable from '../utils/promise/thenable';
+import { find } from '../utils/lang';
+import { validateSplit, validateSplitExistance, validateIfDestroyed, validateIfReady } from '../utils/inputValidation';
+
+var collectTreatments = function collectTreatments(splitObject) {
+  var conditions = splitObject.conditions; // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
+
+  var allTreatmentsCondition = find(conditions, function (cond) {
+    return cond.conditionType === 'ROLLOUT';
+  }); // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.
+
+  if (!allTreatmentsCondition) allTreatmentsCondition = conditions[0]; // Then extract the treatments from the partitions
+
+  return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) {
+    return v.treatment;
+  }) : [];
+};
+
+var ObjectToView = function ObjectToView(json) {
+  var splitObject;
+
+  try {
+    splitObject = JSON.parse(json);
+  } catch (e) {
+    return null;
+  }
+
+  if (splitObject == null) return null;
+  return {
+    name: splitObject.name,
+    trafficType: splitObject.trafficTypeName || null,
+    killed: splitObject.killed,
+    changeNumber: splitObject.changeNumber || 0,
+    treatments: collectTreatments(splitObject),
+    configs: splitObject.configurations || {}
+  };
+};
+
+var ObjectsToViews = function ObjectsToViews(jsons) {
+  var views = [];
+  jsons.forEach(function (split) {
+    var view = ObjectToView(split);
+    if (view != null) views.push(view);
+  });
+  return views;
+};
+
+function SplitManagerFactory(_splits, context) {
+  var SPLIT_FN_LABEL = 'split';
+  var statusManager = context.get(context.constants.STATUS_MANAGER);
+  return objectAssign( // Proto-linkage of the readiness Event Emitter
+  Object.create(statusManager), {
+    /**
+     * Get the Split object corresponding to the given split name if valid
+     */
+    split: function split(maybeSplitName) {
+      var splitName = validateSplit(maybeSplitName, SPLIT_FN_LABEL);
+
+      if (!validateIfDestroyed(context) || !validateIfReady(context, SPLIT_FN_LABEL) || !splitName) {
+        return null;
+      }
+
+      var split = _splits.getSplit(splitName);
+
+      if (thenable(split)) {
+        return split.then(function (result) {
+          validateSplitExistance(context, splitName, result, SPLIT_FN_LABEL);
+          return ObjectToView(result);
+        });
+      }
+
+      validateSplitExistance(context, splitName, split, SPLIT_FN_LABEL);
+      return ObjectToView(split);
+    },
+
+    /**
+     * Get the Split objects present on the factory storage
+     */
+    splits: function splits() {
+      if (!validateIfDestroyed(context) || !validateIfReady(context, 'splits')) {
+        return [];
+      }
+
+      var currentSplits = _splits.getAll();
+
+      if (thenable(currentSplits)) return currentSplits.then(ObjectsToViews);
+      return ObjectsToViews(currentSplits);
+    },
+
+    /**
+     * Get the Split names present on the factory storage
+     */
+    names: function names() {
+      if (!validateIfDestroyed(context) || !validateIfReady(context, 'names')) {
+        return [];
+      }
+
+      return _splits.getKeys();
+    }
+  });
+}
+
+export default SplitManagerFactory;

package/es/metrics/Collectors.js

@@ -0,0 +1,100 @@
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+var ProducerMetricsCollector = /*#__PURE__*/function () {
+  function ProducerMetricsCollector(storage) {
+    this.storage = storage;
+    this.latency = this.latency.bind(this);
+    this.count = this.count.bind(this);
+    this.countException = this.countException.bind(this);
+  }
+
+  var _proto = ProducerMetricsCollector.prototype;
+
+  _proto.latency = function latency(ms) {
+    this.storage.metrics.track(this.metricType + ".time", ms);
+  };
+
+  _proto.count = function count(status) {
+    this.storage.count.track(this.metricType + ".status." + status);
+  };
+
+  _proto.countException = function countException() {
+    this.storage.count.track(this.metricType + ".exception");
+  };
+
+  return ProducerMetricsCollector;
+}();
+
+export var SegmentChangesCollector = /*#__PURE__*/function (_ProducerMetricsColle) {
+  _inheritsLoose(SegmentChangesCollector, _ProducerMetricsColle);
+
+  function SegmentChangesCollector(storage) {
+    var _this;
+
+    _this = _ProducerMetricsColle.call(this, storage) || this;
+    _this.metricType = 'segmentChangeFetcher';
+    return _this;
+  }
+
+  return SegmentChangesCollector;
+}(ProducerMetricsCollector);
+export var SplitChangesCollector = /*#__PURE__*/function (_ProducerMetricsColle2) {
+  _inheritsLoose(SplitChangesCollector, _ProducerMetricsColle2);
+
+  function SplitChangesCollector(storage) {
+    var _this2;
+
+    _this2 = _ProducerMetricsColle2.call(this, storage) || this;
+    _this2.metricType = 'splitChangeFetcher';
+    return _this2;
+  }
+
+  return SplitChangesCollector;
+}(ProducerMetricsCollector);
+export var MySegmentsCollector = /*#__PURE__*/function (_ProducerMetricsColle3) {
+  _inheritsLoose(MySegmentsCollector, _ProducerMetricsColle3);
+
+  function MySegmentsCollector(storage) {
+    var _this3;
+
+    _this3 = _ProducerMetricsColle3.call(this, storage) || this;
+    _this3.metricType = 'mySegmentsFetcher';
+    return _this3;
+  }
+
+  return MySegmentsCollector;
+}(ProducerMetricsCollector);
+export var ClientCollector = /*#__PURE__*/function () {
+  function ClientCollector(storage) {
+    this.storage = storage;
+    this.ready = this.ready.bind(this);
+    this.getTreatment = this.getTreatment.bind(this);
+    this.getTreatments = this.getTreatments.bind(this);
+    this.getTreatmentWithConfig = this.getTreatmentWithConfig.bind(this);
+    this.getTreatmentsWithConfig = this.getTreatmentsWithConfig.bind(this);
+  }
+
+  var _proto2 = ClientCollector.prototype;
+
+  _proto2.ready = function ready(ms) {
+    this.storage.metrics.track('sdk.ready', ms);
+  };
+
+  _proto2.getTreatment = function getTreatment(ms) {
+    this.storage.metrics.track('sdk.getTreatment', ms);
+  };
+
+  _proto2.getTreatments = function getTreatments(ms) {
+    this.storage.metrics.track('sdk.getTreatments', ms);
+  };
+
+  _proto2.getTreatmentWithConfig = function getTreatmentWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentWithConfig', ms);
+  };
+
+  _proto2.getTreatmentsWithConfig = function getTreatmentsWithConfig(ms) {
+    this.storage.metrics.track('sdk.getTreatmentsWithConfig', ms);
+  };
+
+  return ClientCollector;
+}();

package/es/metrics/index.js

@@ -0,0 +1,157 @@
+/**
+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 tracker from '../utils/timeTracker';
+import repeat from '../utils/fn/repeat';
+import metricsService from '../services/metrics';
+import metricsTimesServiceRequest from '../services/metrics/times';
+import metricsCountersServiceRequest from '../services/metrics/counters';
+import { fromLatenciesCollector, fromCountersCollector } from '../services/metrics/dto';
+import impressionsService from '../services/impressions';
+import impressionsBulkRequest from '../services/impressions/bulk';
+import impressionsCountRequest from '../services/impressions/count';
+import { fromImpressionsCollector, fromImpressionsCountCollector } from '../services/impressions/dto';
+import { SegmentChangesCollector, SplitChangesCollector, MySegmentsCollector, ClientCollector } from './Collectors';
+import { OPTIMIZED } from '../utils/constants';
+var log = logFactory('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 === OPTIMIZED;
+
+  var pushMetrics = function pushMetrics() {
+    if (storage.metrics.isEmpty() && storage.count.isEmpty()) return Promise.resolve();
+    log.debug('Pushing metrics');
+    var latencyTrackerStop = tracker.start(tracker.TaskNames.METRICS_PUSH); // POST latencies
+
+    var latenciesPromise = storage.metrics.isEmpty() ? null : metricsService(metricsTimesServiceRequest(settings, {
+      body: JSON.stringify(fromLatenciesCollector(storage.metrics))
+    })).then(function () {
+      return storage.metrics.clear();
+    }).catch(function () {
+      return storage.metrics.clear();
+    }); // POST counters
+
+    var countersPromise = storage.count.isEmpty() ? null : metricsService(metricsCountersServiceRequest(settings, {
+      body: JSON.stringify(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 = tracker.start(tracker.TaskNames.IMPRESSIONS_PUSH);
+    return impressionsService(impressionsBulkRequest(settings, {
+      body: JSON.stringify(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 = fromImpressionsCountCollector(impressionsCounter);
+    var imprCounts = pf.length;
+    if (imprCounts === 0) return Promise.resolve();
+    log.info("Pushing count of impressions for " + imprCounts + " features");
+    return impressionsService(impressionsCountRequest(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 = repeat(function (schedulePublisher) {
+        return pushImpressions().then(function () {
+          return schedulePublisher();
+        });
+      }, settings.scheduler.impressionsRefreshRate);
+      stopPerformancePublisher = repeat(function (schedulePublisher) {
+        return pushMetrics().then(function () {
+          return schedulePublisher();
+        });
+      }, settings.scheduler.metricsRefreshRate);
+
+      if (shouldPushImpressionsCount) {
+        stopImpressionsCountPublisher = repeat(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 SegmentChangesCollector(storage),
+      splitChanges: new SplitChangesCollector(storage),
+      mySegments: new MySegmentsCollector(storage),
+      client: new ClientCollector(storage)
+    }
+  };
+};
+
+export default MetricsFactory;

package/es/producer/browser/Partial.js

@@ -0,0 +1,103 @@
+/**
+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 MySegmentsUpdater from '../updater/MySegments';
+import logFactory from '../../utils/logger';
+var log = logFactory('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 = MySegmentsUpdater(context);
+  var mySegmentsUpdaterTask = TaskFactory(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
+  };
+};
+
+export default PartialBrowserProducer;