@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1-rc.5

package/src/storages/KeyBuilderCS.ts

@@ -1,14 +1,7 @@
 import { startsWith } from '../utils/lang';
 import { KeyBuilder } from './KeyBuilder';
 
-export interface MySegmentsKeyBuilder {
-  buildSegmentNameKey(segmentName: string): string;
-  extractSegmentName(builtSegmentKeyName: string): string | undefined;
-  extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
-  buildTillKey(): string;
-}
-
-export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
+export class KeyBuilderCS extends KeyBuilder {
 
   protected readonly regexSplitsCacheKey: RegExp;
   protected readonly matchingKey: string;
@@ -33,6 +26,10 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
       return builtSegmentKeyName.substr(prefix.length);
   }
 
+  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+  buildOldSegmentNameKey(segmentName: string) {
+    return `${this.matchingKey}.${this.prefix}.segment.${segmentName}`;
+  }
   // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
   extractOldSegmentKey(builtSegmentKeyName: string) {
     const prefix = `${this.matchingKey}.${this.prefix}.segment.`;
@@ -48,30 +45,4 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   isSplitsCacheKey(key: string) {
     return this.regexSplitsCacheKey.test(key);
   }
-
-  buildTillKey() {
-    return `${this.prefix}.${this.matchingKey}.segments.till`;
-  }
-}
-
-export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {
-  return {
-    buildSegmentNameKey(segmentName: string) {
-      return `${prefix}.${matchingKey}.largeSegment.${segmentName}`;
-    },
-
-    extractSegmentName(builtSegmentKeyName: string) {
-      const p = `${prefix}.${matchingKey}.largeSegment.`;
-
-      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
-    },
-
-    extractOldSegmentKey() {
-      return undefined;
-    },
-
-    buildTillKey() {
-      return `${prefix}.${matchingKey}.largeSegments.till`;
-    }
-  };
 }

package/src/storages/dataLoader.ts

@@ -50,6 +50,6 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
         return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
       });
     }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
+    storage.segments.resetSegments(mySegmentsData);
   };
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,26 +1,36 @@
 import { ILogger } from '../../logger/types';
-import { isNaNNumber } from '../../utils/lang';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 
-export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
+export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
-  private readonly keys: MySegmentsKeyBuilder;
+  private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
+  constructor(log: ILogger, keys: KeyBuilderCS) {
     super();
     this.log = log;
     this.keys = keys;
     // 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 {
+  /**
+   * Removes list of segments from localStorage
+   * @NOTE this method is not being used at the moment.
+   */
+  clear() {
+    this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
+
+    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+    // We could optimize next sentence, since it implies iterating over all localStorage items
+    this.resetSegments([]);
+  }
+
+  addToSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) === DEFINED) return false;
       localStorage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
@@ -29,11 +39,10 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     }
   }
 
