@splitsoftware/splitio-commons 2.7.9-rc.3 → 2.8.1-rc.0

package/src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -1,4 +1,4 @@
-import { Treatment, TreatmentWithConfig } from '../../../../types/splitio';
+import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../../types/splitio';
 import { ILogger } from '../../../logger/types';
 import { isObject, isString } from '../../../utils/lang';
 
@@ -7,59 +7,65 @@ enum FallbackDiscardReason {
   Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
 }
 
-export class FallbacksSanitizer {
+const TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 
-  private static readonly pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
-
-  private static isValidFlagName(name: string): boolean {
-    return name.length <= 100 && !name.includes(' ');
-  }
+export function isValidFlagName(name: string): boolean {
+  return name.length <= 100 && !name.includes(' ');
+}
 
-  private static isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
-    const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
+export function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
+  const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
 
-    if (!isString(treatment) || treatment.length > 100) {
-      return false;
-    }
-    return FallbacksSanitizer.pattern.test(treatment);
+  if (!isString(treatment) || treatment.length > 100) {
+    return false;
   }
+  return TREATMENT_PATTERN.test(treatment);
+}
 
-  static sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
-    if (!this.isValidTreatment(treatment)) {
-      logger.error(
-        `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
-      );
-      return undefined;
-    }
-    return treatment;
+function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
+  if (treatment === undefined) return undefined;
+  if (!isValidTreatment(treatment)) {
+    logger.error(`Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`);
+    return undefined;
   }
+  return treatment;
+}
 
-  static sanitizeByFlag(
-    logger: ILogger,
-    byFlagFallbacks: Record<string, Treatment | TreatmentWithConfig>
-  ): Record<string, Treatment | TreatmentWithConfig> {
-    const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
+function sanitizeByFlag(
+  logger: ILogger,
+  byFlagFallbacks?: Record<string, Treatment | TreatmentWithConfig>
+): Record<string, Treatment | TreatmentWithConfig> {
+  const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
 
-    const entries = Object.keys(byFlagFallbacks);
-    entries.forEach((flag) => {
-      const t = byFlagFallbacks[flag];
-      if (!this.isValidFlagName(flag)) {
-        logger.error(
-          `Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`
-        );
-        return;
-      }
+  if (!isObject(byFlagFallbacks)) return sanitizedByFlag;
 
-      if (!this.isValidTreatment(t)) {
-        logger.error(
-          `Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`
-        );
-        return;
-      }
+  Object.keys(byFlagFallbacks!).forEach((flag) => {
+    const t = byFlagFallbacks![flag];
 
-      sanitizedByFlag[flag] = t;
-    });
+    if (!isValidFlagName(flag)) {
+      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
+      return;
+    }
+
+    if (!isValidTreatment(t)) {
+      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`);
+      return;
+    }
+
+    sanitizedByFlag[flag] = t;
+  });
 
-    return sanitizedByFlag;
+  return sanitizedByFlag;
+}
+
+export function sanitizeFallbacks(logger: ILogger, fallbacks: FallbackTreatmentConfiguration): FallbackTreatmentConfiguration | undefined {
+  if (!isObject(fallbacks)) {
+    logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
+    return;
   }
+
+  return {
+    global: sanitizeGlobal(logger, fallbacks.global),
+    byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
+  };
 }

package/src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,8 +1,6 @@
 import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
-import { FallbacksSanitizer } from './fallbackSanitizer';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
 
 export type IFallbackTreatmentsCalculator = {
   resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
@@ -13,13 +11,8 @@ export const FALLBACK_PREFIX = 'fallback - ';
 export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
   private readonly fallbacks: FallbackTreatmentConfiguration;
 
-  constructor(logger: ILogger, fallbacks?: FallbackTreatmentConfiguration) {
-    const sanitizedGlobal = fallbacks?.global ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
-    const sanitizedByFlag = fallbacks?.byFlag ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
-    this.fallbacks = {
-      global: sanitizedGlobal,
-      byFlag: sanitizedByFlag
-    };
+  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
+    this.fallbacks = fallbacks;
   }
 
   resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {

package/src/sdkFactory/index.ts

@@ -61,7 +61,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));

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;
       });
 

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

