@splitsoftware/splitio-commons 1.6.2-rc.12 → 1.6.2-rc.14

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -4,6 +4,7 @@ import { ImpressionDTO } from '../../types';
 import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
+import { impressionsToJSON } from '../utils';
 
 const IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 
@@ -24,7 +25,7 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
   track(impressions: ImpressionDTO[]): Promise<void> { // @ts-ignore
     return this.redis.rpush(
       this.key,
-      this._toJSON(impressions)
+      impressionsToJSON(impressions, this.metadata),
     ).then(queuedCount => {
       // If this is the creation of the key on Redis, set the expiration for it in 1hr.
       if (queuedCount === impressions.length) {
@@ -33,27 +34,6 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     });
   }
 
-  private _toJSON(impressions: ImpressionDTO[]): string[] {
-    return impressions.map(impression => {
-      const {
-        keyName, bucketingKey, feature, treatment, label, time, changeNumber
-      } = impression;
-
-      return JSON.stringify({
-        m: this.metadata,
-        i: {
-          k: keyName,
-          b: bucketingKey,
-          f: feature,
-          t: treatment,
-          r: label,
-          c: changeNumber,
-          m: time
-        }
-      });
-    });
-  }
-
   count(): Promise<number> {
     return this.redis.llen(this.key).catch(() => 0);
   }

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { Redis } from 'ioredis';
@@ -9,6 +9,7 @@ import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
 import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
+import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
@@ -76,7 +77,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
           tr: newBuckets(),
         });
 
-        result.get(metadata)![method][bucket] = count;
+        result.get(metadata)![method]![bucket] = count;
       });
 
       return this.redis.del(this.keys.latencyPrefix).then(() => result);

package/src/storages/inRedis/index.ts

@@ -10,6 +10,7 @@ import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
+import { metadataBuilder } from '../utils';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -24,7 +25,9 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: IStorageFactoryParams): IStorageAsync {
+  function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+    const { onReadyCb, settings, settings: { log, sync: { impressionsMode } } } = params;
+    const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -54,7 +54,7 @@ export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemor
           .then(counts => {
             keys.forEach(key => this.wrapper.del(key).catch(() => { /* noop */ }));
 
-            const impressionsCount: ImpressionCountsPayload = { pf: [] };
+            const pf = [];
 
             for (let i = 0; i < keys.length; i++) {
               const key = keys[i];
@@ -78,14 +78,14 @@ export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemor
                 continue;
               }
 
-              impressionsCount.pf.push({
+              pf.push({
                 f: keyFeatureNameAndTime[1],
                 m: timeFrame,
                 rc: rawCount,
               });
             }
 
-            return impressionsCount;
+            return { pf };
           }) : undefined;
       });
   }

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,8 +1,9 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+import { ILogger } from '../../logger/types';
+import { impressionsToJSON } from '../utils';
 
 export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
 
@@ -27,31 +28,10 @@ export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
   track(impressions: ImpressionDTO[]): Promise<void> {
     return this.wrapper.pushItems(
       this.key,
-      this._toJSON(impressions)
+      impressionsToJSON(impressions, this.metadata)
     );
   }
 
