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

package/src/storages/inRedis/index.ts

@@ -6,10 +6,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
+import { STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
-import { UniqueKeysCacheInRedis } from './uniqueKeysCacheInRedis';
-import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -24,18 +22,15 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode, impressionCountsQueueSize, impressionCountsRefreshRate, uniqueKeysCacheSize, uniqueKeysRefreshRate }: IStorageFactoryParams): IStorageAsync {
+  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
+
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-    const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient, impressionCountsQueueSize, impressionCountsRefreshRate) : undefined;
-    const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient, uniqueKeysCacheSize, uniqueKeysRefreshRate) : undefined;
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
-      if (impressionCountsCache) impressionCountsCache.start();
-      if (uniqueKeysCache) uniqueKeysCache.start();
 
       // Synchronize config
       telemetry.recordConfig();
@@ -45,17 +40,13 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       splits: new SplitsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
-      impressionCounts: impressionCountsCache,
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
       telemetry,
-      uniqueKeys: uniqueKeysCache,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
       destroy() {
         redisClient.disconnect();
-        if (impressionCountsCache) impressionCountsCache.stop();
-        if (uniqueKeysCache) uniqueKeysCache.stop();
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };

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/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';
@@ -12,6 +12,8 @@ import { CONSUMER_PARTIAL_MODE, 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';
 
 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 +37,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,13 +56,25 @@ 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, optimize } = 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;
 
     // Connects to wrapper and emits SDK_READY event on main client
-    wrapperConnect(wrapper, onReadyCb);
+    const connectPromise = wrapper.connect().then(() => {
+      onReadyCb();
+      // 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),
@@ -78,8 +82,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
       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,
 
       // Disconnect the underlying storage
       destroy() {
@@ -88,7 +91,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
       // 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,6 +1,6 @@
 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, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
@@ -347,7 +347,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
@@ -355,17 +355,6 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
   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.
@@ -434,18 +423,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
@@ -455,18 +445,15 @@ 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
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: TImpressionsCountCache,
+  impressionCounts?: IImpressionCountsCacheSync,
   events: TEventsCache,
-  telemetry?: TTelemetryCache,
-  uniqueKeys?: TUniqueKeysCache,
+  telemetry?: TTelemetryCache
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -475,20 +462,16 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
   IEventsCacheSync,
-  ITelemetryCacheSync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheSync
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheAsync | ITelemetryCacheSync
   > { }
 
 /** StorageFactory */
@@ -498,14 +481,10 @@ export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 export interface IStorageFactoryParams {
   log: ILogger,
   impressionsQueueSize?: number,
-  impressionCountsQueueSize?: number,
-  impressionCountsRefreshRate?: number,
-  uniqueKeysRefreshRate?: number,
-  uniqueKeysCacheSize?: 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,

package/src/sync/submitters/submitterManager.ts

@@ -4,7 +4,6 @@ import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
-import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 
 export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
@@ -16,7 +15,6 @@ 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));
 
   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 { 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 { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_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,11 +9,12 @@ 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) {
+export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync) {
   return {
     isEmpty() { return false; }, // There is always data in telemetry cache
     clear() { }, //  No-op
@@ -31,9 +32,9 @@ export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, split
         iQ: telemetry.getImpressionStats(QUEUED),
         iDe: telemetry.getImpressionStats(DEDUPED),
         iDr: telemetry.getImpressionStats(DROPPED),
-        spC: splits.getSplitNames().length,
-        seC: segments.getRegisteredSegments().length,
-        skC: segments.getKeysCount(),
+        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),
@@ -52,9 +53,8 @@ const OPERATION_MODE_MAP = {
 
 const IMPRESSIONS_MODE_MAP = {
   [OPTIMIZED]: OPTIMIZED_ENUM,
-  [DEBUG]: DEBUG_ENUM,
-  [NONE]: NONE_ENUM
-} as Record<ISettings['sync']['impressionsMode'], (0 | 1 | 2)>;
+  [DEBUG]: DEBUG_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
 
 const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,
@@ -137,7 +137,12 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const startTime = timer(now);
 
   const submitter = firstPushWindowDecorator(
-    submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true),
+    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),
+      telemetryRefreshRate, 'telemetry stats', undefined, 0, true
+    ),
     telemetryRefreshRate
   );
 

package/src/sync/submitters/types.ts

@@ -1,5 +1,7 @@
+/* eslint-disable no-use-before-define */
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -35,24 +37,6 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
-export type UniqueKeysPayloadSs = {
-  keys: {
-    /** Split name */
-    f: string
-    /** keyNames */
-    ks: string[]
-  }[]
-}
-
-export type UniqueKeysPayloadCs = {
-  keys: {
-    /** keyNames */
-    k: string
-    /** Split name */
-    fs: string[]
-  }[]
-}
-
 export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
@@ -82,6 +66,33 @@ export type StoredEventWithMetadata = {
   e: SplitIO.EventData
 }
 
+export type MultiMethodLatencies = IMap<string, MethodLatencies>
+
+export type MultiMethodExceptions = IMap<string, MethodExceptions>
+
+export type MultiConfigs = IMap<string, TelemetryConfigStats>
+
+// export type StoredLatenciesWithMetadata = {
+//   /** Metadata */
+//   m: IMetadata,
+//   /** Stored latencies */
+//   l: MethodLatencies
+// }
+
+// export type StoredExceptionsWithMetadata = {
+//   /** Metadata */
+//   m: IMetadata,
+//   /** Stored exceptions */
+//   e: MethodExceptions
+// }
+
+// export type StoredConfigsWithMetadata = {
+//   /** Metadata */
+//   m: IMetadata,
+//   /** Stored configs */
+//   c: TelemetryConfigStats
+// }
+
 /**
  * Telemetry usage stats
  */
@@ -133,11 +144,15 @@ export type StreamingEvent = {
   t: number, // timestamp
 }
 
+// 'telemetry.latencias' and 'telemetry.exceptions' Redis/Pluggable keys
+export type TelemetryUsageStats = {
+  mL?: MethodLatencies, // clientMethodLatencies
+  mE?: MethodExceptions, // methodExceptions
+}
+
 // 'metrics/usage' JSON request body
-export type TelemetryUsageStatsPayload = {
+export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
   lS: LastSync, // lastSynchronization
-  mL: MethodLatencies, // clientMethodLatencies
-  mE: MethodExceptions, // methodExceptions
   hE: HttpErrors, // httpErrors
   hL: HttpLatencies, // httpLatencies
   tR: number, // tokenRefreshes
@@ -145,9 +160,9 @@ export type TelemetryUsageStatsPayload = {
   iQ: number, // impressionsQueued
   iDe: number, // impressionsDeduped
   iDr: number, // impressionsDropped
-  spC: number, // splitCount
-  seC: number, // segmentCount
-  skC: number, // segmentKeyCount
+  spC?: number, // splitCount
+  seC?: number, // segmentCount
+  skC?: number, // segmentKeyCount
   sL?: number, // sessionLengthMs
   eQ: number, // eventsQueued
   eD: number, // eventsDropped
@@ -166,8 +181,7 @@ export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_E
 
 export type OPTIMIZED_ENUM = 0;
 export type DEBUG_ENUM = 1;
-export type NONE_ENUM = 2;
-export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits