[Cache expiration]

CHANGES.txt

@@ -1,5 +1,9 @@
 2.2.0 (March 28, 2025)
  - Added new optional argument to the client `getTreatment` methods to allow passing additional evaluation options, such as a map of properties to append to the generated impression object sent to Split backend.
+ - Added two new configuration options for the SDK storage in browsers when using storage type `LOCALSTORAGE`:
+    - `storage.expirationDays` to specify the validity period of the rollout cache.
+    - `storage.clearOnInit` to clear the rollout cache on SDK initialization.
+ - Updated SDK_READY_FROM_CACHE event when using the `LOCALSTORAGE` storage type to be emitted alongside the SDK_READY event if it has not already been emitted.
 
 2.1.0 (January 17, 2025)
  - Added support for the new impressions tracking toggle available on feature flags, both respecting the setting and including the new field being returned on `SplitView` type objects. Read more in our docs.

src/readiness/__tests__/readinessManager.spec.ts

@@ -3,10 +3,14 @@ import { EventEmitter } from '../../utils/MinEvents';
 import { IReadinessManager } from '../types';
 import { SDK_READY, SDK_UPDATE, SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_READY_FROM_CACHE, SDK_SPLITS_CACHE_LOADED, SDK_READY_TIMED_OUT } from '../constants';
 import { ISettings } from '../../types';
+import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 
 const settings = {
   startup: {
     readyTimeout: 0,
+  },
+  storage: {
+    type: STORAGE_LOCALSTORAGE
   }
 } as unknown as ISettings;
 
