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

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

@@ -1,10 +1,8 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { truncateTimeFrame } from '../utils/time';
-import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker } from './types';
+import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker, IStrategy } 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';
 
@@ -15,18 +13,14 @@ 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 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)
+ * @param strategy strategy for impressions tracking.
  */
 export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
+  strategy: IStrategy,
   integrationsManager?: IImpressionsHandler,
-  // 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
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
 
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
@@ -36,51 +30,36 @@ export function impressionsTrackerFactory(
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
+      const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
 
-      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 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, impressions.length - impressionsToStore.length);
+        // 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);
+          }
         }
       }
 
       // @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 < impressionsCount; i++) {
+        for (let i = 0; i < impressionsToListenerCount; i++) {
           const impressionData: SplitIO.ImpressionData = {
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-            impression: objectAssign({}, impressions[i]),
+            impression: objectAssign({}, impressionsToListener[i]),
             attributes,
             ip,
             hostname,

package/src/trackers/strategy/strategyDebug.ts

@@ -0,0 +1,28 @@
+import { ImpressionDTO } from '../../types';
+import { IImpressionObserver } from '../impressionObserver/types';
+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) => {
+        // Adds previous time if it is enabled
+        impression.pt = impressionsObserver.testAndSet(impression);
+      });
+      return {
+        impressionsToStore: impressions,
+        impressionsToListener: impressions,
+        deduped: 0
+      };
+    }
+  };
+}

package/src/trackers/strategy/strategyNone.ts

@@ -0,0 +1,34 @@
+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.
+ * @returns IStrategyResult
+ */
+export function strategyNoneFactory(
+  impressionsCounter: IImpressionCountsCacheBase,
+  uniqueKeysTracker: IUniqueKeysTracker
+): IStrategy {
+
+  return {
+    process(impressions: ImpressionDTO[]) {
+      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,
+        deduped: 0
+      };
+    }
+  };
+}

package/src/trackers/strategy/strategyOptimized.ts

@@ -0,0 +1,42 @@
+import { IImpressionCountsCacheBase } from '../../storages/types';
+import { ImpressionDTO } from '../../types';
+import { truncateTimeFrame } from '../../utils/time';
+import { IImpressionObserver } from '../impressionObserver/types';
+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: 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,
+        deduped: impressions.length - impressionsToStore.length
+      };
+    }
+  };
+}

package/src/trackers/types.ts

@@ -46,3 +46,31 @@ 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/trackers/uniqueKeysTracker.ts

@@ -0,0 +1,48 @@
+import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
+import { ILogger } from '../logger/types';
+import { IUniqueKeysCacheBase } from '../storages/types';
+import { IFilterAdapter, IUniqueKeysTracker } from './types';
+
+const noopFilterAdapter = {
+  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.
+ *
+ * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
+ */
+export function uniqueKeysTrackerFactory(
+  log: ILogger,
+  uniqueKeysCache: IUniqueKeysCacheBase,
+  filterAdapter: IFilterAdapter = noopFilterAdapter,
+): IUniqueKeysTracker {
+  let intervalId: any;
+
+  if (filterAdapter.refreshRate) {
+    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+  }
+
+  return {
+
+    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;
+      }
+      uniqueKeysCache.track(key, featureName);
+    },
+
+    stop(): void {
+      clearInterval(intervalId);
+    }
+
+  };
+
+}

package/src/types.ts

@@ -718,7 +718,7 @@ export namespace SplitIO {
   * ImpressionsMode type
   * @typedef {string} ImpressionsMode
   */
-  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG'
+  export type ImpressionsMode = 'OPTIMIZED' | 'DEBUG' | 'NONE'
   /**
    * Defines the format of Split data to preload on the factory storage (cache).
    */

package/src/utils/constants/index.ts

@@ -19,6 +19,7 @@ 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';
@@ -49,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/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/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 } from '../constants';
+import { DEBUG, OPTIMIZED, NONE } from '../constants';
 import { stringToUpperCase } from '../lang';
 
 export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
   impressionsMode = stringToUpperCase(impressionsMode);
 
-  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
+  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
 
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
   return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -153,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';
@@ -171,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/logger/constants.d.ts

@@ -138,4 +138,5 @@ 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 } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 /**
  * Environment related dependencies.
@@ -42,6 +42,7 @@ export interface ISdkFactoryContext {
     eventTracker: IEventTracker;
     telemetryTracker: ITelemetryTracker;
     storage: IStorageSync | IStorageAsync;
+    uniqueKeysTracker?: IUniqueKeysTracker;
     signalListener?: ISignalListener;
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
@@ -70,11 +71,12 @@ 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,6 +20,8 @@ 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, headers?: Record<string, string>) => Promise<IResponse>;
@@ -32,6 +34,8 @@ export interface ISplitApi {
     fetchSegmentChanges: IFetchSegmentChanges;
     fetchMySegments: IFetchMySegments;
     postEventsBulk: IPostEventsBulk;
+    postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
+    postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
     postMetricsConfig: IPostMetricsConfig;

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,6 +1,7 @@
 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 {
     latencyPrefix: string;
     exceptionPrefix: string;
@@ -9,12 +10,11 @@ export declare class KeyBuilderSS extends KeyBuilder {
     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;
 }
-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

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

@@ -1,13 +1,21 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { IStorageFactoryParams, 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(): any[];
+export declare function newBuckets(): number[];
 /**
  * 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(params: IStorageFactoryParams): 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;
@@ -17,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;
@@ -24,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;
@@ -48,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

@@ -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;
+}