@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/src/sdkClient/client.ts

@@ -1,17 +1,17 @@
 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 { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 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 { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, 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 } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
+import { 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';
+import { trackMethodFactory } from './trackMethod';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
@@ -23,7 +23,7 @@ function treatmentsNotReady(featureFlagNames: string[]) {
   return evaluations;
 }
 
-function stringify(options?: SplitIO.EvaluationOptions) {
+export function stringify(options?: SplitIO.EvaluationOptions) {
   if (options && options.properties) {
     try {
       return JSON.stringify(options.properties);
@@ -35,7 +35,7 @@ function stringify(options?: SplitIO.EvaluationOptions) {
  * 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, fallbackTreatmentsCalculator } = params;
+  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, telemetryTracker, fallbackCalculator } = params;
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
 
@@ -147,16 +147,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
-      const fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+      const fallbackTreatment = fallbackCalculator(featureFlagName, label);
       treatment = fallbackTreatment.treatment;
       label = fallbackTreatment.label;
       config = fallbackTreatment.config;
     }
 
-    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-
-    if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      log.info(IMPRESSION_QUEUEING);
+    if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+      log.info(IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
       queue.push({
         imp: {
           feature: featureFlagName,
@@ -175,42 +173,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     if (withConfig) {
       return {
         treatment,
-        config
+        config: config as string | null
       };
     }
 
     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;
-    }
-  }
+  const track = trackMethodFactory(params);
 
   return {
     getTreatment,

package/src/sdkClient/clientInputValidation.ts

@@ -1,31 +1,27 @@
 import {
   validateAttributes,
-  validateEvent,
-  validateEventValue,
-  validateEventProperties,
   validateKey,
-  validateSplit,
-  validateSplits,
-  validateTrafficType,
+  validateDefinition,
+  validateDefinitions,
   validateIfNotDestroyed,
   validateIfReadyFromCache,
   validateEvaluationOptions
 } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
+import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG } from '../utils/constants';
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
-import { IFallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
+import { IFallbackCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager, fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator): TClient {
+export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager, fallbackCalculator: IFallbackCalculator): TClient {
 
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
@@ -39,14 +35,14 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
       validateFlagSets(log, methodName, maybeNameOrNames as string[], settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
       startsWith(methodName, GET_TREATMENTS) ?
-        validateSplits(log, maybeNameOrNames, methodName) :
-        validateSplit(log, maybeNameOrNames, methodName);
+        validateDefinitions(log, maybeNameOrNames, methodName) :
+        validateDefinition(log, maybeNameOrNames, methodName);
 
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
     const options = validateEvaluationOptions(log, maybeOptions, methodName);
 
-    validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
+    validateIfReadyFromCache(log, readinessManager, methodName);
 
     const valid = isNotDestroyed && key && nameOrNames && attributes !== false;
 
@@ -59,17 +55,20 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     };
   }
 
-  function evaluateFallBackTreatment(featureFlagName: string, withConfig: boolean): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const { treatment, config } = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
+  function evaluateFallBackTreatment(featureFlagName: string | false | string[], withConfig: boolean) {
+    if (Array.isArray(featureFlagName)) {
+      const res: SplitIO.Treatments = {};
+      featureFlagName.forEach((split: string) => res[split] = evaluateFallBackTreatment(split, withConfig) as SplitIO.Treatment);
+      return res;
+    }
+
+    const { treatment, config } = fallbackCalculator(featureFlagName as string);
 
-    if (withConfig) {
-      return {
+    return withConfig ?
+      {
         treatment,
         config
-      };
-    }
-
-    return treatment;
+      } : treatment;
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
@@ -79,104 +78,65 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, false);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, false));
   }
 
   function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const result = evaluateFallBackTreatment(params.nameOrNames as string, true);
-      return wrapResult(result);
-    }
+    return params.valid ?
+      client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames, true));
   }
 
   function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.Treatments = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach((split: string) => res[split] = evaluateFallBackTreatment(split, false) as SplitIO.Treatment);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], false));
   }
 
   function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.TreatmentsWithConfig = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach(split => res[split] = evaluateFallBackTreatment(split, true) as SplitIO.TreatmentWithConfig);
-
-      return wrapResult(res);
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], true));
   }
 
   function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
+    return params.valid ?
+      client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
     const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
 
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
-    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
-    const tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
-    const event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
-    const eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
-    const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
-    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
-
-    if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-      return client.track(key, tt, event, eventValue, properties, size);
-    } else {
-      return isAsync ? Promise.resolve(false) : false;
-    }
+    return params.valid ?
+      client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options) :
+      wrapResult({});
   }
 
   return {
@@ -188,6 +148,6 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatmentsWithConfigByFlagSets,
     getTreatmentsByFlagSet,
     getTreatmentsWithConfigByFlagSet,
-    track
+    track: client.track,
   } as TClient;
 }

package/src/sdkClient/sdkClient.ts

