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

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,13 +37,15 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
+export type UniqueKeysItemSs = {
+  /** Split name */
+  f: string
+  /** keyNames */
+  ks: string[]
+}
+
 export type UniqueKeysPayloadSs = {
-  keys: {
-    /** Split name */
-    f: string
-    /** keyNames */
-    ks: string[]
-  }[]
+  keys: UniqueKeysItemSs[]
 }
 
 export type UniqueKeysPayloadCs = {
@@ -72,6 +76,8 @@ export type StoredImpressionWithMetadata = {
     c: number,
     /** time */
     m: number
+    /** previous time */
+    pt?: number
   }
 }
 
@@ -82,6 +88,12 @@ export type StoredEventWithMetadata = {
   e: SplitIO.EventData
 }
 
+export type MultiMethodLatencies = IMap<string, MethodLatencies>
+
+export type MultiMethodExceptions = IMap<string, MethodExceptions>
+
+export type MultiConfigs = IMap<string, TelemetryConfigStats>
+
 /**
  * Telemetry usage stats
  */
@@ -102,9 +114,9 @@ export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
 export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 
-export type LastSync = Record<OperationType, number | undefined>
-export type HttpErrors = Record<OperationType, { [statusCode: string]: number }>
-export type HttpLatencies = Record<OperationType, Array<number>>
+export type LastSync = Partial<Record<OperationType, number | undefined>>
+export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
+export type HttpLatencies = Partial<Record<OperationType, Array<number>>>
 
 export type TREATMENT = 't';
 export type TREATMENTS = 'ts';
@@ -113,9 +125,9 @@ export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
 export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
 
-export type MethodLatencies = Record<Method, Array<number>>;
+export type MethodLatencies = Partial<Record<Method, Array<number>>>;
 
-export type MethodExceptions = Record<Method, number>;
+export type MethodExceptions = Partial<Record<Method, number>>;
 
 export type CONNECTION_ESTABLISHED = 0;
 export type OCCUPANCY_PRI = 10;
@@ -133,11 +145,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 +161,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

package/src/sync/submitters/uniqueKeysSubmitter.ts

@@ -2,7 +2,8 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { submitterFactory } from './submitter';
 
