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

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -15,9 +15,10 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        this.setChangeNumber(changeNumber);
         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;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
@@ -37,40 +38,28 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
             this.storage.removeItem(segmentsCountKey);
     };
     RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
-        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;
-        }
+        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;
     };
     RBSegmentsCacheInLocal.prototype.remove = function (name) {
-        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);
+        var rbSegment = this.get(name);
+        if (!rbSegment)
             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,39 +67,27 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         this.hasSync = false;
     };
     SplitsCacheInLocal.prototype.addSplit = function (split) {
-        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;
+        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);
         }
+        this.storage.setItem(splitKey, JSON.stringify(split));
+        this._incrementCounts(split);
+        this.addToFlagSets(split);
+        return true;
     };
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
-        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);
+        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;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
         var item = this.storage.getItem(this.keys.buildSplitKey(name));
@@ -171,6 +159,8 @@ 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,9 +13,10 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     };
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        this.changeNumber = changeNumber;
         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;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+        this.changeNumber = changeNumber;
+        return 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 '../inLocalStorage/constants';
+import { LOG_PREFIX } from './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.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), 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) {
-                // Only when we have downloaded segments completely, we should not keep retrying anymore
-                startingUp = false;
                 updateSegments(segments);
+                // Only when we have downloaded and stored segments completely, we should not keep retrying anymore
+                startingUp = false;
                 return true;
             });
         return updaterPromise.catch(function (error) {

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

@@ -1,5 +1,6 @@
 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`
@@ -11,22 +12,33 @@ import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../log
  * @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) {
+export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
     var readyOnAlreadyExistentState = true;
-    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
+    function _promiseDecorator(promise) {
+        if (readyOnAlreadyExistentState && requestTimeoutBeforeReady)
+            promise = timeout(requestTimeoutBeforeReady, promise);
+        return promise;
+    }
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
         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).then(function (changes) {
+                segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).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;
                 });
         });
     }
@@ -46,8 +58,7 @@ 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) {
-            // Async fetchers
-            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0); });
             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,7 +130,6 @@ 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) {
@@ -151,6 +150,7 @@ 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.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
+                    log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
                     return _splitChangesUpdater(sinces, retry);
                 }
                 else {
                     startingUp = false;
+                    log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
                 }
                 return false;
             });

package/package.json

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

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -49,12 +49,10 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
-    this.setChangeNumber(segmentsData.cn);
-
+    let isDiff = false;
     const { added, removed } = segmentsData as MySegmentsData;
 
     if (added && removed) {
-      let isDiff = false;
 
       added.forEach(segment => {
         isDiff = this.addSegment(segment) || isDiff;
@@ -63,32 +61,40 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
       removed.forEach(segment => {
         isDiff = this.removeSegment(segment) || isDiff;
       });
+    } else {
 
-      return isDiff;
-    }
+      const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+      const storedSegmentKeys = this.getRegisteredSegments().sort();
 
-    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-    const storedSegmentKeys = this.getRegisteredSegments().sort();
+      // Extreme fast => everything is empty
+      if (!names.length && !storedSegmentKeys.length) {
+        isDiff = false;
+      } else {
 
-    // Extreme fast => everything is empty
-    if (!names.length && !storedSegmentKeys.length) return false;
+        let index = 0;
 
-    let index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
 
-    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 {
 
-    // Quick path => no changes
-    if (index === names.length && index === storedSegmentKeys.length) return false;
+          // Slowest path => add and/or remove segments
+          for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
+          }
 
-    // Slowest path => add and/or remove segments
-    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-      this.removeSegment(storedSegmentKeys[removeIndex]);
-    }
+          for (let addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+          }
 
-    for (let addIndex = index; addIndex < names.length; addIndex++) {
-      this.addSegment(names[addIndex]);
+          isDiff = true;
+        }
+      }
     }
 
-    return true;
+    this.setChangeNumber(segmentsData.cn);
+    return isDiff;
   }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -14,9 +14,10 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
   update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
+    return updated;
   }
 
   abstract getSplit(name: string): ISplit | null

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -2,7 +2,7 @@ import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-import { LOG_PREFIX, DEFINED } from './constants';
+import { DEFINED } from './constants';
 import { StorageAdapter } from '../types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
@@ -16,33 +16,22 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     this.log = log;
     this.keys = keys;
     this.storage = storage;
-    // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
   protected addSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    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;
-    }
+    if (this.storage.getItem(segmentKey) === DEFINED) return false;
+    this.storage.setItem(segmentKey, DEFINED);
+    return true;
   }
 
   protected removeSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    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;
-    }
+    if (this.storage.getItem(segmentKey) !== DEFINED) return false;
+    this.storage.removeItem(segmentKey);
+    return true;
   }
 
   isInSegment(name: string): boolean {
@@ -63,12 +52,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   protected setChangeNumber(changeNumber?: number) {
-    try {
-      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else this.storage.removeItem(this.keys.buildTillKey());
-    } catch (e) {
-      this.log.error(e);
-    }
+    if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+    else this.storage.removeItem(this.keys.buildTillKey());
   }
 
   getChangeNumber() {

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -26,9 +26,10 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    return updated;
   }
 
   private setChangeNumber(changeNumber: number) {
@@ -48,40 +49,30 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private add(rbSegment: IRBSegment): boolean {
-    try {
-      const name = rbSegment.name;
-      const rbSegmentKey = this.keys.buildRBSegmentKey(name);
-      const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-      const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
+    const name = rbSegment.name;
+    const rbSegmentKey = this.keys.buildRBSegmentKey(name);
+    const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+    const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
-      this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+    this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
-      let usesSegmentsDiff = 0;
-      if (previous && usesSegments(previous)) usesSegmentsDiff--;
-      if (usesSegments(rbSegment)) usesSegmentsDiff++;
-      if (usesSegmentsDiff !== 0) this.updateSegmentCount(usesSegmentsDiff);
+    let 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;
-    }
+    return true;
   }
 
   private remove(name: string): boolean {
-    try {
-      const rbSegment = this.get(name);
-      if (!rbSegment) return false;
+    const rbSegment = this.get(name);
+    if (!rbSegment) return false;
 
-      this.storage.removeItem(this.keys.buildRBSegmentKey(name));
+    this.storage.removeItem(this.keys.buildRBSegmentKey(name));
 
-      if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
+    if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
+    return true;
   }
 
   private getNames(): string[] {

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -80,44 +80,34 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   addSplit(split: ISplit) {
-    try {
-      const name = split.name;
-      const splitKey = this.keys.buildSplitKey(name);
-      const splitFromStorage = this.storage.getItem(splitKey);
-      const previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
-
-      if (previousSplit) {
-        this._decrementCounts(previousSplit);
-        this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-      }
+    const name = split.name;
+    const splitKey = this.keys.buildSplitKey(name);
+    const splitFromStorage = this.storage.getItem(splitKey);
+    const 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.storage.setItem(splitKey, JSON.stringify(split));
 
-      this._incrementCounts(split);
-      this.addToFlagSets(split);
+    this._incrementCounts(split);
+    this.addToFlagSets(split);
 
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
+    return true;
   }
 
   removeSplit(name: string): boolean {
-    try {
-      const split = this.getSplit(name);
-      if (!split) return false;
+    const split = this.getSplit(name);
+    if (!split) return false;
 
-      this.storage.removeItem(this.keys.buildSplitKey(name));
+    this.storage.removeItem(this.keys.buildSplitKey(name));
 
-      this._decrementCounts(split);
-      this.removeFromFlagSets(split.name, split.sets);
+    this._decrementCounts(split);
+    this.removeFromFlagSets(split.name, split.sets);
 
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
+    return true;
   }
 
   getSplit(name: string): ISplit | null {
@@ -206,6 +196,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const flagSetFromStorage = this.storage.getItem(flagSetKey);
 
       const 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/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -16,9 +16,10 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
     this.changeNumber = changeNumber;
-    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    return updated;
   }
 
   private add(rbSegment: IRBSegment): boolean {

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from '../inLocalStorage/constants';
+import { LOG_PREFIX } from './constants';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
 import type { RedisAdapter } from './RedisAdapter';

package/src/sync/polling/syncTasks/segmentsSyncTask.ts

@@ -23,6 +23,8 @@ export function segmentsSyncTaskFactory(
       segmentChangesFetcherFactory(fetchSegmentChanges),
       storage.segments,
       readiness,
+      settings.startup.requestTimeoutBeforeReady,
+      settings.startup.retriesOnFailureBeforeReady,
     ),
     settings.scheduler.segmentsRefreshRate,
     'segmentChangesUpdater'

package/src/sync/polling/updaters/mySegmentsUpdater.ts

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