@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/src/sync/submitters/types.ts

@@ -1,241 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { IMetadata } from '../../dtos/types';
-import SplitIO from '../../../types/splitio';
-import { ISyncTask } from '../types';
-
-type ImpressionPayload = {
-  /** Matching Key */
-  k: string;
-  /** Bucketing Key */
-  b?: string;
-  /** Treatment */
-  t: string;
-  /** Timestamp */
-  m: number;
-  /** Change number */
-  c: number;
-  /** Rule label */
-  r?: string;
-  /** Previous time */
-  pt?: number;
-  /** Stringified JSON object with properties */
-  properties?: string;
-};
-
-export type ImpressionsPayload = {
-  /** Split name */
-  f: string,
-  /** Key Impressions */
-  i: ImpressionPayload[]
-}[]
-
-export type ImpressionCountsPayload = {
-  pf: {
-    /** Split name */
-    f: string
-    /** Time Frame */
-    m: number
-    /** Count */
-    rc: number
-  }[]
-}
-
-export type UniqueKeysItemSs = {
-  /** Split name */
-  f: string
-  /** keyNames */
-  ks: string[]
-}
-
-export type UniqueKeysPayloadSs = {
-  keys: UniqueKeysItemSs[]
-}
-
-export type UniqueKeysPayloadCs = {
-  keys: {
-    /** keyNames */
-    k: string
-    /** Split name */
-    fs: string[]
-  }[]
-}
-
-export type StoredImpressionWithMetadata = {
-  /** Metadata */
-  m: IMetadata,
-  /** Stored impression */
-  i: ImpressionPayload & {
-    /** Feature flag name */
-    f: string
-  }
-}
-
-export type StoredEventWithMetadata = {
-  /** Metadata */
-  m: IMetadata,
-  /** Stored event */
-  e: SplitIO.EventData
-}
-
-export type MultiMethodLatencies = Map<string, MethodLatencies>
-
-export type MultiMethodExceptions = Map<string, MethodExceptions>
-
-export type MultiConfigs = Map<string, TelemetryConfigStats>
-
-/**
- * Telemetry usage stats
- */
-
-export type QUEUED = 0;
-export type DROPPED = 1;
-export type DEDUPED = 2;
-export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
-export type EventDataType = QUEUED | DROPPED;
-export type UpdatesFromSSEEnum = SPLITS | MEMBERSHIPS;
-
-export type SPLITS = 'sp';
-export type IMPRESSIONS = 'im';
-export type IMPRESSIONS_COUNT = 'ic';
-export type EVENTS = 'ev';
-export type TELEMETRY = 'te';
-export type TOKEN = 'to';
-export type SEGMENT = 'se';
-export type MEMBERSHIPS = 'ms';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MEMBERSHIPS;
-
-export type LastSync = Partial<Record<OperationType, number | undefined>>
-export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
-export type HttpLatencies = Partial<Record<OperationType, Array<number>>>
-
-export type TREATMENT = 't';
-export type TREATMENTS = 'ts';
-export type TREATMENT_WITH_CONFIG = 'tc';
-export type TREATMENTS_WITH_CONFIG = 'tcs';
-export type TRACK = 'tr';
-export type TREATMENTS_BY_FLAGSET = 'tf'
-export type TREATMENTS_BY_FLAGSETS = 'tfs'
-export type TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf'
-export type TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs'
-export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK | TREATMENTS_BY_FLAGSET | TREATMENTS_BY_FLAGSETS | TREATMENTS_WITH_CONFIG_BY_FLAGSET | TREATMENTS_WITH_CONFIG_BY_FLAGSETS;
-
-export type MethodLatencies = Partial<Record<Method, Array<number>>>;
-
-export type MethodExceptions = Partial<Record<Method, number>>;
-
-export type CONNECTION_ESTABLISHED = 0;
-export type OCCUPANCY_PRI = 10;
-export type OCCUPANCY_SEC = 20;
-export type STREAMING_STATUS = 30;
-export type SSE_CONNECTION_ERROR = 40;
-export type TOKEN_REFRESH = 50;
-export type ABLY_ERROR = 60;
-export type SYNC_MODE_UPDATE = 70;
-export type StreamingEventType = CONNECTION_ESTABLISHED | OCCUPANCY_PRI | OCCUPANCY_SEC | STREAMING_STATUS | SSE_CONNECTION_ERROR | TOKEN_REFRESH | ABLY_ERROR | SYNC_MODE_UPDATE;
-
-export type StreamingEvent = {
-  e: StreamingEventType, // eventType
-  d?: number, // eventData
-  t: number, // timestamp
-}
-
-// 'telemetry.latencias' and 'telemetry.exceptions' Redis/Pluggable keys
-export type TelemetryUsageStats = {
-  mL?: MethodLatencies, // clientMethodLatencies
-  mE?: MethodExceptions, // methodExceptions
-}
-
-// amount of instant updates that we are doing by avoiding fetching to Split servers
-export type UpdatesFromSSE = {
-  sp?: number, // splits
-  ms?: number, // my segments
-  mls?: number // my large segments
-}
-
-// 'metrics/usage' JSON request body
-export type TelemetryUsageStatsPayload = TelemetryUsageStats & {
-  lS: LastSync, // lastSynchronization
-  hE: HttpErrors, // httpErrors
-  hL: HttpLatencies, // httpLatencies
-  tR: number, // tokenRefreshes
-  aR: number, // authRejections
-  iQ: number, // impressionsQueued
-  iDe: number, // impressionsDeduped
-  iDr: number, // impressionsDropped
-  spC?: number, // splitCount
-  seC?: number, // segmentCount
-  skC?: number, // segmentKeyCount
-  lsC?: number, // largeSegmentCount
-  lskC?: number, // largeSegmentKeyCount
-  sL?: number, // sessionLengthMs
-  eQ: number, // eventsQueued
-  eD: number, // eventsDropped
-  sE: Array<StreamingEvent>, // streamingEvents
-  t?: Array<string>, // tags
-  ufs?: UpdatesFromSSE, // instant updates
-}
-
-/**
- * Telemetry config stats
- */
-
-export type STANDALONE_ENUM = 0;
-export type CONSUMER_ENUM = 1;
-export type CONSUMER_PARTIAL_ENUM = 2;
-export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_ENUM
-
-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 RefreshRates = {
-  sp: number, // splits
-  se?: number, // segments
-  ms?: number, // mySegments
-  im: number, // impressions
-  ev: number, // events
-  te: number, // telemetry
-}
-
-export type UrlOverrides = {
-  s: boolean, // sdkUrl
-  e: boolean, // events
-  a: boolean, // auth
-  st: boolean, // stream
-  t: boolean, // telemetry
-}
-
-// 'telemetry.init' Redis/Pluggable key
-export type TelemetryConfigStats = {
-  oM: OperationMode, // operationMode
-  st: 'memory' | 'redis' | 'pluggable' | 'localstorage', // storage
-  aF: number, // activeFactories
-  rF: number, // redundantActiveFactories
-  t?: Array<string>, // tags
-}
-
-// 'metrics/config' JSON request body
-export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
-  sE: boolean, // streamingEnabled
-  rR: RefreshRates, // refreshRates
-  uO: UrlOverrides, // urlOverrides
-  iQ: number, // impressionsQueueSize
-  eQ: number, // eventsQueueSize
-  iM: ImpressionsMode, // impressionsMode
-  iL: boolean, // impressionsListenerEnabled
-  hP: boolean, // httpProxyDetected
-  tR: number, // timeUntilSDKReady
-  tC?: number, // timeUntilSDKReadyFromCache
-  nR: number, // SDKNotReadyUsage
-  i?: Array<string>, // integrations
-  uC: number, // userConsent
-  fsT: number, // flagSetsTotal
-  fsI: number, // flagSetsInvalid
-}
-
-export interface ISubmitterManager extends ISyncTask {
-  start(onlyTelemetry?: boolean): void,
-  stop(allExceptTelemetry?: boolean): void,
-  execute(onlyTelemetry?: boolean): Promise<any>
-}

