@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/logger/sdkLogger.ts

@@ -1,46 +0,0 @@
-import { LogLevels, isLogLevelString } from './index';
-import SplitIO from '../../types/splitio';
-import { ILogger } from './types';
-import { ERROR_LOGLEVEL_INVALID } from './constants';
-
-/**
- * The public Logger utility API exposed via SplitFactory, used to update the log level.
- *
- * @param log - the factory logger instance to handle
- */
-export function createLoggerAPI(log: ILogger): SplitIO.ILoggerAPI {
-
-  function setLogLevel(logLevel: string) {
-    if (isLogLevelString(logLevel)) {
-      log.setLogLevel(logLevel);
-    } else {
-      log.error(ERROR_LOGLEVEL_INVALID);
-    }
-  }
-
-  return {
-    /**
-     * Enables all the logs.
-     */
-    enable() {
-      setLogLevel(LogLevels.DEBUG);
-    },
-    /**
-     * Sets a custom log Level for the SDK.
-     * @param logLevel - Custom LogLevel value.
-     */
-    setLogLevel,
-    /**
-     * Disables all the log levels.
-     */
-    disable() {
-      // Disabling is equal logLevel none
-      setLogLevel(LogLevels.NONE);
-    },
-    /**
-     * Exposed for usage with setLogLevel
-     */
-    LogLevel: LogLevels
-  };
-
-}

package/src/logger/types.ts

@@ -1,21 +0,0 @@
-import SplitIO from '../../types/splitio';
-
-export interface ILoggerOptions {
-  prefix?: string,
-  logLevel?: SplitIO.LogLevel,
-  showLevel?: boolean, // @TODO remove this param eventually since it is not being set `false` anymore
-}
-
-export interface ILogger extends SplitIO.ILogger {
-  debug(msg: any): void;
-  debug(msg: string | number, args?: any[]): void;
-
-  info(msg: any): void;
-  info(msg: string | number, args?: any[]): void;
-
-  warn(msg: any): void;
-  warn(msg: string | number, args?: any[]): void;
-
-  error(msg: any): void;
-  error(msg: string | number, args?: any[]): void;
-}

package/src/readiness/constants.ts

@@ -1,12 +0,0 @@
-// Splits events:
-export const SDK_SPLITS_ARRIVED = 'state::splits-arrived';
-export const SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
-
-// Segments events:
-export const SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';
-
-// Readiness events:
-export const SDK_READY_TIMED_OUT = 'init::timeout';
-export const SDK_READY = 'init::ready';
-export const SDK_READY_FROM_CACHE = 'init::cache-ready';
-export const SDK_UPDATE = 'state::update';

package/src/readiness/readinessManager.ts

