@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.10

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -0,0 +1,47 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { REFRESH_RATE } from '../inRedis/constants';
+import { IPluggableStorageWrapper } from '../types';
+import { LOG_PREFIX } from './constants';
+
+export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly wrapper: IPluggableStorageWrapper;
+  private readonly refreshRate: number;
+  private intervalId: any;
+
+  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
+    super(impressionCountsCacheSize);
+    this.log = log;
+    this.key = key;
+    this.wrapper = wrapper;
+    this.refreshRate = refreshRate;
+    this.onFullQueue = () => { this.storeImpressionCounts(); };
+  }
+
+  private storeImpressionCounts() {
+    const counts = this.pop();
+    const keys = Object.keys(counts);
+    if (!keys.length) return Promise.resolve(false);
+
+    const pipeline = keys.reduce<Promise<any>>((pipeline, key) => {
+      return pipeline.then(() => this.wrapper.incr(`${this.key}::${key}`, counts[key]));
+    }, Promise.resolve());
+
+    return pipeline.catch(err => {
+      this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
+      return false;
+    });
+  }
+
+  start() {
+    this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
+  }
+
+  stop() {
+    clearInterval(this.intervalId);
+    return this.storeImpressionCounts();
+  }
+}

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -49,22 +49,22 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.wrapper.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.wrapper.set(splitKey, stringifiedNewSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type and segment count of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -76,7 +76,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -88,8 +88,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
@@ -109,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name));
+  getSplit(name: string): Promise<ISplit | null> {
+    return this.wrapper.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -118,13 +118,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, string | null> = {};
+      const splits: Record<string, ISplit | null> = {};
       names.forEach((name, idx) => {
-        splits[name] = splitDefinitions[idx];
+        const split = splitDefinitions[idx];
+        splits[name] = split && JSON.parse(split);
       });
       return Promise.resolve(splits);
     });