package/src/sync/submitters/uniqueKeysSubmitter.ts

@@ -1,35 +0,0 @@
-import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { submitterFactory } from './submitter';
-
-const DATA_NAME = 'unique keys';
-const UNIQUE_KEYS_RATE = 900000; // 15 minutes
-
-/**
- * Submitter that periodically posts impression counts
- */
-export function uniqueKeysSubmitterFactory(params: ISdkFactoryContextSync) {
-
-  const {
-    settings: { log, core: { key } },
-    splitApi: { postUniqueKeysBulkCs, postUniqueKeysBulkSs },
-    storage: { uniqueKeys }
-  } = params;
-
-  const isClientSide = key !== undefined;
-  const postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-
-  const syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
-
-  // 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/syncManagerOnline.ts

@@ -1,195 +0,0 @@
-import { ISyncManagerCS } from './types';
-import { submitterManagerFactory } from './submitters/submitterManager';
-import { IReadinessManager } from '../readiness/types';
-import { IStorageSync } from '../storages/types';
-import { IPushManager } from './streaming/types';
-import { IPollingManager, IPollingManagerCS } from './polling/types';
-import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
-import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
-import { isConsentGranted } from '../consent';
-import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { ISdkFactoryContextSync } from '../sdkFactory/types';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
-
-/**
- * Online SyncManager factory.
- * Can be used for server-side API, and client-side API with or without multiple clients.
- *
- * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
- * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
- * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- */
-export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
-  pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
-): (params: ISdkFactoryContextSync) => ISyncManagerCS {
-
-  /**
-   * SyncManager factory for modular SDK
-   */
-  return function (params: ISdkFactoryContextSync): ISyncManagerCS {
-
-    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
-
-    /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
-
-    /** Push Manager */
-    const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
-      pushManagerFactory(params, pollingManager) :
-      undefined;
-
-    /** Submitter Manager */
-    // It is not inyected as push and polling managers, because at the moment it is required
-    const submitterManager = submitterManagerFactory(params);
-
-    /** Sync Manager logic */
-
-    function startPolling() {
-      if (pollingManager!.isRunning()) {
-        log.info(SYNC_CONTINUE_POLLING);
-      } else {
-        log.info(SYNC_START_POLLING);
-        pollingManager!.start();
-        telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, POLLING);
-      }
-    }
-
-    function stopPollingAndSyncAll() {
-      log.info(SYNC_STOP_POLLING);
-      // if polling, stop
-      if (pollingManager!.isRunning()) {
-        pollingManager!.stop();
-        telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, STREAMING);
-      }
-
-      // fetch splits and segments. There is no need to catch this promise (it is always resolved)
-      pollingManager!.syncAll();
-    }
-
-    if (pushManager) {
-      pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-      pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);
-    }
-
-    let running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
-    let startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
-
-    return {
-      // Exposed for fine-grained control of synchronization.
-      // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
-      pollingManager,
-      pushManager,
-      submitterManager,
-
-      /**
-       * Method used to start the syncManager for the first time, or resume it after being stopped.
-       */
-      start() {
-        running = true;
-
-        // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
-        submitterManager.start(!isConsentGranted(settings));
-
-        return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
-          if (!running) return;
-
-          if (startFirstTime) {
-            // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-
-          }
-
-          // start syncing splits and segments
-          if (pollingManager) {
-
-            // If synchronization is disabled pushManager and pollingManager should not start
-            if (syncEnabled) {
-              if (pushManager) {
-                // Doesn't call `syncAll` when the syncManager is resuming
-                if (startFirstTime) {
-                  pollingManager.syncAll();
-                }
-                pushManager.start();
-              } else {
-                pollingManager.start();
-              }
-            } else {
-              if (startFirstTime) {
-                pollingManager.syncAll();
-              }
-            }
-          }
-
-          startFirstTime = false;
-        });
-      },
-
-      /**
-       * Method used to stop/pause the syncManager.
-       */
-      stop() {
-        running = false;
-
-        // stop syncing
-        if (pushManager) pushManager.stop();
-        if (pollingManager && pollingManager.isRunning()) pollingManager.stop();
-
-        // stop periodic data recording (events, impressions, telemetry).
-        submitterManager.stop();
-      },
-
-      isRunning() {
-        return running;
-      },
-
-      flush() {
-        return submitterManager.execute(!isConsentGranted(settings));
-      },
-
-      // [Only used for client-side]
-      // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side
-      shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync) {
-        if (!pollingManager) return;
-
-        const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
-        if (syncEnabled && pushManager) pushManager.add(matchingKey, mySegmentsSyncTask);
-
-        if (running) {
-          if (syncEnabled) {
-            if (pushManager) {
-              if (pollingManager.isRunning()) {
-                // if doing polling, we must start the periodic fetch of data
-                if (usesSegmentsSync(storage)) mySegmentsSyncTask.start();
-              } else {
-                // if not polling, we must execute the sync task for the initial fetch
-                // of segments since `syncAll` was already executed when starting the main client
-                mySegmentsSyncTask.execute();
-              }
-            } else {
-              if (usesSegmentsSync(storage)) mySegmentsSyncTask.start();
-            }
-          } else {
-            if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
-          }
-        }
-
-        return {
-          stop() {
-            // check in case `client.destroy()` has been invoked more than once for the same client
-            const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);
-            if (mySegmentsSyncTask) {
-              // stop syncing
-              if (pushManager) pushManager.remove(matchingKey);
-              if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
-
-              (pollingManager as IPollingManagerCS).remove(matchingKey);
-            }
-          },
-          flush() { return Promise.resolve(); }
-        };
-      }
-    };
-  };
-}

