@splitsoftware/splitio-commons 1.5.0 → 1.5.1-rc.2

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -1,58 +1,57 @@
 import { Backoff } from '../../../utils/Backoff';
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-var MySegmentsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-     */
-    function MySegmentsUpdateWorker(mySegmentsSyncTask) {
-        this.mySegmentsSyncTask = mySegmentsSyncTask;
-        this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-        this.handleNewEvent = false;
-        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-        this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
-        this.put = this.put.bind(this);
-        this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
-        this.backoff = new Backoff(this.__handleMySegmentsUpdateCall);
-    }
-    // Private method
-    // Precondition: this.mySegmentsSyncTask.isSynchronizingMySegments === false
-    MySegmentsUpdateWorker.prototype.__handleMySegmentsUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.currentChangeNumber) {
-            this.handleNewEvent = false;
-            var currentMaxChangeNumber_1 = this.maxChangeNumber;
+export function MySegmentsUpdateWorker(mySegmentsSyncTask) {
+    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+    var currentChangeNumber = -1;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+    var backoff = new Backoff(__handleMySegmentsUpdateCall);
+    function __handleMySegmentsUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > currentChangeNumber) {
+            handleNewEvent = false;
+            var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
+            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
+                if (!isHandlingEvent)
+                    return; // halt if `stop` has been called
                 if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-                    _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-                if (_this.handleNewEvent) {
-                    _this.__handleMySegmentsUpdateCall();
+                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                if (handleNewEvent) {
+                    __handleMySegmentsUpdateCall();
                 }
                 else {
-                    _this.backoff.scheduleCall();
+                    backoff.scheduleCall();
                 }
             });
         }
+        else {
+            isHandlingEvent = false;
+        }
+    }
+    return {
+        /**
+         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+         *
+         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
+         * @param {SegmentsData | undefined} segmentsData might be undefined
+         */
+        put: function (changeNumber, segmentsData) {
+            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                return;
+            maxChangeNumber = changeNumber;
+            handleNewEvent = true;
+            _segmentsData = segmentsData;
+            if (backoff.timeoutID || !isHandlingEvent)
+                __handleMySegmentsUpdateCall();
+            backoff.reset();
+        },
+        stop: function () {
+            isHandlingEvent = false;
+            backoff.reset();
+        }
     };
-    /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-     *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
-     */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
-        if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        this.segmentsData = segmentsData;
-        if (this.mySegmentsSyncTask.isExecuting())
-            return;
-        this.__handleMySegmentsUpdateCall();
-    };
-    return MySegmentsUpdateWorker;
-}());
-export { MySegmentsUpdateWorker };
+}

package/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -1,71 +1,88 @@
 import { Backoff } from '../../../utils/Backoff';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_RETRIES, FETCH_BACKOFF_MAX_WAIT } from './constants';
 /**
- * SegmentUpdateWorker class
+ * SegmentsUpdateWorker factory
  */
-var SegmentsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} segmentsCache segments data cache
-     * @param {Object} segmentsSyncTask task for syncing segments data
-     */
-    function SegmentsUpdateWorker(segmentsSyncTask, segmentsCache) {
-        this.segmentsCache = segmentsCache;
-        this.segmentsSyncTask = segmentsSyncTask;
-        this.maxChangeNumbers = {};
-        this.handleNewEvent = false;
-        this.put = this.put.bind(this);
-        this.__handleSegmentUpdateCall = this.__handleSegmentUpdateCall.bind(this);
-        this.backoff = new Backoff(this.__handleSegmentUpdateCall);
+export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
+    // Handles retries with CDN bypass per segment name
+    function SegmentUpdateWorker(segment) {
+        var maxChangeNumber = 0;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+        function __handleSegmentUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+                handleNewEvent = false;
+                // fetch segments revalidating data if cached
+                segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (handleNewEvent) {
+                        __handleSegmentUpdateCall();
+                    }
+                    else {
+                        var attempts = backoff.attempts + 1;
+                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleSegmentUpdateCall();
+                        }
+                    }
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
+        }
+        return {
+            put: function (changeNumber) {
+                var currentChangeNumber = segmentsCache.getChangeNumber(segment);
+                if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                    return;
+                maxChangeNumber = changeNumber;
+                handleNewEvent = true;
+                cdnBypass = false;
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleSegmentUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                isHandlingEvent = false;
+                backoff.reset();
+            }
+        };
     }