-  protected removeSegment(name: string): boolean {
+  removeFromSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
       localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
@@ -46,22 +55,31 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  getRegisteredSegments(): string[] {
+  /**
+   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+   *
+   * @param {string[]} segmentNames list of segment names
+   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+   */
+  resetSegments(names: string[]): boolean {
+    let isDiff = false;
+    let index;
+
     // Scan current values from localStorage
-    return Object.keys(localStorage).reduce((accum, key) => {
+    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
       if (segmentName) {
         accum.push(segmentName);
       } else {
-        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
         segmentName = this.keys.extractOldSegmentKey(key);
 
         if (segmentName) { // this was an old segment key, let's clean up.
           const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
           try {
             // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey)) {
+            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
               localStorage.setItem(newSegmentKey, DEFINED);
               // we are migrating a segment, let's track it.
               accum.push(segmentName);
@@ -75,32 +93,44 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
       return accum;
     }, [] as string[]);
-  }
 
-  getKeysCount() {
-    return 1;
-  }
+    // Extreme fast => everything is empty
+    if (names.length === 0 && storedSegmentNames.length === names.length)
+      return isDiff;
 
-  protected setChangeNumber(changeNumber?: number) {
-    try {
-      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else localStorage.removeItem(this.keys.buildTillKey());
-    } catch (e) {
-      this.log.error(e);
-    }
-  }
+    // Quick path
+    if (storedSegmentNames.length !== names.length) {
+      isDiff = true;
 
-  getChangeNumber() {
-    const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+      storedSegmentNames.forEach(name => this.removeFromSegment(name));
+      names.forEach(name => this.addToSegment(name));
+    } else {
+      // Slowest path => we need to find at least 1 difference because
+      for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
+        // TODO: why empty statement?
+      }
 
-    if (value !== null) {
-      value = parseInt(value, 10);
+      if (index < names.length) {
+        isDiff = true;
 
-      return isNaNNumber(value) ? n : value;
+        storedSegmentNames.forEach(name => this.removeFromSegment(name));
+        names.forEach(name => this.addToSegment(name));
+      }
     }
 
-    return n;
+    return isDiff;
+  }
+
+  getRegisteredSegments(): string[] {
+    return Object.keys(localStorage).reduce<string[]>((accum, key) => {
+      const segmentName = this.keys.extractSegmentName(key);
+      if (segmentName) accum.push(segmentName);
+      return accum;
+    }, []);
+  }
+
+  getKeysCount() {
+    return 1;
   }
 
 }

package/src/storages/inLocalStorage/index.ts

@@ -3,7 +3,7 @@ import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCache
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -38,17 +38,15 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
     const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
     const matchingKey = getMatching(settings.core.key);
-    const keys = new KeyBuilderCS(prefix, matchingKey);
+    const keys = new KeyBuilderCS(prefix, matchingKey as string);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
     const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
     const segments = new MySegmentsCacheInLocal(log, keys);
-    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
     return {
       splits,
       segments,
-      largeSegments,
       impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
       impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(eventsQueueSize),
@@ -58,7 +56,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       destroy() {
         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
         this.segments = new MySegmentsCacheInMemory();
-        this.largeSegments = new MySegmentsCacheInMemory();
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
         this.events.clear();
@@ -67,11 +64,11 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
       // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
+        const childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);
 
         return {
           splits: this.splits,
-          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+          segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
           impressions: this.impressions,
           impressionCounts: this.impressionCounts,
           events: this.events,
@@ -80,7 +77,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           destroy() {
             this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
             this.segments = new MySegmentsCacheInMemory();
-            this.largeSegments = new MySegmentsCacheInMemory();
           }
         };
       },

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -18,12 +18,10 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
-  const largeSegments = new MySegmentsCacheInMemory();
 
   const storage = {
     splits,
     segments,
-    largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(eventsQueueSize),
@@ -34,7 +32,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     destroy() {
       this.splits.clear();
       this.segments.clear();
-      this.largeSegments.clear();
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
@@ -46,7 +43,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       return {
         splits: this.splits,
         segments: new MySegmentsCacheInMemory(),
-        largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -56,14 +52,13 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         destroy() {
           this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
           this.segments.clear();
-          this.largeSegments.clear();
         }
       };
     },
   };
 
   // @TODO revisit storage logic in localhost mode
-  // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
+  // No tracking data in localhost mode to avoid memory leaks
   if (params.settings.mode === LOCALHOST_MODE) {
     const noopTrack = () => true;
     storage.impressions.track = noopTrack;

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -1,25 +1,24 @@
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
  */
-export class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
+export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private segmentCache: Record<string, boolean> = {};
-  private cn?: number;
 
-  protected addSegment(name: string): boolean {
-    if (this.segmentCache[name]) return false;
+  clear() {
+    this.segmentCache = {};
+  }
 
+  addToSegment(name: string): boolean {
     this.segmentCache[name] = true;
 
     return true;
   }
 
-  protected removeSegment(name: string): boolean {
-    if (!this.segmentCache[name]) return false;
-
+  removeFromSegment(name: string): boolean {
     delete this.segmentCache[name];
 
     return true;
@@ -29,13 +28,48 @@ export class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
     return this.segmentCache[name] === true;
   }
 
+  /**
+   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+   * @NOTE based on the way we use segments in the browser, this way is the best option
+   *
+   * @param {string[]} names list of segment names
+   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+   */
+  resetSegments(names: string[]): boolean {
+    let isDiff = false;
+    let index;
 
-  protected setChangeNumber(changeNumber?: number) {
-    this.cn = changeNumber;
-  }
+    const storedSegmentKeys = Object.keys(this.segmentCache);
+
+    // Extreme fast => everything is empty
+    if (names.length === 0 && storedSegmentKeys.length === names.length)
+      return isDiff;
+
+    // Quick path
+    if (storedSegmentKeys.length !== names.length) {
+      isDiff = true;
+
+      this.segmentCache = {};
+      names.forEach(s => {
+        this.addToSegment(s);
+      });
+    } else {
+      // Slowest path => we need to find at least 1 difference because
+      for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
+        // TODO: why empty statement?
+      }
+
+      if (index < names.length) {
+        isDiff = true;
+
+        this.segmentCache = {};
+        names.forEach(s => {
+          this.addToSegment(s);
+        });
+      }
+    }
 
-  getChangeNumber() {
-    return this.cn || -1;
+    return isDiff;
   }
 
   getRegisteredSegments() {

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -1,25 +1,36 @@
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
-import { ISegmentsCacheSync } from '../types';
 
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
-export class SegmentsCacheInMemory implements ISegmentsCacheSync {
+export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private segmentCache: Record<string, ISet<string>> = {};
   private segmentChangeNumber: Record<string, number> = {};
 
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
-    const keySet = this.segmentCache[name] || new _Set<string>();
+  addToSegment(name: string, segmentKeys: string[]): boolean {
+    const values = this.segmentCache[name];
+    const keySet = values ? values : new _Set<string>();
 
-    addedKeys.forEach(k => keySet.add(k));
-    removedKeys.forEach(k => keySet.delete(k));
+    segmentKeys.forEach(k => keySet.add(k));
 
     this.segmentCache[name] = keySet;
-    this.segmentChangeNumber[name] = changeNumber;
 
-    return addedKeys.length > 0 || removedKeys.length > 0;
+    return true;
+  }
+
+  removeFromSegment(name: string, segmentKeys: string[]): boolean {
+    const values = this.segmentCache[name];
+    const keySet = values ? values : new _Set<string>();
+
+    segmentKeys.forEach(k => keySet.delete(k));
+
+    this.segmentCache[name] = keySet;
+
+    return true;
   }
 
   isInSegment(name: string, key: string): boolean {
@@ -63,13 +74,16 @@ export class SegmentsCacheInMemory implements ISegmentsCacheSync {
     }, 0);
   }
 
+  setChangeNumber(name: string, changeNumber: number) {
+    this.segmentChangeNumber[name] = changeNumber;
+
+    return true;
+  }
+
   getChangeNumber(name: string) {
     const value = this.segmentChangeNumber[name];
 
-    return isIntegerNumber(value) ? value : -1;
+    return isIntegerNumber(value) ? value : undefined;
   }
 
-  // No-op. Not used in server-side
-  resetSegments() { return false; }
-
 }

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -5,6 +5,7 @@ import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
@@ -12,7 +13,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
-  private segmentsCount: number = 0;
+  private splitsWithSegmentsCount: number = 0;
   private flagSetsCache: Record<string, ISet<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
@@ -24,7 +25,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsCache = {};
     this.ttCache = {};
     this.changeNumber = -1;
-    this.segmentsCount = 0;
+    this.splitsWithSegmentsCount = 0;
   }
 
   addSplit(name: string, split: ISplit): boolean {
@@ -37,8 +38,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
 
-      // Subtract from segments count for the previous version of this Split
-      if (usesSegments(previousSplit)) this.segmentsCount--;
+      if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
+        this.splitsWithSegmentsCount--;
+      }
     }
 
     if (split) {
@@ -50,7 +52,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(split)) this.segmentsCount++;
+      if (usesSegments(split)) this.splitsWithSegmentsCount++;
 
       return true;
     } else {
@@ -70,7 +72,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
-      if (usesSegments(split)) this.segmentsCount--;
+      if (usesSegments(split)) this.splitsWithSegmentsCount--;
 
       return true;
     } else {
@@ -100,7 +102,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   }
 
   usesSegments(): boolean {
-    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
   }
 
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
@@ -25,7 +25,7 @@ export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
-  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
+  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync) { }
 
   // isEmpty flag
   private e = true;
@@ -51,8 +51,6 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       spC: this.splits && this.splits.getSplitNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
-      lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-      lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),
       eD: this.getEventStats(DROPPED),
@@ -247,16 +245,22 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.e = false;
   }
 
-  private updatesFromSSE: UpdatesFromSSE = {};
+  private updatesFromSSE = {
+    sp: 0,
+    ms: 0
+  };
 
   popUpdatesFromSSE() {
     const result = this.updatesFromSSE;
-    this.updatesFromSSE = {};
+    this.updatesFromSSE = {
+      sp: 0,
+      ms: 0,
+    };
     return result;
   }
 
   recordUpdatesFromSSE(type: UpdatesFromSSEEnum) {
-    this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+    this.updatesFromSSE[type]++;
     this.e = false;
   }
 

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -17,21 +17,24 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     this.keys = keys;
   }
 
