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

package/src/trackers/impressionsTracker.ts

@@ -30,26 +30,27 @@ export function impressionsTrackerFactory(
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
-
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
       
       const impressionsToListenerCount = impressionsToListener.length;
       
-      const res = impressionsCache.track(impressionsToStore);
+      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);
+        // 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);
+          }
         }
       }
 

package/src/trackers/strategy/strategyNone.ts

@@ -21,7 +21,7 @@ export function strategyNoneFactory(
         // Increments impression counter per featureName
         impressionsCounter.track(impression.feature, now, 1);
         // Keep track by unique key
-        uniqueKeysTracker.track(impression.feature, impression.keyName);
+        uniqueKeysTracker.track(impression.keyName, impression.feature);
       });
       
       return {

package/src/trackers/strategy/strategyOptimized.ts

@@ -25,7 +25,7 @@ export function strategyOptimizedFactory(
         const now = Date.now();
         
         // Increments impression counter per featureName
-        impressionsCounter.track(impression.feature, now, 1);
+        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)) {

package/src/trackers/telemetryTracker.ts

@@ -48,6 +48,10 @@ export function telemetryTrackerFactory(
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }
+      },
+      addTag(tag: string) {
+        // @ts-ignore
+        if (telemetryCache.addTag) telemetryCache.addTag(tag);
       }
     };
 
@@ -56,8 +60,9 @@ export function telemetryTrackerFactory(
     return {
       trackEval: noopTrack,
       trackHttp: noopTrack,
-      sessionLength: () => { },
-      streamingEvent: () => { },
+      sessionLength() { },
+      streamingEvent() { },
+      addTag() { }
     };
   }
 }

package/src/trackers/types.ts

@@ -2,7 +2,6 @@ import { SplitIO, ImpressionDTO } from '../types';
 import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
-import { ISet } from '../utils/lang/sets';
 
 /** Events tracker */
 
