@splitsoftware/splitio-commons 2.8.1-rc.0 → 2.8.1-rc.1

package/esm/evaluator/index.js

@@ -16,7 +16,7 @@ function treatmentsException(splitNames) {
     });
     return evaluations;
 }
-export function evaluateFeature(log, key, splitName, attributes, storage) {
+export function evaluateFeature(log, key, splitName, attributes, storage, options) {
     var parsedSplit;
     try {
         parsedSplit = storage.splits.getSplit(splitName);
@@ -26,14 +26,14 @@ export function evaluateFeature(log, key, splitName, attributes, storage) {
         return treatmentException;
     }
     if (thenable(parsedSplit)) {
-        return parsedSplit.then(function (split) { return getEvaluation(log, key, split, attributes, storage); }).catch(
+        return parsedSplit.then(function (split) { return getEvaluation(log, key, split, attributes, storage, options); }).catch(
         // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         function () { return treatmentException; });
     }
-    return getEvaluation(log, key, parsedSplit, attributes, storage);
+    return getEvaluation(log, key, parsedSplit, attributes, storage, options);
 }
-export function evaluateFeatures(log, key, splitNames, attributes, storage) {
+export function evaluateFeatures(log, key, splitNames, attributes, storage, options) {
     var parsedSplits;
     try {
         parsedSplits = storage.splits.getSplits(splitNames);
@@ -43,15 +43,15 @@ export function evaluateFeatures(log, key, splitNames, attributes, storage) {
         return treatmentsException(splitNames);
     }
     return thenable(parsedSplits) ?
-        parsedSplits.then(function (splits) { return getEvaluations(log, key, splitNames, splits, attributes, storage); })
+        parsedSplits.then(function (splits) { return getEvaluations(log, key, splitNames, splits, attributes, storage, options); })
             .catch(function () {
             // Exception on async `getSplits` storage. For example, when the storage is redis or
             // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
             return treatmentsException(splitNames);
         }) :
-        getEvaluations(log, key, splitNames, parsedSplits, attributes, storage);
+        getEvaluations(log, key, splitNames, parsedSplits, attributes, storage, options);
 }
-export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
+export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method, options) {
     var storedFlagNames;
     function evaluate(featureFlagsByFlagSets) {
         var featureFlags = new Set();
@@ -65,7 +65,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
             {};
     }
     // get features by flag sets
@@ -84,7 +84,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
         }) :
         evaluate(storedFlagNames);
 }
-function getEvaluation(log, key, splitJSON, attributes, storage) {
+function getEvaluation(log, key, splitJSON, attributes, storage, options) {
     var evaluation = {
         treatment: CONTROL,
         label: SPLIT_NOT_FOUND,
@@ -98,23 +98,23 @@ function getEvaluation(log, key, splitJSON, attributes, storage) {
             return evaluation.then(function (result) {
                 result.changeNumber = splitJSON.changeNumber;
                 result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
-                result.impressionsDisabled = splitJSON.impressionsDisabled;
+                result.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || splitJSON.impressionsDisabled;
                 return result;
             });
         }
         else {
             evaluation.changeNumber = splitJSON.changeNumber;
             evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
-            evaluation.impressionsDisabled = splitJSON.impressionsDisabled;
+            evaluation.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || splitJSON.impressionsDisabled;
         }
     }
     return evaluation;
 }
-function getEvaluations(log, key, splitNames, splits, attributes, storage) {
+function getEvaluations(log, key, splitNames, splits, attributes, storage, options) {
     var result = {};
     var thenables = [];
     splitNames.forEach(function (splitName) {
-        var evaluation = getEvaluation(log, key, splits[splitName], attributes, storage);
+        var evaluation = getEvaluation(log, key, splits[splitName], attributes, storage, options);
         if (thenable(evaluation)) {
             thenables.push(evaluation.then(function (res) {
                 result[splitName] = res;

package/esm/sdkClient/client.js

@@ -42,7 +42,7 @@ export function clientFactory(params) {
             return treatment;
         };
         var evaluation = readinessManager.isReadyFromCache() ?
-            evaluateFeature(log, key, featureFlagName, attributes, storage) :
+            evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentNotReady) :
                 treatmentNotReady;
@@ -67,7 +67,7 @@ export function clientFactory(params) {
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
+            evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentsNotReady(featureFlagNames)) :
                 treatmentsNotReady(featureFlagNames);
@@ -93,7 +93,7 @@ export function clientFactory(params) {
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
+            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
             isAsync ?
                 Promise.resolve({}) :
                 {};

package/esm/storages/AbstractMySegmentsCacheSync.js

@@ -20,45 +20,37 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
-        var isDiff = false;
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
         if (added && removed) {
+            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff = _this.addSegment(segment) || isDiff;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff = _this.removeSegment(segment) || isDiff;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
+            return isDiff_1;
         }
-        else {
-            var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-            var storedSegmentKeys = this.getRegisteredSegments().sort();
-            // Extreme fast => everything is empty
-            if (!names.length && !storedSegmentKeys.length) {
-                isDiff = false;
-            }
-            else {
-                var index = 0;
-                while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-                    index++;
-                // Quick path => no changes
-                if (index === names.length && index === storedSegmentKeys.length) {
-                    isDiff = false;
-                }
-                else {
-                    // Slowest path => add and/or remove segments
-                    for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-                        this.removeSegment(storedSegmentKeys[removeIndex]);
-                    }
-                    for (var addIndex = index; addIndex < names.length; addIndex++) {
-                        this.addSegment(names[addIndex]);
-                    }
-                    isDiff = true;
-                }
-            }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
-        this.setChangeNumber(segmentsData.cn);
-        return isDiff;
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+        }
+        return true;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/esm/storages/AbstractSplitsCacheSync.js

@@ -9,10 +9,9 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
     }
     AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import { DEFINED } from './constants';
+import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
     function MySegmentsCacheInLocal(log, keys, storage) {
@@ -10,20 +10,33 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         _this.keys = keys;
         _this.storage = storage;
         return _this;
+        // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
     MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (this.storage.getItem(segmentKey) === DEFINED)
+        try {
+            if (this.storage.getItem(segmentKey) === DEFINED)
+                return false;
+            this.storage.setItem(segmentKey, DEFINED);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
             return false;
-        this.storage.setItem(segmentKey, DEFINED);
-        return true;
+        }
     };
     MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (this.storage.getItem(segmentKey) !== DEFINED)
+        try {
+            if (this.storage.getItem(segmentKey) !== DEFINED)
+                return false;
+            this.storage.removeItem(segmentKey);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
             return false;
-        this.storage.removeItem(segmentKey);
-        return true;
+        }
     };
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
@@ -41,10 +54,15 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return 1;
     };
     MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        if (changeNumber)
-            this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-        else
-            this.storage.removeItem(this.keys.buildTillKey());
+        try {
+            if (changeNumber)
+                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+            else
+                this.storage.removeItem(this.keys.buildTillKey());
+        }
+        catch (e) {
+            this.log.error(e);
+        }
     };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -15,10 +15,9 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
@@ -38,28 +37,40 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
             this.storage.removeItem(segmentsCountKey);
     };
     RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
-        var name = rbSegment.name;
-        var rbSegmentKey = this.keys.buildRBSegmentKey(name);
-        var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-        var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
-        this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
-        var usesSegmentsDiff = 0;
-        if (previous && usesSegments(previous))
-            usesSegmentsDiff--;
-        if (usesSegments(rbSegment))
-            usesSegmentsDiff++;
-        if (usesSegmentsDiff !== 0)
-            this.updateSegmentCount(usesSegmentsDiff);
-        return true;
+        try {
+            var name_1 = rbSegment.name;
+            var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
+            var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+            var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
+            this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+            var usesSegmentsDiff = 0;
+            if (previous && usesSegments(previous))
+                usesSegmentsDiff--;
+            if (usesSegments(rbSegment))
+                usesSegmentsDiff++;
+            if (usesSegmentsDiff !== 0)
+                this.updateSegmentCount(usesSegmentsDiff);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
+        }
     };
     RBSegmentsCacheInLocal.prototype.remove = function (name) {
-        var rbSegment = this.get(name);
-        if (!rbSegment)
+        try {
+            var rbSegment = this.get(name);
+            if (!rbSegment)
+                return false;
+            this.storage.removeItem(this.keys.buildRBSegmentKey(name));
+            if (usesSegments(rbSegment))
+                this.updateSegmentCount(-1);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
             return false;
-        this.storage.removeItem(this.keys.buildRBSegmentKey(name));
-        if (usesSegments(rbSegment))
-            this.updateSegmentCount(-1);
-        return true;
+        }
     };
     RBSegmentsCacheInLocal.prototype.getNames = function () {
         var len = this.storage.length;

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -67,27 +67,39 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         this.hasSync = false;
     };
     SplitsCacheInLocal.prototype.addSplit = function (split) {
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        var splitFromStorage = this.storage.getItem(splitKey);
-        var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-        if (previousSplit) {
-            this._decrementCounts(previousSplit);
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+        try {
+            var name_1 = split.name;
+            var splitKey = this.keys.buildSplitKey(name_1);
+            var splitFromStorage = this.storage.getItem(splitKey);
+            var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
+            if (previousSplit) {
+                this._decrementCounts(previousSplit);
+                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+            }
+            this.storage.setItem(splitKey, JSON.stringify(split));
+            this._incrementCounts(split);
+            this.addToFlagSets(split);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
         }
-        this.storage.setItem(splitKey, JSON.stringify(split));
-        this._incrementCounts(split);
-        this.addToFlagSets(split);
-        return true;
     };
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        var split = this.getSplit(name);
-        if (!split)
+        try {
+            var split = this.getSplit(name);
+            if (!split)
+                return false;
+            this.storage.removeItem(this.keys.buildSplitKey(name));
+            this._decrementCounts(split);
+            this.removeFromFlagSets(split.name, split.sets);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
             return false;
-        this.storage.removeItem(this.keys.buildSplitKey(name));
-        this._decrementCounts(split);
-        this.removeFromFlagSets(split.name, split.sets);
-        return true;
+        }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
         var item = this.storage.getItem(this.keys.buildSplitKey(name));
@@ -159,8 +171,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromStorage = _this.storage.getItem(flagSetKey);
             var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-            if (flagSetCache.has(featureFlag.name))
-                return;
             flagSetCache.add(featureFlag.name);
             _this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
         });

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -13,10 +13,9 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     };
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.changeNumber = changeNumber;
-        return updated;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
     };
     RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
         var name = rbSegment.name;

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -1,5 +1,5 @@
 import { isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
+import { LOG_PREFIX } from '../inLocalStorage/constants';
 var SegmentsCacheInRedis = /** @class */ (function () {
     function SegmentsCacheInRedis(log, keys, redis) {
         this.log = log;

package/esm/sync/polling/syncTasks/segmentsSyncTask.js

@@ -5,5 +5,5 @@ import { segmentChangesUpdaterFactory } from '../updaters/segmentChangesUpdater'
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
 export function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -45,9 +45,9 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
             mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(function (segments) {
-                updateSegments(segments);
-                // Only when we have downloaded and stored segments completely, we should not keep retrying anymore
+                // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
+                updateSegments(segments);
                 return true;
             });
         return updaterPromise.catch(function (error) {

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -1,6 +1,5 @@
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { timeout } from '../../../utils/promise/timeout';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -12,33 +11,22 @@ import { timeout } from '../../../utils/promise/timeout';
  * @param segments - segments storage, with sync or async methods
  * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
  */
-export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
-    function _promiseDecorator(promise) {
-        if (readyOnAlreadyExistentState && requestTimeoutBeforeReady)
-            promise = timeout(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
             return fetchOnlyNew && since !== undefined ?
                 false :
-                segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
+                segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
                         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });
-                }).catch(function (error) {
-                    if (retries) {
-                        log.warn(LOG_PREFIX_SYNC_SEGMENTS + "Retrying fetch of segment " + segmentName + " (attempt #" + retries + "). Reason: " + error);
-                        return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
-                    }
-                    throw error;
                 });
         });
     }
@@ -58,7 +46,8 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0); });
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -130,6 +130,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                     { rbs: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
                 splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
                 .then(function (splitChanges) {
+                startingUp = false;
                 var usedSegments = new Set();
                 var ffUpdate = false;
                 if (splitChanges.ff) {
@@ -150,7 +151,6 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                     var ffChanged = _a[0], rbsChanged = _a[1];
                     if (storage.save)
                         storage.save();
-                    startingUp = false;
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
@@ -166,14 +166,14 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                 });
             })
                 .catch(function (error) {
+                log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
                 if (startingUp && retriesOnFailureBeforeReady > retry) {
                     retry += 1;
-                    log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
+                    log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
                     return _splitChangesUpdater(sinces, retry);
                 }
                 else {
                     startingUp = false;
-                    log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
                 }
                 return false;
             });

package/esm/utils/inputValidation/eventProperties.js

@@ -1,3 +1,4 @@
+import { __assign } from "tslib";
 import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
 import { objectAssign } from '../lang/objectAssign';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
@@ -60,7 +61,11 @@ export function validateEventProperties(log, maybeProperties, method) {
 export function validateEvaluationOptions(log, maybeOptions, method) {
     if (isObject(maybeOptions)) {
         var properties = validateEventProperties(log, maybeOptions.properties, method).properties;
-        return properties && Object.keys(properties).length > 0 ? { properties: properties } : undefined;
+        var options = properties && Object.keys(properties).length > 0 ? { properties: properties } : undefined;
+        var impressionsDisabled = maybeOptions.impressionsDisabled;
+        if (!impressionsDisabled)
+            return options;
+        return options ? __assign(__assign({}, options), { impressionsDisabled: impressionsDisabled }) : { impressionsDisabled: impressionsDisabled };
     }
     else if (maybeOptions) {
         log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.8.1-rc.0",
+  "version": "2.8.1-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",