@@ -1,39 +1,16 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import SplitIO from '../../types/splitio';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-
-const COOLDOWN_TIME_IN_MILLIS = 1000;
+import { sdkLifecycleFactory } from './sdkLifecycle';
 
 /**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
-
-  let lastActionTime = 0;
-
-  function __cooldown(func: Function, time: number) {
-    const now = Date.now();
-    //get the actual time elapsed in ms
-    const timeElapsed = now - lastActionTime;
-    //check if the time elapsed is less than desired cooldown
-    if (timeElapsed < time) {
-      //if yes, return message with remaining time in seconds
-      settings.log.warn(`Flush cooldown, remaining time ${(time - timeElapsed) / 1000} seconds`);
-      return Promise.resolve();
-    } else {
-      //Do the requested action and re-assign the lastActionTime
-      lastActionTime = now;
-      return func();
-    }
-  }
+  const { sdkReadinessManager, settings } = params;
 
-  function __flush() {
-    return syncManager ? syncManager.flush() : Promise.resolve();
-  }
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -44,35 +21,9 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
       settings,
       clientFactory(params),
       sdkReadinessManager.readinessManager,
-      params.fallbackTreatmentsCalculator
+      params.fallbackCalculator
     ),
 
-    // Sdk destroy
-    {
-      flush() {
-        // @TODO define cooldown time
-        return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-      },
-      destroy() {
-        // Mark the SDK as destroyed immediately
-        sdkReadinessManager.readinessManager.destroy();
-
-        // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
-        if (!isSharedClient) {
-          releaseApiKey(settings.core.authorizationKey);
-          telemetryTracker.sessionLength();
-          signalListener && signalListener.stop();
-          uniqueKeysTracker.stop();
-        }
-
-        // Stop background jobs
-        syncManager && syncManager.stop();
-
-        return __flush().then(() => {
-          // Cleanup storage
-          return storage.destroy();
-        });
-      }
-    }
+    sdkLifecycleFactory(params, isSharedClient)
   );
 }

package/src/sdkClient/sdkLifecycle.ts

@@ -0,0 +1,78 @@
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
+import { ISdkFactoryContext } from '../sdkFactory/types';
+
+const COOLDOWN_TIME_IN_MILLIS = 1000;
+
+/**
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
+ */
+export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?: boolean): { init(): void; flush(): Promise<void>; destroy(): Promise<void> } {
+  const { sdkReadinessManager, syncManager, storage, settings, telemetryTracker, impressionsTracker, platform } = params;
+
+  let hasInit = false;
+  let lastActionTime = 0;
+
+  const signalListener = platform.SignalListener && new platform.SignalListener(params);
+
+  function __cooldown(func: Function, time: number) {
+    const now = Date.now();
+    //get the actual time elapsed in ms
+    const timeElapsed = now - lastActionTime;
+    //check if the time elapsed is less than desired cooldown
+    if (timeElapsed < time) {
+      //if yes, return message with remaining time in seconds
+      settings.log.warn(`Flush cooldown, remaining time ${(time - timeElapsed) / 1000} seconds`);
+      return Promise.resolve();
+    } else {
+      //Do the requested action and re-assign the lastActionTime
+      lastActionTime = now;
+      return func();
+    }
+  }
+
+  function __flush() {
+    return syncManager ? syncManager.flush() : Promise.resolve();
+  }
+
+  return {
+    init() {
+      if (hasInit) return;
+      hasInit = true;
+
+      if (!isSharedClient) {
+        validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
+        sdkReadinessManager.readinessManager.init();
+        impressionsTracker.start();
+        syncManager && syncManager.start();
+        signalListener && signalListener.start();
+      }
+    },
+
+    flush() {
+      // @TODO define cooldown time
+      return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+    },
+
+    destroy() {
+      hasInit = false;
+      // Mark the SDK as destroyed immediately
+      sdkReadinessManager.readinessManager.destroy();
+
+      // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+      if (!isSharedClient) {
+        releaseApiKey(settings.core.authorizationKey);
+        telemetryTracker.sessionLength();
+        signalListener && signalListener.stop();
+        impressionsTracker.stop();
+      }
+
+      // Stop background jobs
+      syncManager && syncManager.stop();
+
+      return __flush().then(() => {
+        // Cleanup storage
+        return storage.destroy();
+      });
+    }
+  };
+}

package/src/sdkClient/trackMethod.ts

@@ -0,0 +1,59 @@
+import { thenable } from '../utils/promise/thenable';
+import { getMatching } from '../utils/key';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateKey, validateTrafficType, validateEvent, validateEventValue, validateEventProperties, validateIfNotDestroyed } from '../utils/inputValidation';
+import { TRACK, TRACK_FN_LABEL } from '../utils/constants';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+import SplitIO from '../../types/splitio';
+import { ISdkFactoryContext } from '../sdkFactory/types';
+
+/**
+ * Creates a standalone `track` function with input validation.
+ * Reusable by FF SDK client, Configs SDK, and thin-client SDK.
+ */
+export function trackMethodFactory(params: Pick<ISdkFactoryContext, 'settings' | 'eventTracker' | 'telemetryTracker' | 'storage' | 'sdkReadinessManager'>, warnTTExistence = true) {
+  const { settings, storage: { splits }, telemetryTracker, eventTracker, sdkReadinessManager: { readinessManager } } = params;
+  const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
+
+  return function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    // Input validation
+    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+    const trafficTypeName = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+    const eventTypeId = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+    const value = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+    const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
+    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
+
+    if (!(isNotDestroyed && key && trafficTypeName && eventTypeId && value !== false && properties !== false)) {
+      return isAsync ? Promise.resolve(false) : false;
+    }
+
+    // Core logic
+    const stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+
+    const eventData: SplitIO.EventData = {
+      eventTypeId,
+      trafficTypeName,
+      value,
+      timestamp: Date.now(),
+      key: getMatching(key),
+      properties: properties as SplitIO.Properties | undefined
+    };
+
+    // 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.
+    if (warnTTExistence) validateTrafficTypeExistence(log, readinessManager, 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;
+    }
+  };
+}