package/src/sync/syncTask.ts

@@ -1,83 +0,0 @@
-import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
-import { ILogger } from '../logger/types';
-import { ISyncTask } from './types';
-
-/**
- * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
- * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
- *
- * @param log -  Logger instance.
- * @param task -  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
- * @param period -  Period in milliseconds to execute the task.
- * @param taskName -  Optional task name for logging.
- * @returns A sync task that wraps the given task.
- */
-export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
-
-  // Flag that indicates if the task is executing
-  let executing = 0;
-  // Promise chain to resolve tasks sequentially
-  let promiseChain: Promise<Output> | undefined;
-  // flag that indicates if the task periodic execution has been started/stopped.
-  let running = false;
-  // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
-  let runningId = 0;
-  // Params passed to `task` when called periodically
-  let runningArgs: Input;
-  // Id of the periodic call timeout
-  let timeoutID: any;
-
-  function execute(...args: Input): Promise<Output> {
-    executing++;
-    log.debug(SYNC_TASK_EXECUTE, [taskName]);
-
-    // Update `promiseChain` with last promise, to run tasks serially
-    promiseChain = (promiseChain ? promiseChain.then(() => task(...args)) : task(...args))
-      .then(result => {
-        executing--;
-        return result;
-      });
-
-    return promiseChain;
-  }
-
-  function periodicExecute(currentRunningId: number) {
-    return execute(...runningArgs).then((result) => {
-      // Call `setTimeout` if periodic execution was started and `currentRunningId === runningId`
-      // to avoid a race condition when calling `start`, `stop` and `start` again
-      if (running && currentRunningId === runningId) timeoutID = setTimeout(periodicExecute, period, currentRunningId);
-      return result;
-    });
-  }
-
-  return {
-    execute,
-
-    isExecuting() {
-      return executing > 0;
-    },
-
-    start(...args: Input) {
-      if (!running) {
-        running = true;
-        runningId++;
-        runningArgs = args;
-        log.debug(SYNC_TASK_START, [taskName, period]);
-        return periodicExecute(runningId);
-      }
-    },
-
-    stop() {
-      if (running) {
-        running = false;
-        log.debug(SYNC_TASK_STOP, [taskName]);
-        clearTimeout(timeoutID);
-        timeoutID = undefined;
-      }
-    },
-
-    isRunning() {
-      return running;
-    }
-  };
-}