-    // Private method
-    // Precondition: this.segmentsSyncTask.isSynchronizingSegments === false
-    // Approach similar to MySegmentsUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
-    SegmentsUpdateWorker.prototype.__handleSegmentUpdateCall = function () {
-        var _this = this;
-        var segmentsToFetch = Object.keys(this.maxChangeNumbers).filter(function (segmentName) {
-            return _this.maxChangeNumbers[segmentName] > _this.segmentsCache.getChangeNumber(segmentName);
-        });
-        if (segmentsToFetch.length > 0) {
-            this.handleNewEvent = false;
-            var currentMaxChangeNumbers_1 = segmentsToFetch.map(function (segmentToFetch) { return _this.maxChangeNumbers[segmentToFetch]; });
-            // fetch segments revalidating data if cached
-            this.segmentsSyncTask.execute(segmentsToFetch, true).then(function (result) {
-                // Unlike `SplitUpdateWorker` where changeNumber is consistent between notification and endpoint, if there is no error,
-                // we must clean the `maxChangeNumbers` of those segments that didn't receive a new update notification during the fetch.
-                if (result !== false) {
-                    segmentsToFetch.forEach(function (fetchedSegment, index) {
-                        if (_this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers_1[index])
-                            _this.maxChangeNumbers[fetchedSegment] = -1;
-                    });
-                }
-                else {
-                    // recursive invocation with backoff if there was some error
-                    _this.backoff.scheduleCall();
-                }
-                // immediate recursive invocation if a new notification was queued during fetch
-                if (_this.handleNewEvent) {
-                    _this.__handleSegmentUpdateCall();
-                }
-            });
+    var segments = {};
+    return {
+        /**
+         * Invoked by NotificationProcessor on SEGMENT_UPDATE event
+         *
+         * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
+         * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
+         */
+        put: function (_a) {
+            var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
+            if (!segments[segmentName])
+                segments[segmentName] = SegmentUpdateWorker(segmentName);
+            segments[segmentName].put(changeNumber);
+        },
+        stop: function () {
+            Object.keys(segments).forEach(function (segmentName) { return segments[segmentName].stop(); });
         }
     };
-    /**
-     * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-     *
-     * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-     * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
-     */
-    SegmentsUpdateWorker.prototype.put = function (_a) {
-        var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
-        var currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
-        if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName])
-            return;
-        this.maxChangeNumbers[segmentName] = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        if (this.segmentsSyncTask.isExecuting())
-            return;
-        this.__handleSegmentUpdateCall();
-    };
-    return SegmentsUpdateWorker;
-}());
-export { SegmentsUpdateWorker };
+}

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -1,79 +1,94 @@
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-var SplitsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} splitsCache splits data cache
-     * @param {Object} splitsSyncTask task for syncing splits data
-     * @param {Object} splitsEventEmitter emitter for splits data events
-     */
-    function SplitsUpdateWorker(splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
-        this.splitsCache = splitsCache;
-        this.splitsSyncTask = splitsSyncTask;
-        this.splitsEventEmitter = splitsEventEmitter;
-        this.segmentsSyncTask = segmentsSyncTask;
-        this.maxChangeNumber = 0;
-        this.handleNewEvent = false;
-        this.put = this.put.bind(this);
-        this.killSplit = this.killSplit.bind(this);
-        this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
-        this.backoff = new Backoff(this.__handleSplitUpdateCall);
-    }
-    // Private method
-    // Preconditions: this.splitsSyncTask.isSynchronizingSplits === false
-    SplitsUpdateWorker.prototype.__handleSplitUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.splitsCache.getChangeNumber()) {
-            this.handleNewEvent = false;
+export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+    var maxChangeNumber = 0;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var cdnBypass;
+    var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+    function __handleSplitUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > splitsCache.getChangeNumber()) {
+            handleNewEvent = false;
             // fetch splits revalidating data if cached
-            this.splitsSyncTask.execute(true).then(function () {
-                if (_this.handleNewEvent) {
-                    _this.__handleSplitUpdateCall();
+            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+                if (!isHandlingEvent)
+                    return; // halt if `stop` has been called
+                if (handleNewEvent) {
+                    __handleSplitUpdateCall();
                 }
                 else {
                     // fetch new registered segments for server-side API. Not retrying on error
-                    if (_this.segmentsSyncTask)
-                        _this.segmentsSyncTask.execute(undefined, false, true);
-                    _this.backoff.scheduleCall();
+                    if (segmentsSyncTask)
+                        segmentsSyncTask.execute(true);
+                    var attempts = backoff.attempts + 1;
+                    if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+                        log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                        isHandlingEvent = false;
+                        return;
+                    }
+                    if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+                        backoff.scheduleCall();
+                        return;
+                    }
+                    if (cdnBypass) {
+                        log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                        isHandlingEvent = false;
+                    }
+                    else {
+                        backoff.reset();
+                        cdnBypass = true;
+                        __handleSplitUpdateCall();
+                    }
                 }
             });
         }