@@ -67,7 +71,14 @@ test('READINESS MANAGER / Ready event should be fired once', () => {
   const readinessManager = readinessManagerFactory(EventEmitter, settings);
   let counter = 0;
 
+  readinessManager.gate.on(SDK_READY_FROM_CACHE, () => {
+    expect(readinessManager.isReadyFromCache()).toBe(true);
+    expect(readinessManager.isReady()).toBe(true);
+    counter++;
+  });
+
   readinessManager.gate.on(SDK_READY, () => {
+    expect(readinessManager.isReadyFromCache()).toBe(true);
     expect(readinessManager.isReady()).toBe(true);
     counter++;
   });
@@ -79,7 +90,7 @@ test('READINESS MANAGER / Ready event should be fired once', () => {
   readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
   readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
 
-  expect(counter).toBe(1); // should be called once
+  expect(counter).toBe(2); // should be called once
 });
 
 test('READINESS MANAGER / Ready from cache event should be fired once', (done) => {
@@ -88,6 +99,7 @@ test('READINESS MANAGER / Ready from cache event should be fired once', (done) =
 
   readinessManager.gate.on(SDK_READY_FROM_CACHE, () => {
     expect(readinessManager.isReadyFromCache()).toBe(true);
+    expect(readinessManager.isReady()).toBe(false);
     counter++;
   });
 

src/readiness/readinessManager.ts

@@ -3,6 +3,7 @@ import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
+import { STORAGE_LOCALSTORAGE } from '../utils/constants';
 
 function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
@@ -114,6 +115,10 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
+          if (!isReadyFromCache && settings.storage?.type === STORAGE_LOCALSTORAGE) {
+            isReadyFromCache = true;
+            gate.emit(SDK_READY_FROM_CACHE);
+          }
           gate.emit(SDK_READY);
         } catch (e) {
           // throws user callback exceptions in next tick

src/storages/AbstractSplitsCacheAsync.ts

@@ -37,14 +37,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.

src/storages/AbstractSplitsCacheSync.ts

@@ -43,14 +43,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.

src/storages/KeyBuilderCS.ts

@@ -50,6 +50,10 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   buildSplitsWithSegmentCountKey() {
     return `${this.prefix}.splits.usingSegments`;
   }
+
+  buildLastClear() {
+    return `${this.prefix}.lastClear`;
+  }
 }
 
 export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {

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
  *

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 = [];
@@ -141,19 +131,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
@@ -215,48 +192,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);

src/storages/inLocalStorage/__tests__/SplitsCacheInLocal.spec.ts

@@ -29,18 +29,11 @@ test('SPLITS CACHE / LocalStorage', () => {
   expect(cache.getSplit(something.name)).toEqual(null);
   expect(cache.getSplit(somethingElse.name)).toEqual(somethingElse);
 
-  expect(cache.checkCache()).toBe(false); // checkCache should return false until localstorage has data.
-
   expect(cache.getChangeNumber()).toBe(-1);
 
-  expect(cache.checkCache()).toBe(false); // checkCache should return false until localstorage has data.
-
   cache.setChangeNumber(123);
 
-  expect(cache.checkCache()).toBe(true); // checkCache should return true once localstorage has data.
-
   expect(cache.getChangeNumber()).toBe(123);
-
 });
 
 test('SPLITS CACHE / LocalStorage / Get Keys', () => {
@@ -106,6 +99,7 @@ test('SPLITS CACHE / LocalStorage / trafficTypeExists and ttcache tests', () =>
 
 test('SPLITS CACHE / LocalStorage / killLocally', () => {
   const cache = new SplitsCacheInLocal(fullSettings, new KeyBuilderCS('SPLITIO', 'user'));
+
   cache.addSplit(something);
   cache.addSplit(somethingElse);
   const initialChangeNumber = cache.getChangeNumber();
@@ -169,6 +163,7 @@ test('SPLITS CACHE / LocalStorage / flag set cache tests', () => {
       }
     }
   }, new KeyBuilderCS('SPLITIO', 'user'));
+
   const emptySet = new Set([]);
 
   cache.update([
@@ -208,25 +203,25 @@ test('SPLITS CACHE / LocalStorage / flag set cache tests', () => {
 
 // if FlagSets are not defined, it should store all FlagSets in memory.
 test('SPLIT CACHE / LocalStorage / flag set cache tests without filters', () => {
-  const cacheWithoutFilters = new SplitsCacheInLocal(fullSettings, new KeyBuilderCS('SPLITIO', 'user'));
+  const cache = new SplitsCacheInLocal(fullSettings, new KeyBuilderCS('SPLITIO', 'user'));
+
   const emptySet = new Set([]);
 
-  cacheWithoutFilters.update([
+  cache.update([
     featureFlagOne,
     featureFlagTwo,
     featureFlagThree,
   ], [], -1);
-  cacheWithoutFilters.addSplit(featureFlagWithEmptyFS);
+  cache.addSplit(featureFlagWithEmptyFS);
 
-  expect(cacheWithoutFilters.getNamesByFlagSets(['o'])).toEqual([new Set(['ff_one', 'ff_two'])]);
-  expect(cacheWithoutFilters.getNamesByFlagSets(['n'])).toEqual([new Set(['ff_one'])]);
-  expect(cacheWithoutFilters.getNamesByFlagSets(['e'])).toEqual([new Set(['ff_one', 'ff_three'])]);
-  expect(cacheWithoutFilters.getNamesByFlagSets(['t'])).toEqual([new Set(['ff_two', 'ff_three'])]);
-  expect(cacheWithoutFilters.getNamesByFlagSets(['y'])).toEqual([emptySet]);
-  expect(cacheWithoutFilters.getNamesByFlagSets(['o', 'n', 'e'])).toEqual([new Set(['ff_one', 'ff_two']), new Set(['ff_one']), new Set(['ff_one', 'ff_three'])]);
+  expect(cache.getNamesByFlagSets(['o'])).toEqual([new Set(['ff_one', 'ff_two'])]);
+  expect(cache.getNamesByFlagSets(['n'])).toEqual([new Set(['ff_one'])]);
+  expect(cache.getNamesByFlagSets(['e'])).toEqual([new Set(['ff_one', 'ff_three'])]);
+  expect(cache.getNamesByFlagSets(['t'])).toEqual([new Set(['ff_two', 'ff_three'])]);
+  expect(cache.getNamesByFlagSets(['y'])).toEqual([emptySet]);
+  expect(cache.getNamesByFlagSets(['o', 'n', 'e'])).toEqual([new Set(['ff_one', 'ff_two']), new Set(['ff_one']), new Set(['ff_one', 'ff_three'])]);
 
   // Validate that the feature flag cache is cleared when calling `clear` method
-  cacheWithoutFilters.clear();
-  expect(localStorage.length).toBe(1); // only 'SPLITIO.hash' should remain in localStorage
-  expect(localStorage.key(0)).toBe('SPLITIO.hash');
+  cache.clear();
+  expect(localStorage.length).toBe(0);
 });