-  /**
-   * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-   * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-   * or rejected if it fails (e.g., Redis operation fails).
-   */
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
+  addToSegment(name: string, segmentKeys: string[]) {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    return Promise.all([
-      addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
-      removedKeys.length && this.redis.srem(segmentKey, removedKeys),
-      this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-    ]).then(() => {
-      return addedKeys.length > 0 || removedKeys.length > 0;
-    });
+    if (segmentKeys.length) {
+      return this.redis.sadd(segmentKey, segmentKeys).then(() => true);
+    } else {
+      return Promise.resolve(true);
+    }
+  }
+
+  removeFromSegment(name: string, segmentKeys: string[]) {
+    const segmentKey = this.keys.buildSegmentNameKey(name);
+
+    if (segmentKeys.length) {
+      return this.redis.srem(segmentKey, segmentKeys).then(() => true);
+    } else {
+      return Promise.resolve(true);
+    }
   }
 
   isInSegment(name: string, key: string) {
@@ -40,14 +43,20 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     ).then(matches => matches !== 0);
   }
 
+  setChangeNumber(name: string, changeNumber: number) {
+    return this.redis.set(
+      this.keys.buildSegmentTillKey(name), changeNumber + ''
+    ).then(status => status === 'OK');
+  }
+
   getChangeNumber(name: string) {
     return this.redis.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
-      return isNaNNumber(i) ? -1 : i;
+      return isNaNNumber(i) ? undefined : i;
     }).catch((e) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-      return -1;
+      return undefined;
     });
   }