@@ -4,6 +4,7 @@ import { IReadinessManager } from '../../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
+import { timeout } from '../../../utils/promise/timeout';
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -23,11 +24,18 @@ export function segmentChangesUpdaterFactory(
   segmentChangesFetcher: ISegmentChangesFetcher,
   segments: ISegmentsCacheBase,
   readiness?: IReadinessManager,
+  requestTimeoutBeforeReady?: number,
+  retriesOnFailureBeforeReady?: number,
 ): ISegmentChangesUpdater {
 
   let readyOnAlreadyExistentState = true;
 
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
+  function _promiseDecorator<T>(promise: Promise<T>) {
+    if (readyOnAlreadyExistentState && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
+    return promise;
+  }
+
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
     let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
@@ -35,13 +43,19 @@ export function segmentChangesUpdaterFactory(
       // if fetchOnlyNew flag, avoid processing already fetched segments
       return fetchOnlyNew && since !== undefined ?
         false :
-        segmentChangesFetcher(since || -1, segmentName, noCache, till).then((changes) => {
+        segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
           return Promise.all(changes.map(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((updates) => {
             return updates.some(update => update);
           });
+        }).catch(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;
         });
     });
   }
@@ -63,8 +77,7 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      // Async fetchers
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0));
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready

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

@@ -120,8 +120,8 @@ export function splitChangesUpdaterFactory(
   storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
-  requestTimeoutBeforeReady: number = 0,
-  retriesOnFailureBeforeReady: number = 0,
+  requestTimeoutBeforeReady = 0,
+  retriesOnFailureBeforeReady = 0,
   isClientSide?: boolean
 ): SplitChangesUpdater {
   const { splits, rbSegments, segments } = storage;
@@ -163,8 +163,6 @@ export function splitChangesUpdaterFactory(
           splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
         .then((splitChanges: ISplitChangesResponse) => {
-          startingUp = false;
-
           const usedSegments = new Set<string>();
 
           let ffUpdate: MaybeThenable<boolean> = false;
@@ -187,6 +185,8 @@ export function splitChangesUpdaterFactory(
           ]).then(([ffChanged, rbsChanged]) => {
             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))))
@@ -201,14 +201,13 @@ export function splitChangesUpdaterFactory(
           });
         })
         .catch(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/src/utils/settingsValidation/index.ts

@@ -8,6 +8,7 @@ import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 import { validateRolloutPlan } from '../../storages/setRolloutPlan';
+import { sanitizeFallbacks } from '../../evaluator/fallbackTreatmentsCalculator/fallbackSanitizer';
 
 // Exported for telemetry
 export const base = {
@@ -207,5 +208,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
 
+  // @ts-ignore, modify readonly prop
+  withDefaults.fallbackTreatments = withDefaults.fallbackTreatments ? sanitizeFallbacks(log, withDefaults.fallbackTreatments) : undefined;
+
   return withDefaults;
 }

package/types/splitio.d.ts

@@ -98,6 +98,8 @@ interface ISharedSettings {
   logger?: SplitIO.Logger;
   /**
    * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+   *
+   * @defaultValue `undefined`
    */
   fallbackTreatments?: SplitIO.FallbackTreatmentConfiguration;
 }
@@ -717,7 +719,7 @@ declare namespace SplitIO {
     isReadyFromCache: boolean;
 
     /**
-     * `isTimedout` indicates if the client has triggered an `SDK_READY_TIMED_OUT` event and is not ready to evaluate.
+     * `isTimedout` indicates if the client has triggered an `SDK_READY_TIMED_OUT` event and is not ready.
      * In other words, `isTimedout` is equivalent to `hasTimedout && !isReady`.
      */
     isTimedout: boolean;
@@ -1307,7 +1309,13 @@ declare namespace SplitIO {
    * Fallback treatments to be used when the SDK is not ready or the flag is not found.
    */
   type FallbackTreatmentConfiguration = {
+    /**
+     * Fallback treatment for all flags.
+     */
     global?: Treatment | TreatmentWithConfig,
+    /**
+     * Fallback treatments for specific flags. It takes precedence over the global fallback treatment.
+     */
     byFlag?: {
       [featureFlagName: string]: Treatment | TreatmentWithConfig
     }
@@ -1327,8 +1335,6 @@ declare namespace SplitIO {
     /**
      * Defines the factory function to instantiate the storage. If not provided, the default in-memory storage is used.
      *
-     * NOTE: Currently, there is no persistent storage option available for the React Native SDK; only `InLocalStorage` for the Browser SDK.
-     *
      * Example:
      * ```
      * SplitFactory({