@@ -1,170 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
-import { STORAGE_LOCALSTORAGE } from '../utils/constants';
-
-function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
-  const splitsEventEmitter = objectAssign(new EventEmitter(), {
-    splitsArrived: false,
-    splitsCacheLoaded: false,
-    hasInit: false,
-    initCallbacks: []
-  });
-
-  // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
-  // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
-  splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
-
-  return splitsEventEmitter;
-}
-
-function segmentsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISegmentsEventEmitter {
-  const segmentsEventEmitter = objectAssign(new EventEmitter(), {
-    segmentsArrived: false
-  });
-
-  segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, () => { segmentsEventEmitter.segmentsArrived = true; });
-
-  return segmentsEventEmitter;
-}
-
-/**
- * Factory of readiness manager, which handles the ready / update event propagation.
- */
-export function readinessManagerFactory(
-  EventEmitter: new () => SplitIO.IEventEmitter,
-  settings: ISettings,
-  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter),
-  isShared?: boolean
-): IReadinessManager {
-
-  const readyTimeout = settings.startup.readyTimeout;
-
-  const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
-  const gate: IReadinessEventEmitter = new EventEmitter();
-
-  let lastUpdate = 0;
-  function syncLastUpdate() {
-    const dateNow = Date.now();
-    // ensure lastUpdate is always increasing per event, is case Date.now() is mocked or its value is the same
-    lastUpdate = dateNow > lastUpdate ? dateNow : lastUpdate + 1;
-  }
-
-  // emit SDK_READY_FROM_CACHE
-  let isReadyFromCache = false;
-  if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
-  else splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
-
-  // emit SDK_READY_TIMED_OUT
-  let hasTimedout = false;
-
-  function timeout() { // eslint-disable-next-line no-use-before-define
-    if (hasTimedout || isReady) return;
-    hasTimedout = true;
-    syncLastUpdate();
-    gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
-  }
-
-
-  // emit SDK_READY and SDK_UPDATE
-  let isReady = false;
-  splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
-  segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
-
-  let isDestroyed = false;
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
-  function __init() {
-    isDestroyed = false;
-    if (readyTimeout > 0 && !isReady) readyTimeoutId = setTimeout(timeout, readyTimeout);
-  }
-
-  splits.initCallbacks.push(__init);
-  if (splits.hasInit) __init();
-
-  function checkIsReadyFromCache() {
-    isReadyFromCache = true;
-    // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
-    if (!isReady && !isDestroyed) {
-      try {
-        syncLastUpdate();
-        gate.emit(SDK_READY_FROM_CACHE);
-      } catch (e) {
-        // throws user callback exceptions in next tick
-        setTimeout(() => { throw e; }, 0);
-      }
-    }
-  }
-
-  function checkIsReadyOrUpdate(diff: any) {
-    if (isDestroyed) return;
-    if (isReady) {
-      try {
-        syncLastUpdate();
-        gate.emit(SDK_UPDATE, diff);
-      } catch (e) {
-        // throws user callback exceptions in next tick
-        setTimeout(() => { throw e; }, 0);
-      }
-    } else {
-      if (splits.splitsArrived && segments.segmentsArrived) {
-        clearTimeout(readyTimeoutId);
-        isReady = true;
-        try {
-          syncLastUpdate();
-          if (!isReadyFromCache && settings.storage?.type === STORAGE_LOCALSTORAGE) {
-            isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE);
-          }
-          gate.emit(SDK_READY);
-        } catch (e) {
-          // throws user callback exceptions in next tick
-          setTimeout(() => { throw e; }, 0);
-        }
-      }
-    }
-  }
-
-  return {
-    splits,
-    segments,
-    gate,
-
-    shared() {
-      return readinessManagerFactory(EventEmitter, settings, splits, true);
-    },
-
-    // @TODO review/remove next methods when non-recoverable errors are reworked
-    // Called on consumer mode, when storage fails to connect
-    timeout,
-    // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
-    // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
-    setDestroyed() { isDestroyed = true; },
-
-    init() {
-      if (splits.hasInit) return;
-      splits.hasInit = true;
-      splits.initCallbacks.forEach(cb => cb());
-    },
-
-    destroy() {
-      isDestroyed = true;
-      syncLastUpdate();
-      clearTimeout(readyTimeoutId);
-
-      if (!isShared) splits.hasInit = false;
-    },
-
-    isReady() { return isReady; },
-    isReadyFromCache() { return isReadyFromCache; },
-    isTimedout() { return hasTimedout && !isReady; },
-    hasTimedout() { return hasTimedout; },
-    isDestroyed() { return isDestroyed; },
-    isOperational() { return (isReady || isReadyFromCache) && !isDestroyed; },
-    lastUpdate() { return lastUpdate; }
-  };
-
-}

package/src/readiness/sdkReadinessManager.ts

@@ -1,121 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { promiseWrapper } from '../utils/promise/wrapper';
-import { readinessManagerFactory } from './readinessManager';
-import { ISdkReadinessManager } from './types';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
-
-const NEW_LISTENER_EVENT = 'newListener';
-const REMOVE_LISTENER_EVENT = 'removeListener';
-
-/**
- * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
- * It also updates logs related warnings and errors.
- *
- * @param readyTimeout - time in millis to emit SDK_READY_TIME_OUT event
- * @param readinessManager - optional readinessManager to use. only used internally for `shared` method
- */
-export function sdkReadinessManagerFactory(
-  EventEmitter: new () => SplitIO.IEventEmitter,
-  settings: ISettings,
-  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
-
-  const log = settings.log;
-
-  /** Ready callback warning */
-  let internalReadyCbCount = 0;
-  let readyCbCount = 0;
-  readinessManager.gate.on(REMOVE_LISTENER_EVENT, (event: any) => {
-    if (event === SDK_READY) readyCbCount--;
-  });
-
-  readinessManager.gate.on(NEW_LISTENER_EVENT, (event: any) => {
-    if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
-      if (readinessManager.isReady()) {
-        log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
-      } else if (event === SDK_READY) {
-        readyCbCount++;
-      }
-    }
-  });
-
-  /** Ready promise */
-  const readyPromise = generateReadyPromise();
-
-  readinessManager.gate.once(SDK_READY_FROM_CACHE, () => {
-    log.info(CLIENT_READY_FROM_CACHE);
-  });
-
-  // default onRejected handler, that just logs the error, if ready promise doesn't have one.
-  function defaultOnRejected(err: any) {
-    log.error(err && err.message);
-  }
-
-  function generateReadyPromise() {
-    const promise = promiseWrapper(new Promise<void>((resolve, reject) => {
-      readinessManager.gate.once(SDK_READY, () => {
-        log.info(CLIENT_READY);
-
-        if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(CLIENT_NO_LISTENER);
-        resolve();
-      });
-      readinessManager.gate.once(SDK_READY_TIMED_OUT, (message: string) => {
-        reject(new Error(message));
-      });
-    }), defaultOnRejected);
-
-    return promise;
-  }
-
-
-  return {
-    readinessManager,
-
-    shared() {
-      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
-    },
-
-    incInternalReadyCbCount() {
-      internalReadyCbCount++;
-    },
-
-    sdkStatus: objectAssign(
-      // Expose Event Emitter functionality
-      Object.create(readinessManager.gate),
-      {
-        // Expose the event constants without changing the interface
-        Event: {
-          SDK_READY,
-          SDK_READY_FROM_CACHE,
-          SDK_UPDATE,
-          SDK_READY_TIMED_OUT,
-        },
-
-        ready() {
-          if (readinessManager.hasTimedout()) {
-            if (!readinessManager.isReady()) {
-              return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
-            } else {
-              return Promise.resolve();
-            }
-          }
-          return readyPromise;
-        },
-
-        __getStatus() {
-          return {
-            isReady: readinessManager.isReady(),
-            isReadyFromCache: readinessManager.isReadyFromCache(),
-            isTimedout: readinessManager.isTimedout(),
-            hasTimedout: readinessManager.hasTimedout(),
-            isDestroyed: readinessManager.isDestroyed(),
-            isOperational: readinessManager.isOperational(),
-            lastUpdate: readinessManager.lastUpdate(),
-          };
-        },
-      }
-    )
-  };
-}

