@splitsoftware/splitio-commons 1.6.2-rc.4 → 1.6.2-rc.5

package/src/sync/offline/splitsParser/splitsParserFromSettings.ts

@@ -1,23 +1,23 @@
 import { ISplitPartial } from '../../../dtos/types';
-import { ISettings, MockedFeaturesMap, TreatmentWithConfig } from '../../../types';
+import { ISettings, SplitIO } from '../../../types';
 import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
-function hasTreatmentChanged(prev: string | TreatmentWithConfig, curr: string | TreatmentWithConfig) {
+function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
   if (typeof prev !== typeof curr) return true;
 
   if (typeof prev === 'string') { // strings treatments, just compare
     return prev !== curr;
   } else { // has treatment and config, compare both
-    return prev.treatment !== (curr as TreatmentWithConfig).treatment || prev.config !== (curr as TreatmentWithConfig).config;
+    return prev.treatment !== (curr as SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
   }
 }
 
 export function splitsParserFromSettingsFactory() {
 
-  let previousMock: MockedFeaturesMap = { 'emptyMock': '1' };
+  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
 
-  function mockUpdated(currentData: MockedFeaturesMap) {
+  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
     const names = Object.keys(currentData);
 
     // Different amount of items
@@ -42,7 +42,7 @@ export function splitsParserFromSettingsFactory() {
    * @param settings validated object with mocked features mapping.
    */
   return function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
-    const features = settings.features as MockedFeaturesMap || {};
+    const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;
 
@@ -53,8 +53,8 @@ export function splitsParserFromSettingsFactory() {
       let config = null;
 
       if (isObject(data)) {
-        treatment = (data as TreatmentWithConfig).treatment;
-        config = (data as TreatmentWithConfig).config || config;
+        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
+        config = (data as SplitIO.TreatmentWithConfig).config || config;
       }
       const configurations: Record<string, string> = {};
       if (config !== null) configurations[treatment as string] = config;

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -4,7 +4,7 @@ import { IReadinessManager } from '../../../readiness/types';
 import { MaybeThenable } from '../../../dtos/types';
 import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { thenable } from '../../../utils/promise/thenable';
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -5,7 +5,7 @@ import { ISplit, ISplitChangesResponse } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>

package/src/sync/streaming/SSEHandler/index.ts

@@ -4,7 +4,7 @@ import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_S
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 import { ITelemetryTracker } from '../../../trackers/types';

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';

package/src/sync/submitters/submitter.ts

@@ -1,7 +1,7 @@
 import { syncTaskFactory } from '../syncTask';
 import { ISyncTask } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
 

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/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
 import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -52,8 +52,9 @@ const OPERATION_MODE_MAP = {
 
 const IMPRESSIONS_MODE_MAP = {
   [OPTIMIZED]: OPTIMIZED_ENUM,
-  [DEBUG]: DEBUG_ENUM
-} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
+  [DEBUG]: DEBUG_ENUM,
+  [NONE]: NONE_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1 | 2)>;
 
 const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,

package/src/sync/submitters/types.ts

@@ -1,5 +1,5 @@
 import { IMetadata } from '../../dtos/types';
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -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,
@@ -61,7 +79,7 @@ export type StoredEventWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored event */
-  e: EventData
+  e: SplitIO.EventData
 }
 
 /**
@@ -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,35 @@
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { submitterFactory } from './submitter';
+
+const DATA_NAME = 'uniqueKeys';
+
+/**
+ * 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 syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys!, uniqueKeysRefreshRate, 'unique keys');
+
+  // register unique keys submitter to be executed when uniqueKeys cache is full
+  uniqueKeys!.setOnFullQueueCb(() => {
+    if (syncTask.isRunning()) {
+      log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+      syncTask.execute();
+    }
+    // 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/sync/syncTask.ts

@@ -1,5 +1,5 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
-import { ILogger } from '../types';
+import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 
 /**

package/src/trackers/eventTracker.ts

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IEventsCacheBase, ITelemetryCacheAsync, ITelemetryCacheSync } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { ISettings, EventData } from '../types';
+import { ISettings, SplitIO } from '../types';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
 import { isStorageSync } from './impressionObserver/utils';
@@ -23,7 +23,7 @@ export function eventTrackerFactory(
   const log = settings.log;
   const isSync = isStorageSync(settings);
 
-  function queueEventsCallback(eventData: EventData, tracked: boolean) {
+  function queueEventsCallback(eventData: SplitIO.EventData, tracked: boolean) {
     const { eventTypeId, trafficTypeName, key, value, timestamp, properties } = eventData;
     // Logging every prop would be too much.
     const msg = `event of type "${eventTypeId}" for traffic type "${trafficTypeName}". Key: ${key}. Value: ${value}. Timestamp: ${timestamp}. ${properties ? 'With properties.' : 'With no properties.'}`;
@@ -48,7 +48,7 @@ export function eventTrackerFactory(
   }
 
   return {
-    track(eventData: EventData, size?: number) {
+    track(eventData: SplitIO.EventData, size?: number) {
       if (settings.userConsent === CONSENT_DECLINED) {
         return isSync ? false : Promise.resolve(false);
       }

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 { ImpressionDTO, ISettings, Attributes, ImpressionData } from '../types';
-import { IImpressionObserver } from './impressionObserver/types';
+import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 
@@ -15,72 +13,53 @@ 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;
 
   return {
-    track(impressions: ImpressionDTO[], attributes?: Attributes) {
+    track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
+      const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
+      
+      const impressionsToListenerCount = impressionsToListener.length;
+      
+      if ( impressionsToStore.length>0 ){
+        const res = impressionsCache.track(impressionsToStore);
 
-      const impressionsToStore: ImpressionDTO[] = []; // Track only the impressions that are going to be stored
-      // Wraps impressions to store and adds previousTime if it corresponds
-      impressions.forEach((impression) => {
-        if (observer) {
-          // Adds previous time if it is enabled
-          impression.pt = observer.testAndSet(impression);
-        }
-
-        const now = Date.now();
-        if (countsCache) {
-          // Increments impression counter per featureName
-          countsCache.track(impression.feature, now, 1);
-        }
-
-        // Checks if the impression should be added in queue to be sent
-        if (!countsCache || !impression.pt || impression.pt < truncateTimeFrame(now)) {
-          impressionsToStore.push(impression);
-        }
-      });
-
-      const res = impressionsCache.track(impressionsToStore);
-
-      // If we're on an async storage, handle error and log it.
-      if (thenable(res)) {
-        res.then(() => {
-          log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-        }).catch(err => {
-          log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-        });
-      } else {
-        // Record when impressionsCache is sync only (standalone mode)
-        // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-        if (telemetryCache) {
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
-          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
+        // 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++) {
-          const impressionData: ImpressionData = {
+        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.keyName, impression.feature);
+      });
+      
+      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

@@ -1,4 +1,4 @@
-import { ImpressionDTO, EventData, ImpressionData, Attributes } from '../types';
+import { SplitIO, ImpressionDTO } from '../types';
 import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
@@ -6,7 +6,7 @@ import { NetworkError } from '../services/types';
 /** Events tracker */
 
 export interface IEventsHandler {
-  handleEvent(eventData: EventData): any
+  handleEvent(eventData: SplitIO.EventData): any
 }
 
 export type IEventTracker = IEventsCacheBase
@@ -14,11 +14,11 @@ export type IEventTracker = IEventsCacheBase
 /** Impressions tracker */
 
 export interface IImpressionsHandler {
-  handleImpression(impressionData: ImpressionData): any
+  handleImpression(impressionData: SplitIO.ImpressionData): any
 }
 
 export interface IImpressionsTracker {
-  track(impressions: ImpressionDTO[], attributes?: Attributes): void
+  track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void
 }
 
 /** Telemetry tracker */
@@ -42,3 +42,29 @@ export interface ITelemetryTracker {
    */
   streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
 }
+
+export interface IFilterAdapter {
+  add(key: string, featureName: string): boolean;
+  contains(key: string, featureName: string): boolean;
+  clear(): void;
+}
+
+export interface IImpressionSenderAdapter {
+  recordUniqueKeys(data: Object): void;
+  recordImpressionCounts(data: Object): void
+}
+
+/** Unique keys tracker */
+export interface IUniqueKeysTracker {
+  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,37 @@
+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 filterAdapter filter adapter
+ * @param uniqueKeysCache cache to save unique keys
+ */
+export function uniqueKeysTrackerFactory(
+  log: ILogger,
+  uniqueKeysCache: IUniqueKeysCacheBase,
+  filterAdapter: IFilterAdapter = noopFilterAdapter,
+): IUniqueKeysTracker {
+  
+  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);
+    }
+  };
+
+}