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

package/src/evaluator/index.ts

@@ -30,6 +30,7 @@ export function evaluateFeature(
   splitName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
+  options?: SplitIO.EvaluationOptions
 ): MaybeThenable<IEvaluationResult> {
   let parsedSplit;
 
@@ -47,6 +48,7 @@ export function evaluateFeature(
       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
@@ -60,6 +62,7 @@ export function evaluateFeature(
     parsedSplit,
     attributes,
     storage,
+    options,
   );
 }
 
@@ -69,6 +72,7 @@ export function evaluateFeatures(
   splitNames: string[],
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
+  options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   let parsedSplits;
 
@@ -80,13 +84,13 @@ export function evaluateFeatures(
   }
 
   return thenable(parsedSplits) ?
-    parsedSplits.then(splits => getEvaluations(log, key, splitNames, splits, attributes, storage))
+    parsedSplits.then(splits => getEvaluations(log, key, splitNames, splits, attributes, storage, options))
       .catch(() => {
         // 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(
@@ -96,6 +100,7 @@ export function evaluateFeaturesByFlagSets(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   method: string,
+  options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   let storedFlagNames: MaybeThenable<Set<string>[]>;
 
@@ -111,7 +116,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
       {};
   }
 
@@ -138,6 +143,7 @@ function getEvaluation(
   splitJSON: ISplit | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
+  options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
     treatment: CONTROL,
@@ -154,14 +160,14 @@ function getEvaluation(
       return evaluation.then(result => {
         result.changeNumber = splitJSON.changeNumber;
         result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
-        result.impressionsDisabled = splitJSON.impressionsDisabled;
+        result.impressionsDisabled = 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?.impressionsDisabled || splitJSON.impressionsDisabled;
     }
   }
 
@@ -175,6 +181,7 @@ function getEvaluations(
   splits: Record<string, ISplit | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
+  options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   const result: Record<string, IEvaluationResult> = {};
   const thenables: Promise<void>[] = [];
@@ -184,7 +191,8 @@ function getEvaluations(
       key,
       splits[splitName],
       attributes,
-      storage
+      storage,
+      options
     );
     if (thenable(evaluation)) {
       thenables.push(evaluation.then(res => {

package/src/sdkClient/client.ts

@@ -52,7 +52,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const 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;
@@ -81,7 +81,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const 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);
@@ -110,7 +110,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
       isAsync ?
         Promise.resolve({}) :
         {};

package/src/storages/AbstractMySegmentsCacheSync.ts

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

package/src/storages/AbstractSplitsCacheSync.ts

@@ -14,10 +14,9 @@ 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);
-    return updated;
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || 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 { DEFINED } from './constants';
+import { LOG_PREFIX, DEFINED } from './constants';
 import { StorageAdapter } from '../types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
@@ -16,22 +16,33 @@ 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);
 
-    if (this.storage.getItem(segmentKey) === DEFINED) return false;
-    this.storage.setItem(segmentKey, DEFINED);
-    return true;
+    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;
+    }
   }
 
   protected removeSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    if (this.storage.getItem(segmentKey) !== DEFINED) return false;
-    this.storage.removeItem(segmentKey);
-    return true;
+    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;
+    }
   }
 
   isInSegment(name: string): boolean {
@@ -52,8 +63,12 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   protected setChangeNumber(changeNumber?: number) {
-    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);
+    }
   }
 
   getChangeNumber() {

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -80,34 +80,44 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   addSplit(split: ISplit) {
-    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);
-    }
+    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);
+      }
 
-    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;
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
   }
 
   removeSplit(name: string): boolean {
-    const split = this.getSplit(name);
-    if (!split) return false;
+    try {
+      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;
+      return true;
+    } catch (e) {
+      this.log.error(LOG_PREFIX + e);
+      return false;
+    }
   }
 
   getSplit(name: string): ISplit | null {
@@ -196,9 +206,6 @@ 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,10 +16,9 @@ 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;
-    return updated;
+    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || 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 './constants';
+import { LOG_PREFIX } from '../inLocalStorage/constants';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ISegmentsCacheAsync } from '../types';
 import type { RedisAdapter } from './RedisAdapter';

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

@@ -23,8 +23,6 @@ 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 => {
-        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;
       });
 

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

@@ -4,7 +4,6 @@ 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>
 
@@ -24,18 +23,11 @@ export function segmentChangesUpdaterFactory(
   segmentChangesFetcher: ISegmentChangesFetcher,
   segments: ISegmentsCacheBase,
   readiness?: IReadinessManager,
-  requestTimeoutBeforeReady?: number,
-  retriesOnFailureBeforeReady?: number,
 ): ISegmentChangesUpdater {
 
   let readyOnAlreadyExistentState = true;
 
-  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> {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
     let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
@@ -43,19 +35,13 @@ export function segmentChangesUpdaterFactory(
       // if fetchOnlyNew flag, avoid processing already fetched segments
       return fetchOnlyNew && since !== undefined ?
         false :
-        segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
+        segmentChangesFetcher(since || -1, segmentName, noCache, till).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;
         });
     });
   }
@@ -77,7 +63,8 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0));
+      // Async fetchers
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
 
       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 = 0,
-  retriesOnFailureBeforeReady = 0,
+  requestTimeoutBeforeReady: number = 0,
+  retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
 ): SplitChangesUpdater {
   const { splits, rbSegments, segments } = storage;
@@ -163,6 +163,8 @@ export function splitChangesUpdaterFactory(
           splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator)
       )
         .then((splitChanges: ISplitChangesResponse) => {
+          startingUp = false;
+
           const usedSegments = new Set<string>();
 
           let ffUpdate: MaybeThenable<boolean> = false;
@@ -185,8 +187,6 @@ 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,13 +201,14 @@ export function splitChangesUpdaterFactory(
           });
         })
         .catch(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/src/utils/inputValidation/eventProperties.ts

@@ -70,7 +70,12 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
 export function validateEvaluationOptions(log: ILogger, maybeOptions: any, method: string): SplitIO.EvaluationOptions | undefined {
   if (isObject(maybeOptions)) {
     const properties = validateEventProperties(log, maybeOptions.properties, method).properties;
-    return properties && Object.keys(properties).length > 0 ? { properties } : undefined;
+    let options =  properties && Object.keys(properties).length > 0 ? { properties } : undefined;
+
+    const impressionsDisabled = maybeOptions.impressionsDisabled;
+    if (!impressionsDisabled) return options;
+
+    return options ? { ...options, impressionsDisabled } : { impressionsDisabled };
   } else if (maybeOptions) {
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);
   }

package/types/splitio.d.ts

@@ -918,8 +918,16 @@ declare namespace SplitIO {
    * Evaluation options object for getTreatment methods.
    */
   type EvaluationOptions = {
+    /**
+     * Whether the evaluation/s will track impressions or not.
+     *
+     * @defaultValue `false`
+     */
+    impressionsDisabled?: boolean;
     /**
      * Optional properties to append to the generated impression object sent to Split backend.
+     *
+     * @defaultValue `undefined`
      */
     properties?: Properties;
   }
@@ -1335,6 +1343,8 @@ 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({