package/src/readiness/types.ts

@@ -1,85 +0,0 @@
-import { IStatusInterface } from '../types';
-import SplitIO from '../../types/splitio';
-
-/** Splits data emitter */
-
-type SDK_SPLITS_ARRIVED = 'state::splits-arrived'
-type SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded'
-type ISplitsEvent = SDK_SPLITS_ARRIVED | SDK_SPLITS_CACHE_LOADED
-
-export interface ISplitsEventEmitter extends SplitIO.IEventEmitter {
-  emit(event: ISplitsEvent, ...args: any[]): boolean
-  on(event: ISplitsEvent, listener: (...args: any[]) => void): this;
-  once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
-  splitsArrived: boolean
-  splitsCacheLoaded: boolean
-  hasInit: boolean,
-  initCallbacks: (() => void)[]
-}
-
-/** Segments data emitter */
-
-type SDK_SEGMENTS_ARRIVED = 'state::segments-arrived'
-type ISegmentsEvent = SDK_SEGMENTS_ARRIVED
-
-export interface ISegmentsEventEmitter extends SplitIO.IEventEmitter {
-  emit(event: ISegmentsEvent, ...args: any[]): boolean
-  on(event: ISegmentsEvent, listener: (...args: any[]) => void): this;
-  once(event: ISegmentsEvent, listener: (...args: any[]) => void): this;
-  segmentsArrived: boolean
-}
-
-/** Readiness emitter */
-
-export type SDK_READY_TIMED_OUT = 'init::timeout'
-export type SDK_READY = 'init::ready'
-export type SDK_READY_FROM_CACHE = 'init::cache-ready'
-export type SDK_UPDATE = 'state::update'
-export type SDK_DESTROY = 'state::destroy'
-export type IReadinessEvent = SDK_READY_TIMED_OUT | SDK_READY | SDK_READY_FROM_CACHE | SDK_UPDATE | SDK_DESTROY
-
-export interface IReadinessEventEmitter extends SplitIO.IEventEmitter {
-  emit(event: IReadinessEvent, ...args: any[]): boolean
-}
-
-/** Readiness manager */
-
-export interface IReadinessManager {
-  /** Event emitters */
-  splits: ISplitsEventEmitter,
-  segments: ISegmentsEventEmitter,
-  gate: IReadinessEventEmitter,
-
-  /** Readiness status */
-  isReady(): boolean,
-  isReadyFromCache(): boolean,
-  isTimedout(): boolean,
-  hasTimedout(): boolean,
-  isDestroyed(): boolean,
-  isOperational(): boolean,
-  lastUpdate(): number,
-
-  timeout(): void,
-  setDestroyed(): void,
-  destroy(): void,
-  init(): void,
-
-  /** for client-side */
-  shared(): IReadinessManager,
-}
-
-/** SDK readiness manager */
-
-export interface ISdkReadinessManager {
-  readinessManager: IReadinessManager
-  sdkStatus: IStatusInterface
-
-  /**
-   * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
-   * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
-   */
-  incInternalReadyCbCount(): void
-
-  /** for client-side */
-  shared(): ISdkReadinessManager
-}

package/src/sdkClient/client.ts

