@splitsoftware/splitio-commons 1.6.2-rc.9 → 1.7.0

package/src/storages/AbstractSplitsCacheSync.ts

@@ -61,7 +61,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    */
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {

package/src/storages/KeyBuilderSS.ts

@@ -1,9 +1,8 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
-import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
 
-const METHOD_NAMES: Record<Method, string> = {
+export const METHOD_NAMES: Record<Method, string> = {
   t: 'treatment',
   ts: 'treatments',
   tc: 'treatmentWithConfig',
@@ -34,6 +33,14 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.impressions`;
   }
 
+  buildImpressionsCountKey() {
+    return `${this.prefix}.impressions.count`;
+  }
+
+  buildUniqueKeysKey() {
+    return `${this.prefix}.uniquekeys`;
+  }
+
   buildEventsKey() {
     return `${this.prefix}.events`;
   }
@@ -57,44 +64,3 @@ export class KeyBuilderSS extends KeyBuilder {
   }
 
 }
-
-// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
-
-const REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce((acc, key) => {
-  acc[METHOD_NAMES[key as Method]] = key as Method;
-  return acc;
-}, {} as Record<string, Method>);
-
-
-export function parseMetadata(field: string): [metadata: string] | string {
-  const parts = field.split('/');
-  if (parts.length !== 3) return `invalid subsection count. Expected 4, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */] = parts;
-  return [JSON.stringify({ s, n, i })];
-}
-
-export function parseExceptionField(field: string): [metadata: string, method: Method] | string {
-  const parts = field.split('/');
-  if (parts.length !== 4) return `invalid subsection count. Expected 4, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  return [JSON.stringify({ s, n, i }), method];
-}
-
-export function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string {
-  const parts = field.split('/');
-  if (parts.length !== 5) return `invalid subsection count. Expected 5, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m, b] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  const bucket = parseInt(b);
-  if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT) return `invalid bucket. Expected a number between 0 and 22, got: ${b}`;
-
-  return [JSON.stringify({ s, n, i }), method, bucket];
-}

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -229,7 +229,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   /**
    * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-   * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
    *
    * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
    */

package/src/storages/inLocalStorage/index.ts

@@ -12,8 +12,10 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 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
@@ -30,21 +32,26 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
     // Fallback to InMemoryStorage if LocalStorage API is not available
     if (!isLocalStorageAvailable()) {
-      params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
       return InMemoryStorageCSFactory(params);
     }
 
-    const log = params.log;
-    const keys = new KeyBuilderCS(prefix, params.matchingKey as string);
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const matchingKey = getMatching(settings.core.key);
+    const keys = new KeyBuilderCS(prefix, matchingKey as string);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
+    const splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+    const segments = new MySegmentsCacheInLocal(log, keys);
+
     return {
-      splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-      segments: new MySegmentsCacheInLocal(log, keys),
-      impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-      impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-      events: new EventsCacheInMemory(params.eventsQueueSize),
-      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+      splits,
+      segments,
+      impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+      impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+      events: new EventsCacheInMemory(eventsQueueSize),
+      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+      uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();
@@ -52,6 +59,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
         this.events.clear();
+        this.uniqueKeys?.clear();
       },
 
       // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -7,10 +7,10 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update the value for the given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @param {Object} attributeValue attribute value