@@ -42,12 +41,17 @@ export interface ITelemetryTracker {
    * Records streaming event
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
+  /**
+   * Records tag
+   */
+  addTag(tag: string): void
 }
 
 export interface IFilterAdapter {
-  add(featureName: string, key: string): boolean;
-  contains(featureName: string, key: string): boolean;
+  add(key: string, featureName: string): boolean;
+  contains(key: string, featureName: string): boolean;
   clear(): void;
+  refreshRate?: number;
 }
 
 export interface IImpressionSenderAdapter {
@@ -57,10 +61,8 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
-  track(featureName: string, key: string): void;
-  pop(toMerge?: { [featureName: string]: ISet<string> }): { [featureName: string]: ISet<string>; };
-  clear(): void;
-  isEmpty(): boolean;
+  stop(): void;
+  track(key: string, featureName: string): void;
 }
 
 export interface IStrategyResult {

package/src/trackers/uniqueKeysTracker.ts

@@ -1,6 +1,6 @@
 import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
 import { ILogger } from '../logger/types';
-import { ISet, _Set } from '../utils/lang/sets';
+import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 
 const noopFilterAdapter = {
@@ -9,70 +9,38 @@ const noopFilterAdapter = {
   clear() {}
 };
 
-const DEFAULT_CACHE_SIZE = 30000;
 /**
  * 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. 
  * 
  * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
 export function uniqueKeysTrackerFactory(
   log: ILogger,
+  uniqueKeysCache: IUniqueKeysCacheBase,
   filterAdapter: IFilterAdapter = noopFilterAdapter,
-  cacheSize = DEFAULT_CACHE_SIZE,
-  // @TODO
-  // maxBulkSize: number = 5000,
 ): IUniqueKeysTracker {
-  
-  let uniqueKeysTracker: { [featureName: string]: ISet<string> } = {};
-  let uniqueTrackerSize = 0;
-  
+  let intervalId: any;
+
+  if (filterAdapter.refreshRate) {
+    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+  }
+
   return {
-    track(featureName: string, key: string): void {
-      if (!filterAdapter.add(featureName, key)) {
+
+    track(key: string, featureName: string): void {
+      if (!filterAdapter.add(key, featureName)) {
         log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The feature ${featureName} and key ${key} exist in the filter`);
         return;
       }
-      if (!uniqueKeysTracker[featureName]) uniqueKeysTracker[featureName] = new _Set();
-      const tracker = uniqueKeysTracker[featureName];
-      if (!tracker.has(key)) {
-        tracker.add(key);
-        log.debug(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}Key ${key} added to feature ${featureName}`);
-        uniqueTrackerSize++;
-      }
-      
-      if (uniqueTrackerSize >= cacheSize) {
-        log.warn(`${LOG_PREFIX_UNIQUE_KEYS_TRACKER}The UniqueKeysTracker size reached the maximum limit`);
-        // @TODO trigger event to submitter to send mtk
-        uniqueTrackerSize = 0;
-      }
-    },
-    
-    /**
-     * Pop the collected data, used as payload for posting.
-     */
-    pop() {
-      const data = uniqueKeysTracker;
-      uniqueKeysTracker = {};
-      return data;
-    },
-
-    /**
-     * Clear the data stored on the cache.
-     */
-    clear() {
-      uniqueKeysTracker = {};
+      uniqueKeysCache.track(key, featureName);
     },
 
-    /**
-     * Check if the cache is empty.
-     */
-    isEmpty() {
-      return Object.keys(uniqueKeysTracker).length === 0;
+    stop(): void {
+      clearInterval(intervalId);
     }
     
   };

package/src/types.ts

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

package/src/utils/constants/index.ts

@@ -50,6 +50,7 @@ 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/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,12 @@ 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/integrations/types.d.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 export interface IIntegration {
     queue(data: SplitIO.IntegrationData): void;
@@ -10,6 +10,7 @@ export interface IIntegrationFactoryParams {
         events: IEventsCacheBase;
     };
     settings: ISettings;
+    telemetryTracker: ITelemetryTracker;
 }
 export declare type IntegrationFactory = {
     readonly type: string;

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

@@ -1,17 +1,18 @@
 import { ISplitsCacheAsync } from './types';
+import { ISplit } from '../dtos/types';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-    abstract addSplit(name: string, split: string): Promise<boolean>;
-    abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    abstract addSplit(name: string, split: ISplit): Promise<boolean>;
+    abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     abstract removeSplits(names: string[]): Promise<boolean[] | void>;
-    abstract getSplit(name: string): Promise<string | null>;
-    abstract getSplits(names: string[]): Promise<Record<string, string | null>>;
+    abstract getSplit(name: string): Promise<ISplit | null>;
+    abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     abstract setChangeNumber(changeNumber: number): Promise<boolean | void>;
     abstract getChangeNumber(): Promise<number>;
-    abstract getAll(): Promise<string[]>;
+    abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
@@ -28,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

@@ -5,15 +5,15 @@ import { ISplit } from '../dtos/types';
  * to minimize the effort required to implement this interface.
  */
 export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-    abstract addSplit(name: string, split: string): boolean;
-    addSplits(entries: [string, string][]): boolean[];
+    abstract addSplit(name: string, split: ISplit): boolean;
+    addSplits(entries: [string, ISplit][]): boolean[];
     abstract removeSplit(name: string): boolean;
     removeSplits(names: string[]): boolean[];
-    abstract getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    abstract getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     abstract setChangeNumber(changeNumber: number): boolean;
     abstract getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     abstract getSplitNames(): string[];
     abstract trafficTypeExists(trafficType: string): boolean;
     abstract usesSegments(): boolean;
@@ -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

@@ -2,14 +2,21 @@ 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/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
@@ -26,9 +26,9 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
      */
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): any;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];
@@ -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/ImpressionCountsCacheInMemory.d.ts

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

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

@@ -1,3 +1,4 @@
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -9,9 +10,9 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private changeNumber;
     private splitsWithSegmentsCount;
     clear(): void;
-    addSplit(name: string, split: string): boolean;
+    addSplit(name: string, split: ISplit): boolean;
     removeSplit(name: string): boolean;
-    getSplit(name: string): string | null;
+    getSplit(name: string): ISplit | null;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
     getSplitNames(): string[];

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(): 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(params: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;

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

@@ -0,0 +1,35 @@
+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: {
+        [featureName: string]: ISet<string>;
+    };
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys per feature.
+     */
+    track(userKey: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadSs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+}

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

@@ -0,0 +1,35 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+    private onFullQueue?;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    private uniqueKeysTracker;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys per feature.
+     */
+    track(userKey: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadCs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    private fromUniqueKeysCollector;
+}

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/ImpressionCountsCacheInRedis.d.ts

@@ -0,0 +1,16 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsPayload } from '../../sync/submitters/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
+    private postImpressionCountsInRedis;
+    start(): void;
+    stop(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    getImpressionsCount(): Promise<ImpressionCountsPayload | undefined>;
+}