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

package/src/storages/types.ts

@@ -1,8 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
-import { ILogger } from '../logger/types';
+import { MaybeThenable, IMetadata } from '../dtos/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';
+import { ImpressionDTO, SDKMode, ILogger, EventData, ISplitFiltersValidation } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -290,7 +288,7 @@ export interface IImpressionsCacheBase {
 
 export interface IEventsCacheBase {
   // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
-  track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
+  track(data: EventData, size?: number): MaybeThenable<boolean>
 }
 
 /** Impressions and events cache for standalone mode (sync) */
@@ -313,8 +311,8 @@ export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderC
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
-  track(data: SplitIO.EventData, size?: number): boolean
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<EventData[]> {
+  track(data: EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
@@ -340,7 +338,7 @@ export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorder
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
-  track(data: SplitIO.EventData, size?: number): Promise<boolean>
+  track(data: EventData, size?: number): Promise<boolean>
 }
 
 /**
@@ -353,17 +351,9 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
 
   // Used by impressions count submitter in standalone and producer mode
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
+  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
 }
 
-export interface IUniqueKeysCacheBase extends IRecorderCacheProducerSync<{ [featureName: string]: ISet<string> }>{
-  // Used by unique Keys tracker
-  track(featureName: string, timeFrame: number, amount: number): void
-
-  // Used by unique keys submitter in standalone and producer mode
-  isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: { [featureName: string]: ISet<string> } ): { [featureName: string]: ISet<string> } // pop cache data
-}
 
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
@@ -454,16 +444,14 @@ export interface IStorageBase<
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
   TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
-  TUniqueKeysCache extends IUniqueKeysCacheBase
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
   impressionCounts?: IImpressionCountsCacheSync,
   events: TEventsCache,
-  telemetry?: TTelemetryCache,
-  uniqueKeys?: TUniqueKeysCache,
+  telemetry?: TTelemetryCache
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -473,8 +461,7 @@ export interface IStorageSync extends IStorageBase<
   ISegmentsCacheSync,
   IImpressionsCacheSync,
   IEventsCacheSync,
-  ITelemetryCacheSync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheSync
   > { }
 
 export interface IStorageAsync extends IStorageBase<
@@ -482,8 +469,7 @@ export interface IStorageAsync extends IStorageBase<
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheAsync
   > { }
 
 /** StorageFactory */
@@ -508,14 +494,39 @@ export interface IStorageFactoryParams {
   metadata: IMetadata,
 }
 
-export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
-
-export type IStorageSyncFactory = {
-  readonly type: StorageType,
-  (params: IStorageFactoryParams): IStorageSync
-}
-
-export type IStorageAsyncFactory = {
-  type: StorageType,
-  (params: IStorageFactoryParams): IStorageAsync
+/**
+ * Defines the format of Split data to preload on the factory storage (cache).
+ */
+export interface PreloadedData {
+  /**
+   * Timestamp of the last moment the data was synchronized with Split servers.
+   * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
+   * @TODO configurable expiration time policy?
+   */
+  lastUpdated: number,
+  /**
+   * Change number of the preloaded data.
+   * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
+   */
+  since: number,
+  /**
+   * Map of splits to their serialized definitions.
+   */
+  splitsData: {
+    [splitName: string]: string
+  },
+  /**
+   * Optional map of user keys to their list of segments.
+   * @TODO remove when releasing first version
+   */
+  mySegmentsData?: {
+    [key: string]: string[]
+  },
+  /**
+   * Optional map of segments to their serialized definitions.
+   * This property is ignored if `mySegmentsData` was provided.
+   */
+  segmentsData?: {
+    [segmentName: string]: string
+  },
 }

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,12 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { SplitIO } from '../../types';
+import { LocalhostFactory } from '../../types';
 
 // Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
+const localhostFromObject: any = syncManagerOfflineFactory(splitsParserFromSettingsFactory);
 localhostFromObject.type = 'LocalhostFromObject';
 
-export function LocalhostFromObject(): SplitIO.LocalhostFactory {
-  return localhostFromObject;
+export function LocalhostFromObject() {
+  return localhostFromObject as LocalhostFactory;
 }

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

@@ -1,23 +1,23 @@
 import { ISplitPartial } from '../../../dtos/types';
-import { ISettings, SplitIO } from '../../../types';
+import { ISettings, MockedFeaturesMap, TreatmentWithConfig } from '../../../types';
 import { isObject, forOwn } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
-function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
+function hasTreatmentChanged(prev: string | TreatmentWithConfig, curr: string | 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 SplitIO.TreatmentWithConfig).treatment || prev.config !== (curr as SplitIO.TreatmentWithConfig).config;
+    return prev.treatment !== (curr as TreatmentWithConfig).treatment || prev.config !== (curr as TreatmentWithConfig).config;
   }
 }
 
 export function splitsParserFromSettingsFactory() {
 
-  let previousMock: SplitIO.MockedFeaturesMap = { 'emptyMock': '1' };
+  let previousMock: MockedFeaturesMap = { 'emptyMock': '1' };
 
-  function mockUpdated(currentData: SplitIO.MockedFeaturesMap) {
+  function mockUpdated(currentData: 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 SplitIO.MockedFeaturesMap || {};
+    const features = settings.features as MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;
 
@@ -53,8 +53,8 @@ export function splitsParserFromSettingsFactory() {
       let config = null;
 
       if (isObject(data)) {
-        treatment = (data as SplitIO.TreatmentWithConfig).treatment;
-        config = (data as SplitIO.TreatmentWithConfig).config || config;
+        treatment = (data as TreatmentWithConfig).treatment;
+        config = (data as 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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../../logger/types';
+import { ILogger } from '../../../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 '../../logger/types';
+import { ILogger } from '../../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,7 +4,6 @@ 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 {
 
@@ -16,7 +15,6 @@ 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

@@ -1,5 +1,5 @@
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
+import { EventData } from '../../types';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -35,24 +35,6 @@ 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,
@@ -79,7 +61,7 @@ export type StoredEventWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored event */
-  e: SplitIO.EventData
+  e: EventData
 }
 
 /**
@@ -166,8 +148,7 @@ export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_E
 
 export type OPTIMIZED_ENUM = 0;
 export type DEBUG_ENUM = 1;
-export type NONE_ENUM = 2;
-export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM | NONE_ENUM;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits

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 '../logger/types';
+import { ILogger } from '../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, SplitIO } from '../types';
+import { ISettings, EventData } 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: SplitIO.EventData, tracked: boolean) {
+  function queueEventsCallback(eventData: 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: SplitIO.EventData, size?: number) {
+    track(eventData: EventData, size?: number) {
       if (settings.userConsent === CONSENT_DECLINED) {
         return isSync ? false : Promise.resolve(false);
       }

package/src/trackers/impressionsTracker.ts

@@ -1,8 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
-import { SplitIO, ImpressionDTO, ISettings } from '../types';
+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 { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 
@@ -13,28 +15,48 @@ 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 strategy strategy for impressions tracking.
+ * @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)
  */
 export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
-  strategy: IStrategy,
   integrationsManager?: IImpressionsHandler,
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
+  // 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
 ): IImpressionsTracker {
 
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
 
   return {
-    track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
+    track(impressions: ImpressionDTO[], attributes?: Attributes) {
       if (settings.userConsent === CONSENT_DECLINED) return;
 
       const impressionsCount = impressions.length;
 
-      const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
-      const impressionsToListenerCount = impressionsToListener.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 res = impressionsCache.track(impressionsToStore);
 
       // If we're on an async storage, handle error and log it.
@@ -49,16 +71,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, deduped);
+          (telemetryCache as ITelemetryCacheSync).recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
         }
       }
 
       // @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 < impressionsToListenerCount; i++) {
-          const impressionData: SplitIO.ImpressionData = {
+        for (let i = 0; i < impressionsCount; i++) {
+          const impressionData: ImpressionData = {
             // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-            impression: objectAssign({}, impressionsToListener[i]),
+            impression: objectAssign({}, impressions[i]),
             attributes,
             ip,
             hostname,

package/src/trackers/types.ts

@@ -1,13 +1,12 @@
-import { SplitIO, ImpressionDTO } from '../types';
+import { ImpressionDTO, EventData, ImpressionData, Attributes } 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 */
 
 export interface IEventsHandler {
-  handleEvent(eventData: SplitIO.EventData): any
+  handleEvent(eventData: EventData): any
 }
 
 export type IEventTracker = IEventsCacheBase
@@ -15,11 +14,11 @@ export type IEventTracker = IEventsCacheBase
 /** Impressions tracker */
 
 export interface IImpressionsHandler {
-  handleImpression(impressionData: SplitIO.ImpressionData): any
+  handleImpression(impressionData: ImpressionData): any
 }
 
 export interface IImpressionsTracker {
-  track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void
+  track(impressions: ImpressionDTO[], attributes?: Attributes): void
 }
 
 /** Telemetry tracker */
@@ -43,32 +42,3 @@ 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
-}