-  private _toJSON(impressions: ImpressionDTO[]): string[] {
-    return impressions.map(impression => {
-      const {
-        keyName, bucketingKey, feature, treatment, label, time, changeNumber
-      } = impression;
-
-      return JSON.stringify({
-        m: this.metadata,
-        i: {
-          k: keyName,
-          b: bucketingKey,
-          f: feature,
-          t: treatment,
-          r: label,
-          c: changeNumber,
-          m: time
-        }
-      } as StoredImpressionWithMetadata);
-    });
-  }
-
   /**
    * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
    * The promise will never be rejected.

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
@@ -8,6 +8,7 @@ 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';
+import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 
 export class TelemetryCachePluggable implements ITelemetryCacheAsync {
 
@@ -75,7 +76,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
               tr: newBuckets(),
             });
 
-            result.get(metadata)![method][bucket] = count;
+            result.get(metadata)![method]![bucket] = count;
           }
 
           return Promise.all(latencyKeys.map((latencyKey) => this.wrapper.del(latencyKey))).then(() => result);

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -39,25 +39,25 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getKeysByPrefix(prefix: string) {
       return Promise.resolve(Object.keys(_cache).filter(key => startsWith(key, prefix)));
     },
-    incr(key: string) {
+    incr(key: string, increment = 1) {
       if (key in _cache) {
-        const count = toNumber(_cache[key]) + 1;
+        const count = toNumber(_cache[key]) + increment;
         if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
         return Promise.resolve(count);
       } else {
-        _cache[key] = '1';
+        _cache[key] = '' + increment;
         return Promise.resolve(1);
       }
     },
-    decr(key: string) {
+    decr(key: string, decrement = 1) {
       if (key in _cache) {
-        const count = toNumber(_cache[key]) - 1;
+        const count = toNumber(_cache[key]) - decrement;
         if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
         return Promise.resolve(count);
       } else {
-        _cache[key] = '-1';
+        _cache[key] = '-' + decrement;
         return Promise.resolve(-1);
       }
     },

package/src/storages/pluggable/index.ts

@@ -18,6 +18,7 @@ import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable
 import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { metadataBuilder } from '../utils';
 
 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.';
@@ -61,7 +62,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
   const prefix = validatePrefix(options.prefix);
 
   function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
-    const { log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, impressionsMode, matchingKey } = params;
+    const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
+    const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
 
@@ -82,7 +84,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
     const uniqueKeysCache = impressionsMode === NONE || isSyncronizer ?
       isPartialConsumer ?
-        matchingKey === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+        settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
       undefined;
 

package/src/storages/types.ts

@@ -1,7 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
-import { ILogger } from '../logger/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 { MaybeThenable, ISplit } from '../dtos/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -70,21 +69,21 @@ export interface IPluggableStorageWrapper {
   /** Integer operations */
 
   /**
-   * 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.
+   * Increments the number stored at `key` by `increment`, or set it to `increment` if the value doesn't exist.
    *
    * @function incr
    * @param {string} key Key to increment
-   * @param {number} increment Value to increment by
+   * @param {number} increment Value to increment by. Defaults to 1.
    * @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, increment?: number) => Promise<number>
   /**
-   * 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.
+   * Decrements the number stored at `key` by `decrement`, or set it to minus `decrement` if the value doesn't exist.
    *
    * @function decr
    * @param {string} key Key to decrement
-   * @param {number} decrement Value to decrement by
+   * @param {number} decrement Value to decrement by. Defaults to 1.
    * @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.
    */
@@ -285,19 +284,29 @@ export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
 /** Recorder storages (impressions, events and telemetry) */
 
 export interface IImpressionsCacheBase {
-  // Consumer API method, used by impressions tracker, in standalone and consumer modes, to push impressions into the storage.
+  // Used by impressions tracker, in DEBUG and OPTIMIZED impression modes, to push impressions into the storage.
   track(data: ImpressionDTO[]): MaybeThenable<void>
 }
 
 export interface IEventsCacheBase {
-  // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
+  // Used by events tracker to push events into the storage.
   track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
 }
 
-/** Impressions and events cache for standalone mode (sync) */
+export interface IImpressionCountsCacheBase {
+  // Used by impressions tracker, in OPTIMIZED and NONE impression modes, to count impressions.
+  track(featureName: string, timeFrame: number, amount: number): void
+}
+
+export interface IUniqueKeysCacheBase {
+  // Used by impressions tracker, in NONE impression mode, to track unique keys.
+  track(key: string, value: string): void
+}
 