-const DATA_NAME = 'uniqueKeys';
+const DATA_NAME = 'unique keys';
+const UNIQUE_KEYS_RATE = 900000; // 15 minutes
 
 /**
  * Submitter that periodically posts impression counts
@@ -10,15 +11,15 @@ const DATA_NAME = 'uniqueKeys';
 export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
 
   const {
-    settings: { log, scheduler: { uniqueKeysRefreshRate }, core: {key}},
+    settings: { log, core: { key } },
     splitApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
     storage: { uniqueKeys }
   } = params;
-  
+
   const isClientSide = key !== undefined;
   const postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
 
-  const syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, uniqueKeysRefreshRate, 'unique keys');
+  const syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, UNIQUE_KEYS_RATE, DATA_NAME);
 
   // register unique keys submitter to be executed when uniqueKeys cache is full
   uniqueKeys!.setOnFullQueueCb(() => {
@@ -29,7 +30,7 @@ export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
     // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
     // Data will be sent when submitter is resumed.
   });
-  
+
   return syncTask;
 }
 

package/src/trackers/impressionObserver/utils.ts

@@ -1,21 +1,6 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
-/**
- * Checks if impressions previous time should be added or not.
- */
-export function shouldAddPt(settings: ISettings) {
-  return [PRODUCER_MODE, STANDALONE_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-
-/**
- * Checks if it should dedupe impressions or not.
- */
-export function shouldBeOptimized(settings: ISettings) {
-  if (!shouldAddPt(settings)) return false;
-  return settings.sync.impressionsMode === OPTIMIZED ? true : false;
-}
-
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/src/trackers/impressionsTracker.ts

@@ -31,9 +31,9 @@ export function impressionsTrackerFactory(
 
       const impressionsCount = impressions.length;
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
+
       const impressionsToListenerCount = impressionsToListener.length;
-      
+
       if ( impressionsToStore.length>0 ){
         const res = impressionsCache.track(impressionsToStore);
 

package/src/trackers/strategy/strategyDebug.ts

@@ -4,14 +4,14 @@ import { IStrategy } from '../types';
 
 /**
  * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- * 
+ *
  * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
  * @returns IStrategyResult
  */
 export function strategyDebugFactory(
   impressionsObserver: IImpressionObserver
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       impressions.forEach((impression) => {
@@ -19,8 +19,8 @@ export function strategyDebugFactory(
         impression.pt = impressionsObserver.testAndSet(impression);
       });
       return {
-        impressionsToStore: impressions, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressions,
+        impressionsToListener: impressions,
         deduped: 0
       };
     }

package/src/trackers/strategy/strategyNone.ts

@@ -1,32 +1,32 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
 import { IStrategy, IUniqueKeysTracker } from '../types';
 
 /**
  * None strategy for impressions tracker.
- * 
+ *
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split. 
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
 export function strategyNoneFactory(
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
   uniqueKeysTracker: IUniqueKeysTracker
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
-      impressions.forEach((impression) => {        
+      impressions.forEach((impression) => {
         const now = Date.now();
         // Increments impression counter per featureName
         impressionsCounter.track(impression.feature, now, 1);
         // Keep track by unique key
         uniqueKeysTracker.track(impression.keyName, impression.feature);
       });
-      
+
       return {
-        impressionsToStore: [], 
-        impressionsToListener: impressions, 
+        impressionsToStore: [],
+        impressionsToListener: impressions,
         deduped: 0
       };
     }

package/src/trackers/strategy/strategyOptimized.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
 import { truncateTimeFrame } from '../../utils/time';
 import { IImpressionObserver } from '../impressionObserver/types';
@@ -6,35 +6,35 @@ import { IStrategy } from '../types';
 
 /**
  * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- * 
+ *
  * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
  * @returns IStrategyResult
  */
 export function strategyOptimizedFactory(
   impressionsObserver: IImpressionObserver,
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       const impressionsToStore: ImpressionDTO[] = [];
       impressions.forEach((impression) => {
         impression.pt = impressionsObserver.testAndSet(impression);
-        
+
         const now = Date.now();
-        
+
         // Increments impression counter per featureName
         if (impression.pt) impressionsCounter.track(impression.feature, now, 1);
-  
+
         // Checks if the impression should be added in queue to be sent
         if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
           impressionsToStore.push(impression);
         }
       });
       return {
-        impressionsToStore: impressionsToStore, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressionsToStore,
+        impressionsToListener: impressions,
         deduped: impressions.length - impressionsToStore.length
       };
     }

package/src/trackers/uniqueKeysTracker.ts

@@ -4,16 +4,16 @@ import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 
 const noopFilterAdapter = {
-  add() {return true;},
-  contains() {return true;},
-  clear() {}
+  add() { return true; },
+  contains() { return true; },
+  clear() { }
 };
 
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post. 
- * 
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ *
  * @param log Logger instance
  * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
@@ -42,7 +42,7 @@ export function uniqueKeysTrackerFactory(
     stop(): void {
       clearInterval(intervalId);
     }
-    
+
   };
 
 }

package/src/types.ts

@@ -80,8 +80,6 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
-    uniqueKeysRefreshRate: number,
-    uniqueKeysCacheSize: number,
     /**
      * @deprecated
      */

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/redis/RedisMock.ts

@@ -0,0 +1,33 @@
+//@ts-nocheck
+function identityFunction(data: any): any {
+  return data;
+}
+
+function asyncFunction(data: any): Promise<any> {
+  return Promise.resolve(data);
+}
+
+const IDENTITY_METHODS: string[] = [];
+const ASYNC_METHODS = ['rpush', 'hincrby'];
+const PIPELINE_METHODS = ['rpush', 'hincrby'];
+
+export class RedisMock {
+
+  private pipelineMethods: any = { exec: jest.fn(asyncFunction) }
+
+  constructor() {
+    IDENTITY_METHODS.forEach(method => {
+      this[method] = jest.fn(identityFunction);
+    });
+    ASYNC_METHODS.forEach(method => {
+      this[method] = jest.fn(asyncFunction);
+    });
+    PIPELINE_METHODS.forEach(method => {
+      this.pipelineMethods[method] = this[method];
+    });
+
+    this.pipeline = jest.fn(() => {return this.pipelineMethods;});
+  }
+
+
+}

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');
@@ -157,8 +153,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   if (storage) withDefaults.storage = storage(withDefaults);
 
   // Validate key and TT (for client-side)
+  const maybeKey = withDefaults.core.key;
   if (validationParams.acceptKey) {
-    const maybeKey = withDefaults.core.key;
     // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
     if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
       withDefaults.core.key = 'localhost_key';
@@ -175,6 +171,10 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
         withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
       }
     }
+  } else {
+    // On server-side, key is undefined and used to distinguish from client-side
+    if (maybeKey !== undefined) log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+    withDefaults.core.key = undefined;
   }
 
   // Current ip/hostname information

package/types/services/types.d.ts

@@ -24,8 +24,8 @@ export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<stri
 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;

package/types/storages/AbstractSplitsCacheAsync.d.ts

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

package/types/storages/AbstractSplitsCacheSync.d.ts

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

package/types/storages/KeyBuilderSS.d.ts

@@ -1,8 +1,12 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
+export declare const METHOD_NAMES: Record<Method, string>;
 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;
@@ -13,5 +17,4 @@ export declare class KeyBuilderSS extends KeyBuilder {
     buildLatencyKey(method: Method, bucket: number): string;
     buildExceptionKey(method: Method): string;
     buildInitKey(): string;
-    private buildVersionablePrefix;
 }

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

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

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

@@ -1,10 +1,21 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { ITelemetryCacheSync } from '../types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+export declare const MAX_LATENCY_BUCKET_COUNT = 23;
+export declare function newBuckets(): number[];
 /**
- * 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({ settings }: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
+    private splits?;
+    private segments?;
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
+    private e;
+    isEmpty(): boolean;
+    clear(): void;
+    pop(): TelemetryUsageStatsPayload;
+    /** Config stats */
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;
     recordTimeUntilReady(ms: number): void;
@@ -14,6 +25,7 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private notReadyUsage;
     getNonReadyUsage(): number;
     recordNonReadyUsage(): void;
+    /** Usage stats */
     private impressionStats;
     getImpressionStats(type: ImpressionDataType): number;
     recordImpressionStats(type: ImpressionDataType, count: number): void;
@@ -21,13 +33,15 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): LastSync;
+    getLastSynchronization(): Partial<Record<OperationType, number | undefined>>;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): HttpErrors;
+    popHttpErrors(): Partial<Record<OperationType, {
+        [statusCode: string]: number;
+    }>>;
     recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): HttpLatencies;