package/src/sync/types.ts

@@ -1,48 +0,0 @@
-import { IReadinessManager } from '../readiness/types';
-import { IStorageSync } from '../storages/types';
-import { IPollingManager } from './polling/types';
-import { IPushManager } from './streaming/types';
-import { ISubmitterManager } from './submitters/types';
-
-export interface ITask<Input extends any[] = []> {
-  /**
-   * Start periodic execution of the task
-   */
-  start(...args: Input): any,
-  /**
-   * Stop periodic execution of the task
-   */
-  stop(): any,
-  /**
-   * Returns true if the task periodic execution is running
-   */
-  isRunning(): boolean
-}
-
-export interface ISyncTask<Input extends any[] = [], Output = any> extends ITask<Input> {
-  /**
-   * Start periodic execution of the task, and returns the promise of the first execution
-   */
-  start(...args: Input): Promise<Output> | void
-  /**
-   * Explicitly executes the task. It can be invoked multiple times. Returns a promise when the task is resolved
-   */
-  execute(...args: Input): Promise<Output>
-  /**
-   * Returns true if the task is being executed
-   */
-  isExecuting(): boolean
-}
-
-/** SyncManager */
-
-export interface ISyncManager extends ITask {
-  flush(): Promise<any>,
-  pushManager?: IPushManager,
-  pollingManager?: IPollingManager,
-  submitterManager?: ISubmitterManager
-}
-
-export interface ISyncManagerCS extends ISyncManager {
-  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined
-}

