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

package/src/sync/submitters/submitterManager.ts

@@ -4,6 +4,7 @@ import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
+import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 
 export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
@@ -15,6 +16,7 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
+  if (params.uniqueKeysTracker) submitters.push(uniqueKeysSubmitterFactory(params));
 
   return {
     // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/src/sync/submitters/types.ts

@@ -35,6 +35,24 @@ export type ImpressionCountsPayload = {
   }[]
 }
 
+export type UniqueKeysPayloadSs = {
+  keys: {
+    /** Split name */
+    f: string
+    /** keyNames */
+    ks: string[]
+  }[]
+}
+
+export type UniqueKeysPayloadCs = {
+  keys: {
+    /** keyNames */
+    k: string
+    /** Split name */
+    fs: string[]
+  }[]
+}
+
 export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
@@ -148,7 +166,8 @@ export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_E
 
 export type OPTIMIZED_ENUM = 0;
 export type DEBUG_ENUM = 1;
-export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
+export type NONE_ENUM = 2;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits

package/src/sync/submitters/uniqueKeysSubmitter.ts

@@ -0,0 +1,79 @@
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { ISet, setToArray } from '../../utils/lang/sets';
+import { submitterFactory } from './submitter';
+import { UniqueKeysPayloadCs, UniqueKeysPayloadSs } from './types';
+
+/** 
+ * Invert keys for feature to features for key
+ */
+function invertUniqueKeys(uniqueKeys: { [featureName: string]: ISet<string> }): { [key: string]: string[] } {
+  const featureNames = Object.keys(uniqueKeys);
+  const inverted: { [key: string]: string[] } = {};
+  for (let i = 0; i < featureNames.length; i++) {
+    const featureName = featureNames[i];
+    const featureKeys = setToArray(uniqueKeys[featureName]);
+    for (let j = 0; j< featureKeys.length; j++) {
+      const featureKey = featureKeys[j];
+      if (!inverted[featureKey]) inverted[featureKey] = []; 
+      inverted[featureKey].push(featureName);
+    }
+  }
+  return inverted;
+}
+
+/**
+ * Converts `uniqueKeys` data from cache into request payload for CS.
+ */
+export function fromUniqueKeysCollectorCs(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+  const payload = [];
+  const featuresPerKey = invertUniqueKeys(uniqueKeys);
+  const keys = Object.keys(featuresPerKey);
+  for (let k = 0; k < keys.length; k++) {
+    const key = keys[k];
+    const uniqueKeysPayload = {
+      k: key,
+      fs: featuresPerKey[key]
+    };
+
+    payload.push(uniqueKeysPayload);
+  }
+  return { keys: payload };
+}
+
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+export function fromUniqueKeysCollectorSs(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+  const payload = [];
+  const featureNames = Object.keys(uniqueKeys);
+  for (let i = 0; i < featureNames.length; i++) {
+    const featureName = featureNames[i];
+    const featureKeys = setToArray(uniqueKeys[featureName]);
+    const uniqueKeysPayload = {
+      f: featureName,
+      ks: featureKeys
+    };
+
+    payload.push(uniqueKeysPayload);
+  }
+  return { keys: payload };
+}
+
+/**
+ * Submitter that periodically posts impression counts
+ */
+export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
+
+  const {
+    settings: { log, scheduler: { uniqueKeysRefreshRate }, core: {key}},
+    splitApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
+    storage: { uniqueKeys }
+  } = params;
+  
+  const isClientSide = key !== undefined;
+  const postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
+  const fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
+
+  return submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+}
+

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;
@@ -37,26 +31,10 @@ export function impressionsTrackerFactory(
 
       const impressionsCount = impressions.length;
 
-      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 { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
+      
+      const impressionsToListenerCount = impressionsToListener.length;
+      
       const res = impressionsCache.track(impressionsToStore);
 
       // If we're on an async storage, handle error and log it.
@@ -71,16 +49,16 @@ export function impressionsTrackerFactory(
         // @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);
+          (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 { IImpressionCountsCacheSync } 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: IImpressionCountsCacheSync,
+  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.feature, impression.keyName);
+      });
+      
+      return {
+        impressionsToStore: [], 
+        impressionsToListener: impressions, 
+        deduped: 0
+      };
+    }
+  };
+}