@@ -1,217 +0,0 @@
-import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
-import { thenable } from '../utils/promise/thenable';
-import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
-import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
-import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
-import { IEvaluationResult } from '../evaluator/types';
-import SplitIO from '../../types/splitio';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
-import { ISdkFactoryContext } from '../sdkFactory/types';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { Method } from '../sync/submitters/types';
-import { ImpressionDecorated } from '../trackers/types';
-
-const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
-
-function treatmentsNotReady(featureFlagNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
-  featureFlagNames.forEach(featureFlagName => {
-    evaluations[featureFlagName] = treatmentNotReady;
-  });
-  return evaluations;
-}
-
-function stringify(options?: SplitIO.EvaluationOptions) {
-  if (options && options.properties) {
-    try {
-      return JSON.stringify(options.properties);
-    } catch { /* JSON.stringify should never throw with validated options, but handling just in case */ }
-  }
-}
-
-/**
- * Creator of base client with getTreatments and track methods.
- */
-export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
-  const { log, mode } = settings;
-  const isAsync = isConsumerMode(mode);
-
-  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
-
-    const wrapUp = (evaluationResult: IEvaluationResult) => {
-      const queue: ImpressionDecorated[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
-      impressionsTracker.track(queue, attributes);
-
-      stopTelemetryTracker(queue[0] && queue[0].imp.label);
-      return treatment;
-    };
-
-    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeature(log, key, featureFlagName, attributes, storage) :
-      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        Promise.resolve(treatmentNotReady) :
-        treatmentNotReady;
-
-    return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
-  }
-
-  function getTreatmentWithConfig(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions) {
-    return getTreatment(key, featureFlagName, attributes, options, true, GET_TREATMENT_WITH_CONFIG);
-  }
-
-  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENTS) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
-
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
-      const queue: ImpressionDecorated[] = [];
-      const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
-      Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
-      });
-      impressionsTracker.track(queue, attributes);
-
-      stopTelemetryTracker(queue[0] && queue[0].imp.label);
-      return treatments;
-    };
-
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-      isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        Promise.resolve(treatmentsNotReady(featureFlagNames)) :
-        treatmentsNotReady(featureFlagNames);
-
-    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
-  }
-
-  function getTreatmentsWithConfig(key: SplitIO.SplitKey, featureFlagNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions) {
-    return getTreatments(key, featureFlagNames, attributes, options, true, GET_TREATMENTS_WITH_CONFIG);
-  }
-
-  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(method);
-
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
-      const queue: ImpressionDecorated[] = [];
-      const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
-      Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
-      });
-      impressionsTracker.track(queue, attributes);
-
-      stopTelemetryTracker(queue[0] && queue[0].imp.label);
-      return treatments;
-    };
-
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
-      isAsync ?
-        Promise.resolve({}) :
-        {};
-
-    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
-  }
-
-  function getTreatmentsWithConfigByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions) {
-    return getTreatmentsByFlagSets(key, flagSetNames, attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
-  }
-
-  function getTreatmentsByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
-  }
-
-  function getTreatmentsWithConfigByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
-  }
-
-  // Internal function
-  function processEvaluation(
-    evaluation: IEvaluationResult,
-    featureFlagName: string,
-    key: SplitIO.SplitKey,
-    properties: string | undefined,
-    withConfig: boolean,
-    invokingMethodName: string,
-    queue: ImpressionDecorated[]
-  ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const matchingKey = getMatching(key);
-    const bucketingKey = getBucketing(key);
-
-    const { treatment, label, changeNumber, config = null, impressionsDisabled } = evaluation;
-    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-
-    if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      log.info(IMPRESSION_QUEUEING);
-      queue.push({
-        imp: {
-          feature: featureFlagName,
-          keyName: matchingKey,
-          treatment,
-          time: Date.now(),
-          bucketingKey,
-          label,
-          changeNumber: changeNumber as number,
-          properties
-        },
-        disabled: impressionsDisabled
-      });
-    }
-
-    if (withConfig) {
-      return {
-        treatment,
-        config
-      };
-    }
-
-    return treatment;
-  }
-
-  function track(key: SplitIO.SplitKey, trafficTypeName: string, eventTypeId: string, value?: number, properties?: SplitIO.Properties, size = 1024) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
-
-    const matchingKey = getMatching(key);
-    const timestamp = Date.now();
-    const eventData: SplitIO.EventData = {
-      eventTypeId,
-      trafficTypeName,
-      value,
-      timestamp,
-      key: matchingKey,
-      properties
-    };
-
-    // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
-
-    const result = eventTracker.track(eventData, size);
-
-    if (thenable(result)) {
-      return result.then((result) => {
-        stopTelemetryTracker();
-        return result;
-      });
-    } else {
-      stopTelemetryTracker();
-      return result;
-    }
-  }
-
-  return {
-    getTreatment,
-    getTreatmentWithConfig,
-    getTreatments,
-    getTreatmentsWithConfig,
-    getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet,
-    track,
-  } as SplitIO.IClient | SplitIO.IAsyncClient;
-}