-// Producer API methods for sync recorder storages, used by submitters in standalone mode to pop data and post it to Split BE.
-export interface IRecorderCacheProducerSync<T> {
+/** Impressions and events cache for standalone and partial consumer modes (sync methods) */
+
+// API methods for sync recorder storages, used by submitters in standalone mode to pop data and post it to Split BE.
+export interface IRecorderCacheSync<T> {
   // @TODO names are inconsistent with spec
   /* Checks if cache is empty. Returns true if the cache was just created or cleared */
   isEmpty(): boolean
@@ -307,23 +316,29 @@ export interface IRecorderCacheProducerSync<T> {
   pop(toMerge?: T): T
 }
 
-
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
   track(data: ImpressionDTO[]): void
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
   track(data: SplitIO.EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
 
-/** Impressions and events cache for consumer and producer mode (async) */
+/* Named `ImpressionsCounter` in spec */
+export interface IImpressionCountsCacheSync extends IImpressionCountsCacheBase, IRecorderCacheSync<Record<string, number>> { }
 
-// Producer API methods for async recorder storages, used by submitters in producer mode to pop data and post it to Split BE.
-export interface IRecorderCacheProducerAsync<T> {
+export interface IUniqueKeysCacheSync  extends IUniqueKeysCacheBase, IRecorderCacheSync<UniqueKeysPayloadSs | UniqueKeysPayloadCs> {
+  setOnFullQueueCb(cb: () => void): void,
+}
+
+/** Impressions and events cache for consumer and producer modes (async methods) */
+
+// API methods for async recorder storages, used by submitters in producer mode (synchronizer) to pop data and post it to Split BE.
+export interface IRecorderCacheAsync<T> {
   /* returns the number of stored items */
   count(): Promise<number>
   /* removes the given number of items from the store. If not provided, it deletes all items */
@@ -332,43 +347,18 @@ export interface IRecorderCacheProducerAsync<T> {
   popNWithMetadata(count: number): Promise<T>
 }
 
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
   // Consumer API method, used by impressions tracker (in standalone and consumer modes) to push data into.
   // The result promise can reject.
   track(data: ImpressionDTO[]): Promise<void>
 }
 
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
   track(data: SplitIO.EventData, size?: number): Promise<boolean>
 }
 
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  // Used by impressions tracker
-  track(featureName: string, timeFrame: number, amount: number): void
-
-  // Used by impressions count 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?: Record<string, number>): Record<string, number> // pop cache data
-}
-
-export interface IUniqueKeysCacheBase {
-  // Used by unique Keys tracker
-  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(): UniqueKeysPayloadSs | UniqueKeysPayloadCs // pop cache data
-  /* Registers callback for full queue */
-  setOnFullQueueCb(cb: () => void): void,
-  clear(): void
-}
-
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -428,7 +418,7 @@ export interface ITelemetryEvaluationProducerSync {
 
 export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync { }
 
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync { }
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> { }
 
 /**
  * Telemetry storage interface for consumer mode.
@@ -458,7 +448,7 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheSync,
+  TImpressionsCountCache extends IImpressionCountsCacheBase,
   TEventsCache extends IEventsCacheBase,
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase
@@ -481,14 +471,14 @@ export interface IStorageSync extends IStorageBase<
   IImpressionCountsCacheSync,
   IEventsCacheSync,
   ITelemetryCacheSync,
-  IUniqueKeysCacheBase
+  IUniqueKeysCacheSync
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
+  IImpressionCountsCacheBase,
   IEventsCacheAsync | IEventsCacheSync,
   ITelemetryCacheAsync | ITelemetryCacheSync,
   IUniqueKeysCacheBase
@@ -499,21 +489,12 @@ export interface IStorageAsync extends IStorageBase<
 export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 
 export interface IStorageFactoryParams {
-  log: ILogger,
-  impressionsQueueSize?: number,
-  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,
-
-  // This callback is invoked when the storage is ready to be used. Error-first callback style: if an error is passed,
-  // it means that the storge fail to connect and shouldn't be used.
-  // It is meant for emitting SDK_READY event in consumer mode, and for synchronizer to wait before using the storage.
+  settings: ISettings,
+  /**
+   * Error-first callback invoked when the storage is ready to be used. An error means that the storage failed to connect and shouldn't be used.
+   * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
+   */
   onReadyCb: (error?: any) => void,
-  metadata: IMetadata,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/storages/utils.ts

@@ -0,0 +1,78 @@
+// Shared utils for Redis and Pluggable storage
+
+import { IMetadata } from '../dtos/types';
+import { Method, StoredImpressionWithMetadata } from '../sync/submitters/types';
+import { ImpressionDTO, ISettings } from '../types';
+import { UNKNOWN } from '../utils/constants';
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+import { METHOD_NAMES } from './KeyBuilderSS';
+
+export function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata {
+  return {
+    s: settings.version,
+    i: settings.runtime.ip || UNKNOWN,
+    n: settings.runtime.hostname || UNKNOWN,
+  };
+}
+
+// Converts impressions to be stored in Redis or pluggable storage.
+export function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[] {
+  return impressions.map(impression => {
+    const impressionWithMetadata: StoredImpressionWithMetadata = {
+      m: metadata,
+      i: {
+        k: impression.keyName,
+        b: impression.bucketingKey,
+        f: impression.feature,
+        t: impression.treatment,
+        r: impression.label,
+        c: impression.changeNumber,
+        m: impression.time,
+        pt: impression.pt,
+      }
+    };
+
+    return JSON.stringify(impressionWithMetadata);
+  });
+}
+
+// Utilities used by 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 3, 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 ${MAX_LATENCY_BUCKET_COUNT - 1}, got: ${b}`;
+
+  return [JSON.stringify({ s, n, i }), method, bucket];
+}

package/src/sync/submitters/submitter.ts

@@ -1,6 +1,6 @@
 import { syncTaskFactory } from '../syncTask';
 import { ISyncTask } from '../types';
-import { IRecorderCacheProducerSync } from '../../storages/types';
+import { IRecorderCacheSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
@@ -11,7 +11,7 @@ import { IResponse } from '../../services/types';
 export function submitterFactory<T>(
   log: ILogger,
   postClient: (body: string) => Promise<IResponse>,
-  sourceCache: IRecorderCacheProducerSync<T>,
+  sourceCache: IRecorderCacheSync<T>,
   postRate: number,
   dataName: string,
   fromCacheToPayload?: (cacheData: T) => any,

package/src/sync/submitters/submitterManager.ts

@@ -16,7 +16,7 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
-  if (params.uniqueKeysTracker) submitters.push(uniqueKeysSubmitterFactory(params));
+  if (params.storage.uniqueKeys) submitters.push(uniqueKeysSubmitterFactory(params));
 
   return {
     // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
-import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
+import { ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -9,41 +9,6 @@ import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
-import { isStorageSync } from '../../trackers/impressionObserver/utils';
-
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync) {
-  return {
-    isEmpty() { return false; }, // There is always data in telemetry cache
-    clear() { }, //  No-op
-
-    // @TODO consider moving inside telemetry cache for code size reduction
-    pop(): TelemetryUsageStatsPayload {
-      return {
-        lS: telemetry.getLastSynchronization(),
-        mL: telemetry.popLatencies(),
-        mE: telemetry.popExceptions(),
-        hE: telemetry.popHttpErrors(),
-        hL: telemetry.popHttpLatencies(),
-        tR: telemetry.popTokenRefreshes(),
-        aR: telemetry.popAuthRejections(),
-        iQ: telemetry.getImpressionStats(QUEUED),
-        iDe: telemetry.getImpressionStats(DEDUPED),
-        iDr: telemetry.getImpressionStats(DROPPED),
-        spC: splits && splits.getSplitNames().length,
-        seC: segments && segments.getRegisteredSegments().length,
-        skC: segments && segments.getKeysCount(),
-        sL: telemetry.getSessionLength(),
-        eQ: telemetry.getEventStats(QUEUED),
-        eD: telemetry.getEventStats(DROPPED),
-        sE: telemetry.popStreamingEvents(),
-        t: telemetry.popTags(),
-      };
-    }
-  };
-}
 
 const OPERATION_MODE_MAP = {
   [STANDALONE_MODE]: STANDALONE_ENUM,
@@ -131,7 +96,7 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
-  const { storage: { splits, segments, telemetry }, platform: { now } } = params;
+  const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
   const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
@@ -140,8 +105,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const submitter = firstPushWindowDecorator(
     submitterFactory(
       log, splitApi.postMetricsUsage,
-      // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
-      isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry),
+      telemetry,
       telemetryRefreshRate, 'telemetry stats', undefined, 0, true
     ),
     telemetryRefreshRate