@splitsoftware/splitio-commons 2.0.3-rc.0 → 2.1.0-rc.1

package/src/sdkFactory/index.ts

@@ -13,7 +13,7 @@ import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
+import { NONE, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -59,16 +59,21 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
   const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-
-  const noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-  const strategy = impressionsMode === OPTIMIZED ?
-    strategyOptimizedFactory(observer, storage.impressionCounts) :
-    impressionsMode === DEBUG ?
-      strategyDebugFactory(observer) :
-      noneStrategy;
+  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+
+  let strategy;
+  switch (impressionsMode) {
+    case OPTIMIZED:
+      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
+      break;
+    case NONE:
+      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
+      break;
+    default:
+      strategy = strategyDebugFactory(observer);
+  }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
@@ -94,7 +99,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
     validateAndTrackApiKey(log, settings.core.authorizationKey);
     readiness.init();
-    uniqueKeysTracker.start();
+    uniqueKeysTracker && uniqueKeysTracker.start();
     syncManager && syncManager.start();
     signalListener && signalListener.start();
 

package/src/sdkFactory/types.ts

@@ -46,7 +46,7 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker: IUniqueKeysTracker,
+  uniqueKeysTracker?: IUniqueKeysTracker,
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,

package/src/sdkManager/index.ts

@@ -31,8 +31,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     treatments: collectTreatments(splitObject),
     configs: splitObject.configurations || {},
     sets: splitObject.sets || [],
-    defaultTreatment: splitObject.defaultTreatment,
-    trackImpressions: splitObject.trackImpressions !== false
+    defaultTreatment: splitObject.defaultTreatment
   };
 }
 

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -27,14 +27,6 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     return Promise.resolve(true);
   }
 
-  /**
-   * Check if the splits information is already stored in cache.
-   * Noop, just keeping the interface. This is used by client-side implementations only.
-   */
-  checkCache(): Promise<boolean> {
-    return Promise.resolve(false);
-  }
-
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/AbstractSplitsCacheSync.ts

@@ -47,14 +47,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract clear(): void
 
-  /**
-   * Check if the splits information is already stored in cache. This data can be preloaded.
-   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-   */
-  checkCache(): boolean {
-    return false;
-  }
-
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/KeyBuilderCS.ts

@@ -43,6 +43,10 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   buildTillKey() {
     return `${this.prefix}.${this.matchingKey}.segments.till`;
   }
+
+  buildLastClear() {
+    return `${this.prefix}.lastClear`;
+  }
 }
 
 export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {

package/src/storages/dataLoader.ts

@@ -1,7 +1,9 @@
 import { PreloadedData } from '../types';
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
+// This value might be eventually set via a config parameter
+const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
+
 /**
  * Factory of client-side storage loader
  *

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -5,7 +5,6 @@ import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
-import { getStorageHash } from '../KeyBuilder';
 import { setToArray } from '../../utils/lang/sets';
 
 /**
@@ -15,21 +14,14 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
-  private readonly storageHash: string;
   private readonly flagSetsFilter: string[];
   private hasSync?: boolean;
-  private updateNewFilter?: boolean;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number) {
+  constructor(settings: ISettings, keys: KeyBuilderCS) {
     super();
     this.keys = keys;
     this.log = settings.log;
-    this.storageHash = getStorageHash(settings);
     this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-
-    this._checkExpiration(expirationTimestamp);
-
-    this._checkFilterQuery();
   }
 
   private _decrementCount(key: string) {
@@ -79,8 +71,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
    * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
    */
   clear() {
-    this.log.info(LOG_PREFIX + 'Flushing Splits data from localStorage');
-
     // collect item keys
     const len = localStorage.length;
     const accum = [];
@@ -138,19 +128,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   setChangeNumber(changeNumber: number): boolean {
-
-    // when using a new split query, we must update it at the store
-    if (this.updateNewFilter) {
-      this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
-      const storageHashKey = this.keys.buildHashKey();
-      try {
-        localStorage.setItem(storageHashKey, this.storageHash);
-      } catch (e) {
-        this.log.error(LOG_PREFIX + e);
-      }
-      this.updateNewFilter = false;
-    }
-
     try {
       localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
       // update "last updated" timestamp with current time
@@ -212,48 +189,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
-  /**
-   * Check if the splits information is already stored in browser LocalStorage.
-   * In this function we could add more code to check if the data is valid.
-   * @override
-   */
-  checkCache(): boolean {
-    return this.getChangeNumber() > -1;
-  }
-
-  /**
-   * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-   *
-   * @param expirationTimestamp - if the value is not a number, data will not be cleaned
-   */
-  private _checkExpiration(expirationTimestamp?: number) {
-    let value: string | number | null = localStorage.getItem(this.keys.buildLastUpdatedKey());
-    if (value !== null) {
-      value = parseInt(value, 10);
-      if (!isNaNNumber(value) && expirationTimestamp && value < expirationTimestamp) this.clear();
-    }
-  }
-
-  // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
-  private _checkFilterQuery() {
-    const storageHashKey = this.keys.buildHashKey();
-    const storageHash = localStorage.getItem(storageHashKey);
-
-    if (storageHash !== this.storageHash) {
-      try {
-        // mark cache to update the new query filter on first successful splits fetch
-        this.updateNewFilter = true;
-
-        // if there is cache, clear it
-        if (this.checkCache()) this.clear();
-
-      } catch (e) {
-        this.log.error(LOG_PREFIX + e);
-      }
-    }
-    // if the filter didn't change, nothing is done
-  }
-
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);

package/src/storages/inLocalStorage/index.ts

@@ -7,22 +7,19 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-
-export interface InLocalStorageOptions {
-  prefix?: string
-}
+import { validateCache } from './validateCache';
+import SplitIO from '../../../types/splitio';
 
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
+export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): IStorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
@@ -34,12 +31,11 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       return InMemoryStorageCSFactory(params);
     }
 
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
-    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
+    const splits = new SplitsCacheInLocal(settings, keys);
     const segments = new MySegmentsCacheInLocal(log, keys);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
@@ -48,10 +44,14 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       segments,
       largeSegments,
       impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-      impressionCounts: new ImpressionCountsCacheInMemory(),
+      impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(eventsQueueSize),
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-      uniqueKeys: new UniqueKeysCacheInMemoryCS(),
+      uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
+
+      validateCache() {
+        return validateCache(options, settings, keys, splits, segments, largeSegments);
+      },
 
       destroy() { },
 
@@ -66,7 +66,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           impressionCounts: this.impressionCounts,
           events: this.events,
           telemetry: this.telemetry,
-          uniqueKeys: this.uniqueKeys,
 
           destroy() { }
         };