+    popHttpLatencies(): Partial<Record<OperationType, number[]>>;
     recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
@@ -45,9 +59,9 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): MethodExceptions;
+    popExceptions(): Partial<Record<Method, number>>;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): MethodLatencies;
+    popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
 }

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

@@ -1,21 +1,25 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { ISet } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export declare function fromUniqueKeysCollector(uniqueKeys: {
+    [featureName: string]: ISet<string>;
+}): UniqueKeysPayloadSs;
 export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
     protected onFullQueue?: () => void;
     private readonly maxStorage;
     private uniqueTrackerSize;
     protected uniqueKeysTracker: {
-        [keys: string]: ISet<string>;
+        [featureName: string]: ISet<string>;
     };
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;
     /**
-     * Store unique keys in sequential order
-     * key: string = feature name.
-     * value: Set<string> = set of unique keys.
+     * Store unique keys per feature.
      */
-    track(key: string, featureName: string): void;
+    track(userKey: string, featureName: string): void;
     /**
      * Clear the data stored on the cache.
      */
@@ -28,8 +32,4 @@ export declare class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
      * Check if the cache is empty.
      */
     isEmpty(): boolean;
-    /**
-     * Converts `uniqueKeys` data from cache into request payload for SS.
-     */
-    private fromUniqueKeysCollector;
 }

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

@@ -13,11 +13,9 @@ export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
     constructor(uniqueKeysQueueSize?: number);
     setOnFullQueueCb(cb: () => void): void;
     /**
-     * Store unique keys in sequential order
-     * key: string = key.
-     * value: HashSet<string> = set of split names.
+     * Store unique keys per feature.
      */
-    track(key: string, featureName: string): void;
+    track(userKey: string, featureName: string): void;
     /**
      * Clear the data stored on the cache.
      */