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

package/src/trackers/impressionsTracker.ts

@@ -1,8 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
+import { truncateTimeFrame } from '../utils/time';
+import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
+import { IImpressionObserver } from './impressionObserver/types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 
@@ -13,14 +15,18 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
+ * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
 export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
-  strategy: IStrategy,
   integrationsManager?: IImpressionsHandler,
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
+  // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
+  observer?: IImpressionObserver,
+  // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
+  countsCache?: IImpressionCountsCacheSync,
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IImpressionsTracker {
 
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
@@ -30,36 +36,51 @@ export function impressionsTrackerFactory(
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
-      const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
-      const impressionsToListenerCount = impressionsToListener.length;
-      
-      if ( impressionsToStore.length>0 ){
-        const res = impressionsCache.track(impressionsToStore);
 
-        // If we're on an async storage, handle error and log it.
-        if (thenable(res)) {
-          res.then(() => {
-            log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-          }).catch(err => {
-            log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-          });
-        } else {
-          // Record when impressionsCache is sync only (standalone mode)
-          // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-          if (telemetryCache) {
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
-            (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, deduped);
-          }
+      const impressionsToStore: ImpressionDTO[] = []; // Track only the impressions that are going to be stored
+      // Wraps impressions to store and adds previousTime if it corresponds
+      impressions.forEach((impression) => {
+        if (observer) {
+          // Adds previous time if it is enabled
+          impression.pt = observer.testAndSet(impression);
+        }
+
+        const now = Date.now();
+        if (countsCache) {
+          // Increments impression counter per featureName
+          countsCache.track(impression.feature, now, 1);
+        }
+
+        // Checks if the impression should be added in queue to be sent
+        if (!countsCache || !impression.pt || impression.pt < truncateTimeFrame(now)) {
+          impressionsToStore.push(impression);
+        }
+      });
+
+      const res = impressionsCache.track(impressionsToStore);
+
+      // If we're on an async storage, handle error and log it.
+      if (thenable(res)) {
+        res.then(() => {
+          log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+        }).catch(err => {
+          log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+        });
+      } else {
+        // Record when impressionsCache is sync only (standalone mode)
+        // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+        if (telemetryCache) {
+          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
+          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
         }
       }
 
       // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
       if (impressionListener || integrationsManager) {
-        for (let i = 0; i < impressionsToListenerCount; i++) {
+        for (let i = 0; i < impressionsCount; i++) {
           const impressionData: SplitIO.ImpressionData = {
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-            impression: objectAssign({}, impressionsToListener[i]),
+            impression: objectAssign({}, impressions[i]),
             attributes,
             ip,
             hostname,

package/src/trackers/types.ts

@@ -46,31 +46,3 @@ export interface ITelemetryTracker {
    */
   addTag(tag: string): void
 }
-
-export interface IFilterAdapter {
-  add(key: string, featureName: string): boolean;
-  contains(key: string, featureName: string): boolean;
-  clear(): void;
-  refreshRate?: number;
-}
-
-export interface IImpressionSenderAdapter {
-  recordUniqueKeys(data: Object): void;
-  recordImpressionCounts(data: Object): void
-}
-
-/** Unique keys tracker */
-export interface IUniqueKeysTracker {
-  stop(): void;
-  track(key: string, featureName: string): void;
-}
-
-export interface IStrategyResult {
-  impressionsToStore: ImpressionDTO[],
-  impressionsToListener: ImpressionDTO[],
-  deduped: number
-}
-
-export interface IStrategy {
-  process(impressions:  ImpressionDTO[]): IStrategyResult
-}

package/src/types.ts

@@ -80,8 +80,6 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
-    uniqueKeysRefreshRate: number,
-    uniqueKeysCacheSize: number,
     /**
      * @deprecated
      */
@@ -720,7 +718,7 @@ export namespace SplitIO {
   * ImpressionsMode type
   * @typedef {string} ImpressionsMode
   */
-  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE'
+  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG'
   /**
    * Defines the format of Split data to preload on the factory storage (cache).
    */

package/src/utils/constants/index.ts

@@ -19,7 +19,6 @@ export const SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export const DEBUG = 'DEBUG';
 export const OPTIMIZED = 'OPTIMIZED';
-export const NONE = 'NONE';
 
 // SDK Modes
 export const LOCALHOST_MODE: SDKMode = 'localhost';
@@ -50,7 +49,6 @@ export const CONSUMER_PARTIAL_ENUM = 2;
 
 export const OPTIMIZED_ENUM = 0;
 export const DEBUG_ENUM = 1;
-export const NONE_ENUM = 2;
 
 export const SPLITS = 'sp';
 export const IMPRESSIONS = 'im';

package/src/utils/lang/maps.ts

@@ -24,10 +24,12 @@ THE SOFTWARE.
 **/
 
 export interface IMap<K, V> {
-  set(key: K, value: V): this;
   clear(): void;
   delete(key: K): boolean;
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
   get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): this;
   readonly size: number;
 }
 
@@ -46,13 +48,6 @@ export class MapPoly<K, V> implements IMap<K, V>{
     this.__mapValuesData__.length = 0;
   }
 
-  set(key: K, value: V) {
-    let index = this.__mapKeysData__.indexOf(key);
-    if (index === -1) index = this.__mapKeysData__.push(key) - 1;
-    this.__mapValuesData__[index] = value;
-    return this;
-  }
-
   delete(key: K) {
     const index = this.__mapKeysData__.indexOf(key);
     if (index === -1) return false;
@@ -61,12 +56,29 @@ export class MapPoly<K, V> implements IMap<K, V>{
     return true;
   }
 
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any) {
+    for (let i = 0; i < this.__mapKeysData__.length; i++) {
+      callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this as any);
+    }
+  }
+
   get(key: K) {
     const index = this.__mapKeysData__.indexOf(key);
     if (index === -1) return;
     return this.__mapValuesData__[index];
   }
 
+  has(key: K): boolean {
+    return this.__mapKeysData__.indexOf(key) !== -1;
+  }
+
+  set(key: K, value: V) {
+    let index = this.__mapKeysData__.indexOf(key);
+    if (index === -1) index = this.__mapKeysData__.push(key) - 1;
+    this.__mapValuesData__[index] = value;
+    return this;
+  }
+
   get size() {
     return this.__mapKeysData__.length;
   }

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,14 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 
 export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
   impressionsMode = stringToUpperCase(impressionsMode);
 
-  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
+  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
 
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
   return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -36,8 +36,6 @@ export const base = {
     telemetryRefreshRate: 3600,
     // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
     impressionsRefreshRate: 300,
-    // publish unique Keys each 900 sec (15 min) 
-    uniqueKeysRefreshRate: 900,
     // fetch offline changes each 15 sec
     offlineRefreshRate: 15,
     // publish events every 60 seconds after the first flush
@@ -132,13 +130,11 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
   scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
   scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-  scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
   if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
-  
 
   // Log deprecation for old telemetry param
   if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');

package/types/logger/constants.d.ts

@@ -138,5 +138,4 @@ export declare const LOG_PREFIX_SYNC_POLLING: string;
 export declare const LOG_PREFIX_SYNC_SUBMITTERS: string;
 export declare const LOG_PREFIX_IMPRESSIONS_TRACKER = "impressions-tracker: ";
 export declare const LOG_PREFIX_EVENTS_TRACKER = "events-tracker: ";
-export declare const LOG_PREFIX_UNIQUE_KEYS_TRACKER = "unique-keys-tracker: ";
 export declare const LOG_PREFIX_CLEANUP = "cleanup: ";

package/types/sdkFactory/types.d.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
@@ -42,7 +42,6 @@ export interface ISdkFactoryContext {
     eventTracker: IEventTracker;
     telemetryTracker: ITelemetryTracker;
     storage: IStorageSync | IStorageAsync;
-    uniqueKeysTracker?: IUniqueKeysTracker;
     signalListener?: ISignalListener;
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
@@ -71,12 +70,11 @@ export interface ISdkFactoryParams {
         (): SplitIO.ICsClient;
         (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient;
     } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient));
-    impressionsObserverFactory: () => IImpressionObserver;
-    filterAdapterFactory?: () => IFilterAdapter;
     SignalListener?: new (syncManager: ISyncManager | undefined, // Used by NodeSignalListener to flush data, and by BrowserSignalListener to close streaming connection.
     settings: ISettings, // Used by BrowserSignalListener
     storage: IStorageSync | IStorageAsync, // Used by BrowserSignalListener
     serviceApi: ISplitApi | undefined) => ISignalListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
+    impressionsObserverFactory?: () => IImpressionObserver;
     extraProps?: (params: ISdkFactoryContext) => object;
 }

package/types/services/types.d.ts

@@ -20,12 +20,10 @@ export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
-export declare type IPostMetricsUsage = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
+export declare type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export interface ISplitApi {
     getSdkAPIHealthCheck: IHealthCheckAPI;
     getEventsAPIHealthCheck: IHealthCheckAPI;
@@ -34,8 +32,6 @@ export interface ISplitApi {
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
-    postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
-    postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
     postMetricsConfig: IPostMetricsConfig;

package/types/storages/KeyBuilderSS.d.ts

@@ -2,16 +2,19 @@ import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
 export declare class KeyBuilderSS extends KeyBuilder {
-    protected readonly metadata: IMetadata;
+    latencyPrefix: string;
+    exceptionPrefix: string;
+    initPrefix: string;
+    private versionablePrefix;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;
-    buildImpressionsCountKey(): string;
-    buildUniqueKeysKey(): string;
     buildEventsKey(): string;
     searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;
     buildExceptionKey(method: Method): string;
     buildInitKey(): string;
-    private buildVersionablePrefix;
 }
+export declare function parseMetadata(field: string): [metadata: string] | string;
+export declare function parseExceptionField(field: string): [metadata: string, method: Method] | string;
+export declare function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string;

package/types/storages/inMemory/ImpressionCountsCacheInMemory.d.ts

@@ -1,10 +1,6 @@
 import { IImpressionCountsCacheSync } from '../types';
 export declare class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-    protected cache: Record<string, number>;
-    private readonly maxStorage;
-    protected onFullQueue?: () => void;
-    private cacheSize;
-    constructor(impressionCountsCacheSize?: number);
+    private cache;
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,9 +1,12 @@
 import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { ITelemetryCacheSync } from '../types';
+import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+export declare const MAX_LATENCY_BUCKET_COUNT = 23;
+export declare function newBuckets(): any[];
 /**
- * Used on client-side. 0.1% of instances will track telemetry
+ * Record telemetry if mode is not localhost.
+ * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export declare function shouldRecordTelemetry(): boolean;
+export declare function shouldRecordTelemetry(params: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;

package/types/storages/inRedis/EventsCacheInRedis.d.ts

@@ -23,7 +23,7 @@ export declare class EventsCacheInRedis implements IEventsCacheAsync {
     drop(count?: number): Promise<any>;
     /**
      * Pop the given number of events from the storage.
-     * The returned promise rejects if the wrapper operation fails.
+     * The returned promise rejects if the redis operation fails.
      *
      * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
      * It is the submitter responsability to handle that.

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { Redis } from 'ioredis';
@@ -17,4 +17,19 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
     recordConfig(): Promise<number | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

package/types/storages/inRedis/constants.d.ts

@@ -1,4 +1 @@
 export declare const LOG_PREFIX = "storage:redis: ";
-export declare const DEFAULT_CACHE_SIZE = 30000;
-export declare const REFRESH_RATE = 300000;
-export declare const TTL_REFRESH = 3600;

package/types/storages/pluggable/TelemetryCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
@@ -15,4 +15,20 @@ export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<boolean | void>;
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popLatencies(): Promise<MultiMethodLatencies>;
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popExceptions(): Promise<MultiMethodExceptions>;
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    popConfigs(): Promise<MultiConfigs>;
 }

package/types/storages/types.d.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';
 /**
  * Interface of a pluggable storage wrapper.
@@ -297,13 +297,6 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     isEmpty(): boolean;
     pop(toMerge?: Record<string, number>): Record<string, number>;
 }
-export interface IUniqueKeysCacheBase {
-    track(key: string, value: string): void;
-    isEmpty(): boolean;
-    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
-    setOnFullQueueCb(cb: () => void): void;
-    clear(): void;
-}
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -361,43 +354,42 @@ export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITel
  * Methods are async because data is stored in Redis or a pluggable storage.
  */
 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>;
 }
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync {
+export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync, ITelemetryEvaluationConsumerAsync {
 }
 /**
  * Storages
  */
-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> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
-    impressionCounts?: TImpressionsCountCache;
+    impressionCounts?: IImpressionCountsCacheSync;
     events: TEventsCache;
     telemetry?: TTelemetryCache;
-    uniqueKeys?: TUniqueKeysCache;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     log: ILogger;
     impressionsQueueSize?: number;
-    uniqueKeysCacheSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
     mode: SDKMode;
-    impressionsMode?: string;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
     onReadyCb: (error?: any) => void;

package/types/sync/submitters/telemetrySubmitter.d.ts

@@ -5,7 +5,7 @@ import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
-export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits: ISplitsCacheSync, segments: ISegmentsCacheSync): {
+export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync): {
     isEmpty(): boolean;
     clear(): void;
     pop(): TelemetryUsageStatsPayload;

package/types/sync/submitters/types.d.ts

@@ -1,5 +1,6 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
@@ -32,22 +33,6 @@ export declare type ImpressionCountsPayload = {
         rc: number;
     }[];
 };
-export declare type UniqueKeysPayloadSs = {
-    keys: {
-        /** Split name */
-        f: string;
-        /** keyNames */
-        ks: string[];
-    }[];
-};
-export declare type UniqueKeysPayloadCs = {
-    keys: {
-        /** keyNames */
-        k: string;
-        /** Split name */
-        fs: string[];
-    }[];
-};
 export declare type StoredImpressionWithMetadata = {
     /** Metadata */
     m: IMetadata;
@@ -75,6 +60,9 @@ export declare type StoredEventWithMetadata = {
     /** Stored event */
     e: SplitIO.EventData;
 };
+export declare type MultiMethodLatencies = IMap<string, MethodLatencies>;
+export declare type MultiMethodExceptions = IMap<string, MethodExceptions>;
+export declare type MultiConfigs = IMap<string, TelemetryConfigStats>;
 /**
  * Telemetry usage stats
  */
@@ -119,10 +107,12 @@ export declare type StreamingEvent = {
     d?: number;
     t: number;
 };
-export declare type TelemetryUsageStatsPayload = {
+export declare type TelemetryUsageStats = {
+    mL?: MethodLatencies;
+    mE?: MethodExceptions;
+};
+export declare type TelemetryUsageStatsPayload = TelemetryUsageStats & {
     lS: LastSync;
-    mL: MethodLatencies;
-    mE: MethodExceptions;
     hE: HttpErrors;
     hL: HttpLatencies;
     tR: number;
@@ -130,9 +120,9 @@ export declare type TelemetryUsageStatsPayload = {
     iQ: number;
     iDe: number;
     iDr: number;
-    spC: number;
-    seC: number;
-    skC: number;
+    spC?: number;
+    seC?: number;
+    skC?: number;
     sL?: number;
     eQ: number;
     eD: number;
@@ -148,8 +138,7 @@ export declare type CONSUMER_PARTIAL_ENUM = 2;
 export declare type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_ENUM;
 export declare type OPTIMIZED_ENUM = 0;
 export declare type DEBUG_ENUM = 1;
-export declare type NONE_ENUM = 2;
-export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
+export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 export declare type RefreshRates = {
     sp: number;
     se?: number;