@@ -135,10 +136,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => Promise.all(listOfKeys.map(this.wrapper.get) as Promise<string>[])
-    );
+  getAll(): Promise<ISplit[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,8 +1,13 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
+import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { isString, isNaNNumber } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 
 export class TelemetryCachePluggable implements ITelemetryCacheAsync {
 
@@ -23,4 +28,144 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       .catch(() => { /* Handle rejections for telemetry */ });
   }
 
+  recordConfig() {
+    const value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_PLUGGABLE));
+    return this.wrapper.set(this.keys.buildInitKey(), value).catch(() => { /* Handle rejections for telemetry */ });
+  }
+
+  /**
+   * Pop telemetry latencies.
+   * The returned promise rejects if wrapper operations fail.
+   */
+  popLatencies(): Promise<MultiMethodLatencies> {
+    return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(latencyKeys => {
+      return latencyKeys.length ?
+        this.wrapper.getMany(latencyKeys).then(latencies => {
+
+          const result: MultiMethodLatencies = new _Map();
+
+          for (let i = 0; i < latencyKeys.length; i++) {
+            const field = latencyKeys[i].split('::')[1];
+
+            const parsedField = parseLatencyField(field);
+            if (isString(parsedField)) {
+              this.log.error(`Ignoring invalid latency field: ${field}: ${parsedField}`);
+              continue;
+            }
+
+            // @ts-ignore
+            const count = parseInt(latencies[i]);
+            if (isNaNNumber(count)) {
+              this.log.error(`Ignoring latency with invalid count: ${latencies[i]}`);
+              continue;
+            }
+
+            const [metadata, method, bucket] = parsedField;
+
+            if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
+              this.log.error(`Ignoring latency with invalid bucket: ${bucket}`);
+              continue;
+            }
+
+            if (!result.has(metadata)) result.set(metadata, {
+              t: newBuckets(),
+              ts: newBuckets(),
+              tc: newBuckets(),
+              tcs: newBuckets(),
+              tr: newBuckets(),
+            });
+
+            result.get(metadata)![method][bucket] = count;
+          }
+
+          return Promise.all(latencyKeys.map((latencyKey) => this.wrapper.del(latencyKey))).then(() => result);
+        }) :
+        // If latencyKeys is empty, return an empty map.
+        new _Map();
+    });
+  }
+
+  /**
+   * Pop telemetry exceptions.
+   * The returned promise rejects if wrapper operations fail.
+   */
+  popExceptions(): Promise<MultiMethodExceptions> {
+    return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(exceptionKeys => {
+      return exceptionKeys.length ?
+        this.wrapper.getMany(exceptionKeys).then(exceptions => {
+
+          const result: MultiMethodExceptions = new _Map();
+
+          for (let i = 0; i < exceptionKeys.length; i++) {
+            const field = exceptionKeys[i].split('::')[1];
+
+            const parsedField = parseExceptionField(field);
+            if (isString(parsedField)) {
+              this.log.error(`Ignoring invalid exception field: ${field}: ${parsedField}`);
+              continue;
+            }
+
+            // @ts-ignore
+            const count = parseInt(exceptions[i]);
+            if (isNaNNumber(count)) {
+              this.log.error(`Ignoring exception with invalid count: ${exceptions[i]}`);
+              continue;
+            }
+
+            const [metadata, method] = parsedField;
+
+            if (!result.has(metadata)) result.set(metadata, {
+              t: 0,
+              ts: 0,
+              tc: 0,
+              tcs: 0,
+              tr: 0,
+            });
+
+            result.get(metadata)![method] = count;
+          }
+
+          return Promise.all(exceptionKeys.map((exceptionKey) => this.wrapper.del(exceptionKey))).then(() => result);
+        }) :
+        // If exceptionKeys is empty, return an empty map.
+        new _Map();
+    });
+  }
+
+  /**
+   * Pop telemetry configs.
+   * The returned promise rejects if wrapper operations fail.
+   */
+  popConfigs(): Promise<MultiConfigs> {
+    return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(configKeys => {
+      return configKeys.length ?
+        this.wrapper.getMany(configKeys).then(configs => {
+
+          const result: MultiConfigs = new _Map();
+
+          for (let i = 0; i < configKeys.length; i++) {
+            const field = configKeys[i].split('::')[1];
+
+            const parsedField = parseMetadata(field);
+            if (isString(parsedField)) {
+              this.log.error(`Ignoring invalid config field: ${field}: ${parsedField}`);
+              continue;
+            }
+
+            const [metadata] = parsedField;
+
+            try { // @ts-ignore
+              const config = JSON.parse(configs[i]);
+              result.set(metadata, config);
+            } catch (e) {
+              this.log.error(`Ignoring invalid config: ${configs[i]}`);
+            }
+          }
+
+          return Promise.all(configKeys.map((configKey) => this.wrapper.del(configKey))).then(() => result);
+        }) :
+        // If configKeys is empty, return an empty map.
+        new _Map();
+    });
+  }
 }

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -0,0 +1,56 @@
+import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
+import { LOG_PREFIX } from './constants';
+import { ILogger } from '../../logger/types';
+
+export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly wrapper: IPluggableStorageWrapper;
+  private readonly refreshRate: number;
+  private intervalId: any;
+
+  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, uniqueKeysQueueSize = DEFAULT_CACHE_SIZE, refreshRate = REFRESH_RATE) {
+    super(uniqueKeysQueueSize);
+    this.log = log;
+    this.key = key;
+    this.wrapper = wrapper;
+    this.refreshRate = refreshRate;
+    this.onFullQueue = () => { this.storeUniqueKeys(); };
+  }
+
+  storeUniqueKeys() {
+    const featureNames = Object.keys(this.uniqueKeysTracker);
+    if (!featureNames.length) return Promise.resolve(false);
+
+    const pipeline = featureNames.reduce<Promise<any>>((pipeline, featureName) => {
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const uniqueKeysPayload = {
+        f: featureName,
+        ks: featureKeys
+      };
+
+      return pipeline.then(() => this.wrapper.pushItems(this.key, [JSON.stringify(uniqueKeysPayload)]));
+    }, Promise.resolve());
+
+    this.clear();
+    return pipeline.catch(err => {
+      this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
+      return false;
+    });
+  }
+
+
+  start() {
+    this.intervalId = setInterval(this.storeUniqueKeys.bind(this), this.refreshRate);
+  }
+
+  stop() {
+    clearInterval(this.intervalId);
+    return this.storeUniqueKeys();
+  }
+
+}

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -8,10 +8,16 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { 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';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { TelemetryCachePluggable } from './TelemetryCachePluggable';
+import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable';
+import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
@@ -35,16 +41,6 @@ function validatePluggableStorageOptions(options: any) {
   if (missingMethods.length) throw new Error(`${NO_VALID_WRAPPER_INTERFACE} The following methods are missing or invalid: ${missingMethods}`);
 }
 
-// subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper: IPluggableStorageWrapper, onReadyCb: (error?: any) => void) {
-  wrapper.connect().then(() => {
-    onReadyCb();
-    // At the moment, we don't synchronize config with pluggable storage
-  }).catch((e) => {
-    onReadyCb(e || new Error('Error connecting wrapper'));
-  });
-}
-
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
 function promisifyEventsTrack(events: any) {
@@ -64,31 +60,60 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory({ log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, optimize }: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+    const { log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, impressionsMode, matchingKey } = params;
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
+    const telemetry = shouldRecordTelemetry(params) ?
+      isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper) :
+      undefined;
+    const impressionCountsCache = impressionsMode !== DEBUG ?
+      isPartialConsumer ? new ImpressionCountsCacheInMemory() : new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+      undefined;
+    const uniqueKeysCache = impressionsMode === NONE ?
+      isPartialConsumer ?
+        matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+        new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+      undefined;
 
     // Connects to wrapper and emits SDK_READY event on main client
-    wrapperConnect(wrapper, onReadyCb);
+    const connectPromise = wrapper.connect().then(() => {
+      onReadyCb();
+
+      // Start periodic flush of async storages
+      if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+      if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+
+      // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
+      if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig && mode) (telemetry as ITelemetryCacheAsync).recordConfig();
+    }).catch((e) => {
+      e = e || new Error('Error connecting wrapper');
+      onReadyCb(e);
+      return e;
+    });
 
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-      impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
+      impressionCounts: impressionCountsCache,
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-      // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
-      // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
+      telemetry,
+      uniqueKeys: uniqueKeysCache,
 
       // Disconnect the underlying storage
       destroy() {
-        return wrapper.disconnect();
+        return Promise.all([
+          impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).stop && (impressionCountsCache as ImpressionCountsCachePluggable).stop(),
+          uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).stop && (uniqueKeysCache as UniqueKeysCachePluggable).stop(),
+        ]).then(() => wrapper.disconnect());
       },
 
       // emits SDK_READY event on shared clients and returns a reference to the storage
       shared(_, onReadyCb) {
-        wrapperConnect(wrapper, onReadyCb);
+        connectPromise.then(onReadyCb);
+
         return {
           ...this,
           // no-op destroy, to disconnect the wrapper only when the main client is destroyed

package/src/storages/types.ts

@@ -1,8 +1,7 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -71,23 +70,25 @@ export interface IPluggableStorageWrapper {
   /** Integer operations */
 
   /**
-   * Increments in 1 the given `key` value or set it to 1 if the value doesn't exist.
+   * Increments the number stored at `key` by `increment` (or 1 if `increment` is not provided), or set it to `increment` (or 1) if the value doesn't exist.
    *
    * @function incr
    * @param {string} key Key to increment
+   * @param {number} increment Value to increment by
    * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
-  incr: (key: string) => Promise<number>
+  incr: (key: string, increment?: number) => Promise<number>
   /**
-   * Decrements in 1 the given `key` value or set it to -1 if the value doesn't exist.
+   * Decrements the number stored at `key` by `decrement` (or 1 if `decrement` is not provided), or set it to minus `decrement` (or minus 1) if the value doesn't exist.
    *
    * @function decr
    * @param {string} key Key to decrement
+   * @param {number} decrement Value to decrement by
    * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
-  decr: (key: string) => Promise<number>
+  decr: (key: string, decrement?: number) => Promise<number>
 
   /** Queue operations */
 
@@ -192,14 +193,14 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
   removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
-  getSplit(name: string): MaybeThenable<string | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, string | null>>, // `fetchMany` in spec
+  getSplit(name: string): MaybeThenable<ISplit | null>,
+  getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
   setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<string[]>,
+  getAll(): MaybeThenable<ISplit[]>,
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
@@ -212,13 +213,13 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): boolean[],
+  addSplits(entries: [string, ISplit][]): boolean[],
   removeSplits(names: string[]): boolean[],
-  getSplit(name: string): string | null,
-  getSplits(names: string[]): Record<string, string | null>,
+  getSplit(name: string): ISplit | null,
+  getSplits(names: string[]): Record<string, ISplit | null>,
   setChangeNumber(changeNumber: number): boolean,
   getChangeNumber(): number,
-  getAll(): string[],
+  getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
@@ -228,13 +229,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): Promise<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
   removeSplits(names: string[]): Promise<boolean[] | void>,
-  getSplit(name: string): Promise<string | null>,
-  getSplits(names: string[]): Promise<Record<string, string | null>>,
+  getSplit(name: string): Promise<ISplit | null>,
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
   setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<string[]>,
+  getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
@@ -348,7 +349,7 @@ export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProdu
  * Only in memory. Named `ImpressionsCounter` in spec.
  */
 export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  // Used by impressions tracker
+// Used by impressions tracker
   track(featureName: string, timeFrame: number, amount: number): void
 
   // Used by impressions count submitter in standalone and producer mode
@@ -356,13 +357,16 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
   pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
 }
 
-export interface IUniqueKeysCacheBase extends IRecorderCacheProducerSync<{ [featureName: string]: ISet<string> }>{
+export interface IUniqueKeysCacheBase {
   // Used by unique Keys tracker
-  track(featureName: string, timeFrame: number, amount: number): void
+  track(key: string, value: string): void
 
   // Used by unique keys submitter in standalone and producer mode
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: { [featureName: string]: ISet<string> } ): { [featureName: string]: ISet<string> } // pop cache data
+  pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs // pop cache data
+  /* Registers callback for full queue */
+  setOnFullQueueCb(cb: () => void): void,
+  clear(): void
 }
 
 /**
@@ -432,18 +436,19 @@ export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITel
  */
 
 export interface ITelemetryEvaluationConsumerAsync {
-  popExceptions(): Promise<MethodExceptions>;
-  popLatencies(): Promise<MethodLatencies>;
+  popLatencies(): Promise<MultiMethodLatencies>;
+  popExceptions(): Promise<MultiMethodExceptions>;
+  popConfigs(): Promise<MultiConfigs>;
 }
 
 export interface ITelemetryEvaluationProducerAsync {
   recordLatency(method: Method, latencyMs: number): Promise<any>;
   recordException(method: Method): Promise<any>;
+  recordConfig(): Promise<any>;
 }
 
 // ATM it only implements the producer API, used by the SDK in consumer mode.
-// @TODO implement consumer API for JS Synchronizer.
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync { }
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync, ITelemetryEvaluationConsumerAsync { }
 
 /**
  * Storages
@@ -453,6 +458,7 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheSync,
   TEventsCache extends IEventsCacheBase,
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase
@@ -460,7 +466,7 @@ export interface IStorageBase<
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: IImpressionCountsCacheSync,
+  impressionCounts?: TImpressionsCountCache,
   events: TEventsCache,
   telemetry?: TTelemetryCache,
   uniqueKeys?: TUniqueKeysCache,
@@ -472,6 +478,7 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheBase
@@ -481,8 +488,9 @@ export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync,
+  ITelemetryCacheAsync | ITelemetryCacheSync,
   IUniqueKeysCacheBase
   > { }
 
@@ -496,7 +504,7 @@ export interface IStorageFactoryParams {
   eventsQueueSize?: number,
   optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
   mode: SDKMode,
-
+  impressionsMode?: string,
   // ATM, only used by InLocalStorage
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,