package/src/storages/inLocalStorage/validateCache.ts

@@ -0,0 +1,91 @@
+import { ISettings } from '../../types';
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { getStorageHash } from '../KeyBuilder';
+import { LOG_PREFIX } from './constants';
+import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { KeyBuilderCS } from '../KeyBuilderCS';
+import SplitIO from '../../../types/splitio';
+
+const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
+const MILLIS_IN_A_DAY = 86400000;
+
+/**
+ * Validates if cache should be cleared and sets the cache `hash` if needed.
+ *
+ * @returns `true` if cache should be cleared, `false` otherwise
+ */
+function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
+  const { log } = settings;
+
+  // Check expiration
+  const lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()) as string, 10);
+  if (!isNaNNumber(lastUpdatedTimestamp)) {
+    const cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
+    const expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
+    if (lastUpdatedTimestamp < expirationTimestamp) {
+      log.info(LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
+      return true;
+    }
+  }
+
+  // Check hash
+  const storageHashKey = keys.buildHashKey();
+  const storageHash = localStorage.getItem(storageHashKey);
+  const currentStorageHash = getStorageHash(settings);
+
+  if (storageHash !== currentStorageHash) {
+    try {
+      localStorage.setItem(storageHashKey, currentStorageHash);
+    } catch (e) {
+      log.error(LOG_PREFIX + e);
+    }
+    if (isThereCache) {
+      log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
+      return true;
+    }
+    return false; // No cache to clear
+  }
+
+  // Clear on init
+  if (options.clearOnInit) {
+    const lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()) as string, 10);
+
+    if (isNaNNumber(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
+      log.info(LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
+      return true;
+    }
+  }
+}
+
+/**
+ * Clean cache if:
+ * - it has expired, i.e., its `lastUpdated` timestamp is older than the given `expirationTimestamp`
+ * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
+ * - `clearOnInit` was set and cache was not cleared in the last 24 hours
+ *
+ * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ */
+export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
+
+  const currentTimestamp = Date.now();
+  const isThereCache = splits.getChangeNumber() > -1;
+
+  if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
+    splits.clear();
+    segments.clear();
+    largeSegments.clear();
+
+    // Update last clear timestamp
+    try {
+      localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
+    } catch (e) {
+      settings.log.error(LOG_PREFIX + e);
+    }
+
+    return false;
+  }
+
+  // Check if ready from cache
+  return isThereCache;
+}

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,7 +4,7 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 
@@ -14,7 +14,7 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new SegmentsCacheInMemory();
@@ -23,10 +23,10 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     splits,
     segments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-    impressionCounts: new ImpressionCountsCacheInMemory(),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(eventsQueueSize),
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-    uniqueKeys: new UniqueKeysCacheInMemory(),
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
     destroy() { }
   };

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,7 +4,7 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 
@@ -14,7 +14,7 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -25,10 +25,10 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     segments,
     largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-    impressionCounts: new ImpressionCountsCacheInMemory(),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(eventsQueueSize),
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-    uniqueKeys: new UniqueKeysCacheInMemoryCS(),
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
     destroy() { },
 
@@ -42,7 +42,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         impressionCounts: this.impressionCounts,
         events: this.events,
         telemetry: this.telemetry,
-        uniqueKeys: this.uniqueKeys,
 
         destroy() { }
       };

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -266,10 +266,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
       return Promise.reject(this.redisError);
     }
 