-    };
+        else {
+            isHandlingEvent = false;
+        }
+    }
     /**
      * Invoked by NotificationProcessor on SPLIT_UPDATE event
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (_a) {
+    function put(_a) {
         var changeNumber = _a.changeNumber;
-        var currentChangeNumber = this.splitsCache.getChangeNumber();
-        if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        if (this.splitsSyncTask.isExecuting())
+        var currentChangeNumber = splitsCache.getChangeNumber();
+        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
             return;
-        this.__handleSplitUpdateCall();
-    };
-    /**
-     * Invoked by NotificationProcessor on SPLIT_KILL event
-     *
-     * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-     * @param {string} splitName name of split to kill
-     * @param {string} defaultTreatment default treatment value
-     */
-    SplitsUpdateWorker.prototype.killSplit = function (_a) {
-        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-        if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
-            // trigger an SDK_UPDATE if Split was killed locally
-            this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
+        maxChangeNumber = changeNumber;
+        handleNewEvent = true;
+        cdnBypass = false;
+        if (backoff.timeoutID || !isHandlingEvent)
+            __handleSplitUpdateCall();
+        backoff.reset();
+    }
+    return {
+        put: put,
+        /**
+         * Invoked by NotificationProcessor on SPLIT_KILL event
+         *
+         * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+         * @param {string} splitName name of split to kill
+         * @param {string} defaultTreatment default treatment value
+         */
+        killSplit: function (_a) {
+            var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
+            if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+                // trigger an SDK_UPDATE if Split was killed locally
+                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
+            }
+            // queues the SplitChanges fetch (only if changeNumber is newer)
+            put({ changeNumber: changeNumber });
+        },
+        stop: function () {
+            isHandlingEvent = false;
+            backoff.reset();
         }
-        // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put({ changeNumber: changeNumber });
     };
-    return SplitsUpdateWorker;
-}());
-export { SplitsUpdateWorker };
+}

package/esm/sync/streaming/UpdateWorkers/constants.js

@@ -0,0 +1,3 @@
+export var FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds
+export var FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute
+export var FETCH_BACKOFF_MAX_RETRIES = 10; // max retries

package/esm/sync/streaming/pushManager.js

@@ -42,9 +42,9 @@ export function pushManagerFactory(params, pollingManager) {
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+    var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -137,21 +137,20 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.backoff.reset();
+        splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
-                return worker.backoff.reset();
+                return worker.stop();
             });
         else
-            segmentsUpdateWorker.backoff.reset();
+            segmentsUpdateWorker.stop();
     }
     pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
     // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
     // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
     pushEmitter.on(PUSH_SUBSYSTEM_UP, function () {
         connectPushRetryBackoff.reset();
-        stopWorkers();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
     pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
@@ -287,7 +286,7 @@ export function pushManagerFactory(params, pollingManager) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
+                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/esm/sync/syncTask.js

@@ -1,8 +1,7 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
 /**
- * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
- * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
+ * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
+ * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -12,8 +11,10 @@ import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/co
  */
 export function syncTaskFactory(log, task, period, taskName) {
     if (taskName === void 0) { taskName = 'task'; }
-    // Task promise while it is pending. Undefined once the promise is resolved
-    var pendingTask;
+    // Flag that indicates if the task is executing
+    var executing = 0;
+    // Promise chain to resolve tasks sequentially
+    var promiseChain;
     // flag that indicates if the task periodic execution has been started/stopped.
     var running = false;
     // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -27,19 +28,15 @@ export function syncTaskFactory(log, task, period, taskName) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        // If task is executing, chain the new execution
-        if (pendingTask) {
-            return pendingTask.then(function () {
-                return execute.apply(void 0, args);
-            });
-        }
-        // Execute task
+        executing++;
         log.debug(SYNC_TASK_EXECUTE, [taskName]);
-        pendingTask = task.apply(void 0, args).then(function (result) {
-            pendingTask = undefined;
+        // Update `promiseChain` with last promise, to run tasks serially
+        promiseChain = (promiseChain ? promiseChain.then(function () { return task.apply(void 0, args); }) : task.apply(void 0, args))
+            .then(function (result) {
+            executing--;
             return result;
         });
-        return pendingTask;
+        return promiseChain;
     }
     function periodicExecute(currentRunningId) {
         return execute.apply(void 0, runningArgs).then(function (result) {
@@ -53,7 +50,7 @@ export function syncTaskFactory(log, task, period, taskName) {
     return {
         execute: execute,
         isExecuting: function () {
-            return pendingTask !== undefined;
+            return executing > 0;
         },
         start: function () {
             var args = [];

package/esm/utils/Backoff.js

@@ -7,8 +7,8 @@ var Backoff = /** @class */ (function () {
      * @param {number} maxMillis
      */
     function Backoff(cb, baseMillis, maxMillis) {
-        this.baseMillis = baseMillis || Backoff.DEFAULT_BASE_MILLIS;
-        this.maxMillis = maxMillis || Backoff.DEFAULT_MAX_MILLIS;
+        this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
+        this.maxMillis = Backoff.__TEST__MAX_MILLIS || maxMillis || Backoff.DEFAULT_MAX_MILLIS;
         this.attempts = 0;
         this.cb = cb;
     }
@@ -22,6 +22,7 @@ var Backoff = /** @class */ (function () {
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
         this.timeoutID = setTimeout(function () {
+            _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
         this.attempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.5.0",
+  "version": "1.5.1-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -47,13 +47,9 @@
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
-    "js-yaml": "^3.13.1",
     "ioredis": "^4.28.0"
   },
   "peerDependenciesMeta": {
-    "js-yaml": {
-      "optional": true
-    },
     "ioredis": {
       "optional": true
     }