-   * @returns {boolean} the attribute was stored 
+   * @returns {boolean} the attribute was stored
    */
   setAttribute(attributeName: string, attributeValue: Object): boolean {
     this.attributesCache[attributeName] = attributeValue;
@@ -19,7 +19,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieves the value of a given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @returns {Object?} stored attribute value
    */
@@ -29,7 +29,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update all the given attributes
-   * 
+   *
    * @param {[string, Object]} attributes attributes to create or update
    * @returns {boolean} attributes were stored
    */
@@ -40,7 +40,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieve the full attributes map
-   * 
+   *
    * @returns {Map<string, Object>} stored attributes
    */
   getAll(): Record<string, Object> {
@@ -49,7 +49,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Removes a given attribute from the map
-   * 
+   *
    * @param {string} attributeName attribute to remove
    * @returns {boolean} attribute removed
    */
@@ -63,7 +63,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Clears all attributes stored in the SDK
-   * 
+   *
    */
   clear() {
     this.attributesCache = {};

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,8 +1,16 @@
 import { truncateTimeFrame } from '../../utils/time';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 import { IImpressionCountsCacheSync } from '../types';
 
 export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-  private cache: Record<string, number> = {};
+  protected cache: Record<string, number> = {};
+  private readonly maxStorage: number;
+  protected onFullQueue?: () => void;
+  private cacheSize = 0;
+
+  constructor(impressionCountsCacheSize = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = impressionCountsCacheSize;
+  }
 
   /**
   * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -18,6 +26,13 @@ export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync
     const key = this._makeKey(featureName, timeFrame);
     const currentAmount = this.cache[key];
     this.cache[key] = currentAmount ? currentAmount + amount : amount;
+    if (this.onFullQueue) {
+      this.cacheSize = this.cacheSize + amount;
+      if (this.cacheSize >= this.maxStorage) {
+        this.onFullQueue();
+        this.cacheSize = 0;
+      }
+    }
   }
 
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,8 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -13,14 +14,19 @@ import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheI
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+
+  const splits = new SplitsCacheInMemory();
+  const segments = new SegmentsCacheInMemory();
 
   return {
-    splits: new SplitsCacheInMemory(),
-    segments: new SegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-    events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+    splits,
+    segments,
+    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    events: new EventsCacheInMemory(eventsQueueSize),
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -29,6 +35,7 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
+      this.uniqueKeys?.clear();
     }
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,8 +4,9 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -13,14 +14,19 @@ import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheI
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+
+  const splits = new SplitsCacheInMemory();
+  const segments = new MySegmentsCacheInMemory();
 
   return {
-    splits: new SplitsCacheInMemory(),
-    segments: new MySegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-    events: new EventsCacheInMemory(params.eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
+    splits,
+    segments,
+    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+    impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    events: new EventsCacheInMemory(eventsQueueSize),
+    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+    uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -29,6 +35,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
+      this.uniqueKeys?.clear();
     },
 
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,14 +1,16 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { LOCALHOST_MODE } from '../../utils/constants';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
-import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
 const MAX_STREAMING_EVENTS = 20;
 const MAX_TAGS = 10;
 export const MAX_LATENCY_BUCKET_COUNT = 23;
 
 export function newBuckets() {
-  return new Array(MAX_LATENCY_BUCKET_COUNT).fill(0);
+  // MAX_LATENCY_BUCKET_COUNT (length) is 23
+  // Not using Array.fill for old browsers compatibility
+  return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 }
 
 const ACCEPTANCE_RANGE = 0.001;
@@ -17,12 +19,48 @@ const ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export function shouldRecordTelemetry(params: IStorageFactoryParams) {
-  return params.mode !== LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
+export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
+  return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
+  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync) { }
+
+  // isEmpty flag
+  private e = true;
+
+  isEmpty() { return this.e; }
+
+  clear() { /* no-op */ }
+
+  pop(): TelemetryUsageStatsPayload {
+    this.e = true;
+
+    return {
+      lS: this.getLastSynchronization(),
+      mL: this.popLatencies(),
+      mE: this.popExceptions(),
+      hE: this.popHttpErrors(),
+      hL: this.popHttpLatencies(),
+      tR: this.popTokenRefreshes(),
+      aR: this.popAuthRejections(),
+      iQ: this.getImpressionStats(QUEUED),
+      iDe: this.getImpressionStats(DEDUPED),
+      iDr: this.getImpressionStats(DROPPED),
+      spC: this.splits && this.splits.getSplitNames().length,
+      seC: this.segments && this.segments.getRegisteredSegments().length,
+      skC: this.segments && this.segments.getKeysCount(),
+      sL: this.getSessionLength(),
+      eQ: this.getEventStats(QUEUED),
+      eD: this.getEventStats(DROPPED),
+      sE: this.popStreamingEvents(),
+      t: this.popTags(),
+    };
+  }
+
+  /** Config stats */
+
   private timeUntilReady?: number;
 
   getTimeUntilReady() {
@@ -53,6 +91,8 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.notReadyUsage++;
   }
 
+  /** Usage stats */
+
   private impressionStats = [0, 0, 0];
 
   getImpressionStats(type: ImpressionDataType) {
@@ -61,6 +101,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordImpressionStats(type: ImpressionDataType, count: number) {
     this.impressionStats[type] += count;
+    this.e = false;
   }
 
   private eventStats = [0, 0];
@@ -71,9 +112,9 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordEventStats(type: EventDataType, count: number) {
     this.eventStats[type] += count;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private lastSync: LastSync = {};
 
   getLastSynchronization() {
@@ -82,40 +123,35 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordSuccessfulSync(resource: OperationType, timeMs: number) {
     this.lastSync[resource] = timeMs;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private httpErrors: HttpErrors = {};
 
   popHttpErrors() {
-    const result = this.httpErrors; // @ts-expect-error
+    const result = this.httpErrors;
     this.httpErrors = {};
     return result;
   }
 
   recordHttpError(resource: OperationType, status: number) {
-    if (!this.httpErrors[resource]) this.httpErrors[resource] = {};
-    if (!this.httpErrors[resource][status]) {
-      this.httpErrors[resource][status] = 1;
-    } else {
-      this.httpErrors[resource][status]++;
-    }
+    const statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
+    statusErrors[status] = (statusErrors[status] || 0) + 1;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private httpLatencies: HttpLatencies = {};
 
   popHttpLatencies() {
-    const result = this.httpLatencies; // @ts-expect-error
+    const result = this.httpLatencies;
     this.httpLatencies = {};
     return result;
   }
 
   recordHttpLatency(resource: OperationType, latencyMs: number) {
-    if (!this.httpLatencies[resource]) {
-      this.httpLatencies[resource] = newBuckets();
-    }
-    this.httpLatencies[resource][findLatencyIndex(latencyMs)]++;
+    const latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
+    latencyBuckets[findLatencyIndex(latencyMs)]++;
+    this.e = false;
   }
 
   private authRejections = 0;
@@ -128,6 +164,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordAuthRejections() {
     this.authRejections++;
+    this.e = false;
   }
 
   private tokenRefreshes = 0;
@@ -140,6 +177,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordTokenRefreshes() {
     this.tokenRefreshes++;
+    this.e = false;
   }
 
   private streamingEvents: StreamingEvent[] = []
@@ -152,6 +190,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
       this.streamingEvents.push(streamingEvent);
     }
+    this.e = false;
   }
 
   private tags: string[] = [];
@@ -164,6 +203,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     if (this.tags.length < MAX_TAGS) {
       this.tags.push(tag);
     }
+    this.e = false;
   }
 
   private sessionLength?: number;
@@ -174,39 +214,34 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
   recordSessionLength(ms: number) {
     this.sessionLength = ms;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private exceptions: MethodExceptions = {};
 
   popExceptions() {
-    const result = this.exceptions; // @ts-expect-error
+    const result = this.exceptions;
     this.exceptions = {};
     return result;
   }
 
   recordException(method: Method) {
-    if (!this.exceptions[method]) {
-      this.exceptions[method] = 1;
-    } else {
-      this.exceptions[method]++;
-    }
+    this.exceptions[method] = (this.exceptions[method] || 0) + 1;
+    this.e = false;
   }
 
-  // @ts-expect-error
   private latencies: MethodLatencies = {};
 
   popLatencies() {
-    const result = this.latencies; // @ts-expect-error
+    const result = this.latencies;
     this.latencies = {};
     return result;
   }
 
   recordLatency(method: Method, latencyMs: number) {
-    if (!this.latencies[method]) {
-      this.latencies[method] = newBuckets();
-    }
-    this.latencies[method][findLatencyIndex(latencyMs)]++;
+    const latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
+    latencyBuckets[findLatencyIndex(latencyMs)]++;
+    this.e = false;
   }
 
 }

package/src/storages/inMemory/UniqueKeysCacheInMemory.ts

@@ -0,0 +1,80 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet, setToArray, _Set } from '../../utils/lang/sets';
+import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+  const payload = [];
+  const featureNames = Object.keys(uniqueKeys);
+  for (let i = 0; i < featureNames.length; i++) {
+    const featureName = featureNames[i];
+    const userKeys = setToArray(uniqueKeys[featureName]);
+    const uniqueKeysPayload = {
+      f: featureName,
+      ks: userKeys
+    };
+
+    payload.push(uniqueKeysPayload);
+  }
+  return { keys: payload };
+}
+
+export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  protected onFullQueue?: () => void;
+  private readonly maxStorage: number;
+  private uniqueTrackerSize = 0;
+  protected uniqueKeysTracker: { [featureName: string]: ISet<string> };
+
+  constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = uniqueKeysQueueSize;
+    this.uniqueKeysTracker = {};
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
+
+  /**
+   * Store unique keys per feature.
+   */
+  track(userKey: string, featureName: string) {
+    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
+    const tracker = this.uniqueKeysTracker[featureName];
+    if (!tracker.has(userKey)) {
+      tracker.add(userKey);
+      this.uniqueTrackerSize++;
+    }
+    if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+      this.uniqueTrackerSize = 0;
+      this.onFullQueue();
+    }
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.uniqueKeysTracker = {};
+  }
+
+  /**
+   * Pop the collected data, used as payload for posting.
+   */
+  pop() {
+    const data = this.uniqueKeysTracker;
+    this.uniqueKeysTracker = {};
+    return fromUniqueKeysCollector(data);
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return Object.keys(this.uniqueKeysTracker).length === 0;
+  }
+
+}