-    const splits: Record<string, ISplit | null> = {};
     const keys = names.map(name => this.keys.buildSplitKey(name));
     return this.redis.mget(...keys)
       .then(splitDefinitions => {
+        const splits: Record<string, ISplit | null> = {};
         names.forEach((name, idx) => {
           const split = splitDefinitions[idx];
           splits[name] = split && JSON.parse(split);

package/src/storages/inRedis/index.ts

@@ -6,7 +6,7 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { STORAGE_REDIS } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
@@ -30,19 +30,19 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
   const prefix = validatePrefix(options.prefix);
 
   function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
-    const { onReadyCb, settings, settings: { log } } = params;
+    const { onReadyCb, settings, settings: { log, sync: { impressionsMode } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient: RedisAdapter = new RD(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-    const impressionCountsCache = new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient);
-    const uniqueKeysCache = new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient);
+    const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
+    const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
-      impressionCountsCache.start();
-      uniqueKeysCache.start();
+      if (impressionCountsCache) impressionCountsCache.start();
+      if (uniqueKeysCache) uniqueKeysCache.start();
 
       // Synchronize config
       telemetry.recordConfig();
@@ -60,10 +60,10 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       // When using REDIS we should:
       // 1- Disconnect from the storage
       destroy(): Promise<void> {
-        return Promise.all([
-          impressionCountsCache.stop(),
-          uniqueKeysCache.stop()
-        ]).then(() => { redisClient.disconnect(); });
+        let promises = [];
+        if (impressionCountsCache) promises.push(impressionCountsCache.stop());
+        if (uniqueKeysCache) promises.push(uniqueKeysCache.stop());
+        return Promise.all(promises).then(() => { redisClient.disconnect(); });
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };

package/src/storages/pluggable/index.ts

@@ -8,7 +8,7 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { getStorageHash, validatePrefix } from '../KeyBuilder';
-import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
@@ -63,32 +63,37 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
   const prefix = validatePrefix(options.prefix);
 
   function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
-    const { onReadyCb, settings, settings: { log, mode, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
+    const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
 
-    const isSynchronizer = mode === undefined; // If mode is not defined, the synchronizer is running
+    const isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
 
-    const telemetry = shouldRecordTelemetry(params) || isSynchronizer ?
+    const telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
       isPartialConsumer ?
         new TelemetryCacheInMemory() :
         new TelemetryCachePluggable(log, keys, wrapper) :
       undefined;
 
-    const impressionCountsCache = isPartialConsumer ?
-      new ImpressionCountsCacheInMemory() :
-      new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper);
+    const impressionCountsCache = impressionsMode !== DEBUG || isSyncronizer ?
+      isPartialConsumer ?
+        new ImpressionCountsCacheInMemory() :
+        new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+      undefined;
 
-    const uniqueKeysCache = isPartialConsumer ?
-      settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
-      new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper);
+    const uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
+      isPartialConsumer ?
+        settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+        new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+      undefined;
 
     // Connects to wrapper and emits SDK_READY event on main client
     const connectPromise = wrapper.connect().then(() => {
-      if (isSynchronizer) {
-        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+      if (isSyncronizer) {
+        // @TODO reuse InLocalStorage::validateCache logic
+        // In standalone or producer mode, clear storage if SDK key, flags filter criteria or flags spec version was modified
         return wrapper.get(keys.buildHashKey()).then((hash) => {
           const currentHash = getStorageHash(settings);
           if (hash !== currentHash) {
@@ -102,8 +107,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
         });
       } else {
         // Start periodic flush of async storages if not running synchronizer (producer mode)
-        if ((impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-        if ((uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
         if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
 
         onReadyCb();
@@ -125,9 +130,9 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
       // Stop periodic flush and disconnect the underlying storage
       destroy() {
-        return Promise.all(isSynchronizer ? [] : [
-          (impressionCountsCache as ImpressionCountsCachePluggable).stop && (impressionCountsCache as ImpressionCountsCachePluggable).stop(),
-          (uniqueKeysCache as UniqueKeysCachePluggable).stop && (uniqueKeysCache as UniqueKeysCachePluggable).stop(),
+        return Promise.all(isSyncronizer ? [] : [
+          impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).stop && (impressionCountsCache as ImpressionCountsCachePluggable).stop(),
+          uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).stop && (uniqueKeysCache as UniqueKeysCachePluggable).stop(),
         ]).then(() => wrapper.disconnect());
       },
 

package/src/storages/types.ts

@@ -191,8 +191,6 @@ export interface ISplitsCacheBase {
   // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
-  // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
-  checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
   getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
 }
@@ -209,7 +207,6 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
   clear(): void,
-  checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
   getNamesByFlagSets(flagSets: string[]): Set<string>[]
 }
@@ -226,7 +223,6 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
-  checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
   getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
@@ -439,10 +435,10 @@ export interface IStorageBase<
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts: TImpressionsCountCache,
+  impressionCounts?: TImpressionsCountCache,
   events: TEventsCache,
   telemetry?: TTelemetryCache,
-  uniqueKeys: TUniqueKeysCache,
+  uniqueKeys?: TUniqueKeysCache,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -457,6 +453,7 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
+  validateCache?: () => boolean, // @TODO support async
   largeSegments?: ISegmentsCacheSync,
 }