package/src/trackers/strategy/strategyOptimized.ts

@@ -0,0 +1,42 @@
+import { IImpressionCountsCacheSync } 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: IImpressionCountsCacheSync,
+): 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
+        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

@@ -2,6 +2,7 @@ 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,3 +43,32 @@ export interface ITelemetryTracker {
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
 }
+
+export interface IFilterAdapter {
+  add(featureName: string, key: string): boolean;
+  contains(featureName: string, key: string): boolean;
+  clear(): void;
+}
+
+export interface IImpressionSenderAdapter {
+  recordUniqueKeys(data: Object): void;
+  recordImpressionCounts(data: Object): void
+}
+
+/** 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;
+}
+
+export interface IStrategyResult {
+  impressionsToStore: ImpressionDTO[],
+  impressionsToListener: ImpressionDTO[],
+  deduped: number
+}
+
+export interface IStrategy {
+  process(impressions:  ImpressionDTO[]): IStrategyResult
+}

package/src/trackers/uniqueKeysTracker.ts

@@ -0,0 +1,80 @@
+import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
+import { ILogger } from '../logger/types';
+import { ISet, _Set } from '../utils/lang/sets';
+import { IFilterAdapter, IUniqueKeysTracker } from './types';
+
+const noopFilterAdapter = {
+  add() {return true;},
+  contains() {return true;},
+  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 filterAdapter filter adapter
+ * @param cacheSize optional internal cache size
+ * @param maxBulkSize optional max MTKs bulk size
+ */
+export function uniqueKeysTrackerFactory(
+  log: ILogger,
+  filterAdapter: IFilterAdapter = noopFilterAdapter,
+  cacheSize = DEFAULT_CACHE_SIZE,
+  // @TODO
+  // maxBulkSize: number = 5000,
+): IUniqueKeysTracker {
+  
+  let uniqueKeysTracker: { [featureName: string]: ISet<string> } = {};
+  let uniqueTrackerSize = 0;
+  
+  return {
+    track(featureName: string, key: string): void {
+      if (!filterAdapter.add(featureName, key)) {
+        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 = {};
+    },
+
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty() {
+      return Object.keys(uniqueKeysTracker).length === 0;
+    }
+    
+  };
+
+}

package/src/types.ts

@@ -80,6 +80,7 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
+    uniqueKeysRefreshRate: number,
     /**
      * @deprecated
      */
@@ -718,7 +719,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';

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

@@ -36,6 +36,8 @@ 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
@@ -130,11 +132,13 @@ 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/ga/GoogleAnalyticsToSplit.d.ts

@@ -1,3 +1,3 @@
 import { IntegrationFactory } from '../types';
 import { GoogleAnalyticsToSplitOptions } from './types';
-export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): IntegrationFactory;
+export declare function GoogleAnalyticsToSplit(options?: GoogleAnalyticsToSplitOptions): IntegrationFactory;

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) => 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/types.d.ts

@@ -2,6 +2,7 @@ import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types
 import { ILogger } from '../logger/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { ISet } from '../utils/lang/sets';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -297,6 +298,17 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
     isEmpty(): boolean;
     pop(toMerge?: Record<string, number>): Record<string, number>;
 }
+export interface IUniqueKeysCacheBase extends IRecorderCacheProducerSync<{
+    [featureName: string]: ISet<string>;
+}> {
+    track(featureName: string, timeFrame: number, amount: number): void;
+    isEmpty(): boolean;
+    pop(toMerge?: {
+        [featureName: string]: ISet<string>;
+    }): {
+        [featureName: string]: ISet<string>;
+    };
+}
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -366,19 +378,20 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
     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, IEventsCacheSync, ITelemetryCacheSync> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync> {
+export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;