package/src/trackers/eventTracker.ts

@@ -1,72 +0,0 @@
-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 } from '../types';
-import SplitIO from '../../types/splitio';
-import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
-import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-
-/**
- * Event tracker stores events in cache and pass them to the integrations manager if provided.
- *
- * @param eventsCache - cache to save events
- * @param integrationsManager - optional event handler used for integrations
- */
-export function eventTrackerFactory(
-  settings: ISettings,
-  eventsCache: IEventsCacheBase,
-  whenInit: (cb: () => void) => void,
-  integrationsManager?: IEventsHandler,
-  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
-): IEventTracker {
-
-  const { log, mode } = settings;
-  const isAsync = isConsumerMode(mode);
-
-  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.'}`;
-
-    if (tracked) {
-      log.info(EVENTS_TRACKER_SUCCESS, [msg]);
-      if (integrationsManager) {
-        whenInit(() => {
-          // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(() => {
-            // copy of event, to avoid unexpected behavior if modified by integrations
-            const eventDataCopy = objectAssign({}, eventData);
-            if (properties) eventDataCopy.properties = objectAssign({}, properties);
-            // integrationsManager does not throw errors (they are internally handled by each integration module)
-            integrationsManager.handleEvent(eventDataCopy);
-          });
-        });
-      }
-    } else {
-      log.error(ERROR_EVENTS_TRACKER, [msg]);
-    }
-
-    return tracked;
-  }
-
-  return {
-    track(eventData: SplitIO.EventData, size?: number) {
-      if (settings.userConsent === CONSENT_DECLINED) {
-        return isAsync ? Promise.resolve(false) : false;
-      }
-
-      const tracked = eventsCache.track(eventData, size);
-
-      if (thenable(tracked)) {
-        return tracked.then(queueEventsCallback.bind(null, eventData));
-      } else {
-        // Record when eventsCache is sync only (standalone mode)
-        // @TODO we are not dropping events on full queue yet, so `tracked` is always true ATM
-        if (telemetryCache) (telemetryCache as ITelemetryCacheSync).recordEventStats(tracked ? QUEUED : DROPPED, 1);
-        return queueEventsCallback(eventData, tracked);
-      }
-    }
-  };
-}

package/src/trackers/impressionObserver/ImpressionObserver.ts

@@ -1,20 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { LRUCache } from '../../utils/LRUCache';
-import { IImpressionObserver } from './types';
-
-export class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
-  private cache: LRUCache<K, number>;
-  private hasher: (impression: SplitIO.ImpressionDTO) => K;
-
-  constructor(size: number, hasher: (impression: SplitIO.ImpressionDTO) => K) {
-    this.cache = new LRUCache(size);
-    this.hasher = hasher;
-  }
-
-  testAndSet(impression: SplitIO.ImpressionDTO) {
-    const hash = this.hasher(impression);
-    const previous = this.cache.get(hash);
-    this.cache.set(hash, impression.time);
-    return previous;
-  }
-}